Synchronous interrupts are produced by the CPU control unit while executing instructions and are called synchronous because the control unit issues them only after terminating the execution of an instruction.
This interrupt according to temporal relationship with system clock.
Asynchronous interrupts are generated by other hardware devices at arbitrary times with respect to the CPU clock signals..
Maskable Interrupts - Those interrupts whose request can be denied by microprocessor.
eg- RST 1, RST2, RST 5, RST 6.5 etc..
Non maskable Interrupts - Interrupts whose request cannot be denied. eg -RST 4.5 or TRAP ,RESET IN.
. Periodic interrupts to cause a software task to be executed on a periodic basis.

Option-A TRUE: Implementing virtual memory is need to write large program
Option-B TRUE: It require more I/O
Option-C FALSE: Not more addressable memory available.
Option-D TRUE: Virtual memory is faster and easy swapping of process.

Implied → Specified implicitly in the definition of instruction
Immediate→ Registers which are in CPU
Register→ Specified in the register
Register Indirect→ Specified implicitly in the definition of instruction

Before 8085 microprocessors require +5V, -5V and 12V. In 8085 microprocessor need +5 volts supply only.

LDAX: Load accumulator indirect( This instruction copies the contents of that memory location into the accumulator. )
LHLD: Load H and L register direct ( This instruction loads the contents of the 16- bit memory location into the H and L register pair. )
LXI: Load register pair immediate( The instruction loads 16-bit data in the register pair designated in the operand.)
INX: Increment register pair by 1.( It will increment the register value by 1.)

Consider an example, where we have two entities Employee(whose primary key is R₁) and Department(whose primary key is R₂) and a department have many employees and each employee works in one department i.e. many to one relationship.

Candidate key is ab.
Since all a, b, c, d are atomic. So the relation is in 1NF.
Checking the FD's
a → c
b → d
We can see that there is partial dependencies. So it is not 2NF.
So answer is option (A).

TRUE: Persistence is the term used to describe the duration of phosphorescence. Phosphorescence is a process in which energy absorbed by a substance is released relatively slowly in the form of light.
TRUE: The control electrode is used to turn the electron beam on and off.
TRUE: The electron gun creates a source of electrons which are focused into a narrow beam directed at the face of CRT.

Scan converting a circle using Bresenham’s algorithm:
1 Initially X = 0 , Y = R and D = 3 – 2R

2. While (X < Y)

3. Call Draw Circle(X_c, Y_c, X, Y)

4. Set X = X + 1

5. If (D < 0) Then

6. D = D + 4X + 6

7. Else

8. Set Y = Y – 1

9. D = D + 4(X – Y) + 10

10. End If

11. Draw Circle(X_c, Y_c, X, Y) /* calling function call */

12. End While

Side effects of scan conversions are 1. Aliasing
2. Unequal intensity of diagonal lines
3. Overstriking in photographic applications
4. Local or Global aliasing

L = { a², a³, a⁵, a⁷, a¹¹, a¹³, a¹⁷...................}
It is not a regular language. A language is regular if the difference between two consecutive strings is the same or we can say the language is in AP(arithmetic progression). But here if you see the difference between two consecutive strings/terms is not the same. Hence it is not regular.
Statement (C):
L = {ab, aabb, ................... abab, baba, ababa, aababa, baabb, ..................}
It is also not regular language because the difference between two consecutive strings/terms is not same.
Statement (D): L = { a¹, a⁴, a⁹, a¹⁶, a²⁵, a³⁶, a⁴⁹...............}
It is also not a regular language because the difference between two consecutive strings/terms is not the same.

As we know, for any regular expression R,
Rϕ = ϕR=ϕ
So L₁ L₂ * = ϕ
and L₁ * = {ϕ}* = {ϵ}
So L₁L₂* ∪ L₁* = {ϵ}

be closed under intersection but if a language is not closing under either of union or complementation then it can or can not be closed under intersection.
So here, Statement (A) is true because regular language, context sensitive language and recursive language are closed under union and complementation and they are also closing under intersection but recursive enumerable language is closed under union but not under complementation but still it is closed under intersection.
Statement (B): The meaning of given statement is that if a class of languages that is closed under union and intersection then it has to be closed under complementation but if a language is not closing under either of union or intersection then it can or can not be closed under complementation.
So here, Statement (B) is false because regular language, context sensitive language, recursive language and recursively enumerable language are closed under union and intersection but only regular language, context sensitive language and recursive language are closed under complementation , recursively enumerable language is not closing under complementation after being closed under union and intersection.
Hence statement (B) is not true.

Min height of any tree is log_k |W|
For max height (since k>1, consider k=2) , hence it is CNF form and in CNF height is log_2 (|W|+1)
so in general it should be log_k ((|w|-1) / (k-1))

Statement 1: L1 is a context free language because we can easily construct a pushdown automata which can push all a's onto the top of stack and then when b's comes as input for each "b" one "a" will be popped up. If number of a's is equal to number of b's then final stage is reached and string is accepted except the case when 100th "b" came as input we can go to a non final state and if after that any "b" came as input then the transaction can take place to a final state according to the equal number of b's and a's else we remain on that non-final state. So in this way a pushdown automata can be constructed for given language.
Hence L1 is a context free language.
Statement 2: L2 is not a context free language because we can push a's on the top of stack and when b's came as input we can pop one "a" for each "b" so in this way stack will get empty before comparing equal number of a, b and c. For comparing number of "c" the will be no "a or b" on the top of stack.
Hence L2 is not a context free language.

If k=2, 24 + 32 × 2 = 24 + 64 = 88

Each iteration:
h(2) = 2h(1) + 4h(0) = 2 + 4k
h(3) = 2h(2) + 4h(1) = 4 + 8k + 4 = 8 + 8k
h(4) = 2h(3) + 4h(2) = 16 + 16k + 8 +16k = 32k + 24 = 88 (if k=2)

This question can be solved by binomial distribution, ⁿC₁P¹(1-p)^n-1 = nP(1-P)^n-1

Given data,
L = 32 byte
Bandwidth = 64 kbps,
2Tp = 40 millisec
Tt = L / B = 32 *8 / 64*103 = 4 millisec
a= Tp/Tt
Optimal window size (N) = 1 + 2a
N = 1 + 2a ⇒ 1+ (40/4) ⇒ 11
The correct answer is 11. Option-B is more relevant.

Odd number of bit errors can be detected if G(x) contains (x+1) as a factor.

Given data,
-- Message size=48 bytes
-- Packet header=3 bytes
-- 24 packets are carrying 48 bytes of data
-- Packet size=?
Step-1: One packet carries maximum size is= Message size / Transmission message size
= 48 / 24
= 2 bytes
Step-2: Packet size= One packet carries maximum size + new packet header size
= 2 + 3
= 5 byte

To generate the encryption and decryption keys, we can proceed as follows.
1. Generate randomly two “large” primes p and q.
2. Compute n=pq and ∅=(p-1)(q-1).
3. Choose a number e so that
gcd(e,∅)=1
4. Find the multiplicative inverse of e modulo ∅, i.e., find d so that
ed≡1 (mod ∅)
This can be done efficiently using Euclid’s Extended Algorithm.
The encryption public key is K_E=(n,e) and the decryption private key is K_D=(n,d).
The encryption function is
E(M)=M^e mod n
The decryption function is
D(M)=M^d mod n

Given data,
-- A node X on a 10 Mbps network is regulated by a token bucket.
-- Filled rate=2 Mbps
-- Initially token bucket filled time= 16 Megabits
-- Maximum duration time=?
Step-1: Maximum duration time= Initially token bucket filled time / (Regulated token time-Filled rate)
= 16 / (10-2)
= 16 / 8
= 2 seconds

→ The above recurrence is not in the form of Masters theorem. It doesn't apply since f(n)=n/logn is n polynomially smaller than n^{log(base 2) 2-e} for any epsilon>0.
We can apply after converting into n/logn as n*log^-1n
2T(n/2)+n/logn is by taking a=2,b=2 ,k=1 ,p=-1
T(n) = Θ(n^{log(base 2)2} log log n)
= O(n lg lg n)

Theorem: Any decision tree that sorts n elements has height Ω(n lg n).
Proof:
→ The number of leaves l ≥ n!
→ Any binary tree of height h has ≤ 2^h leaves.
→ Hence, n! ≤ l ≤ 2^h
→ Take logs: h ≥ lg(n!)
→ Use Stirling’s approximation: n! > (n/e)ⁿ
→ We get:
h ≥ log(n/e)ⁿ
= nlg(n/e)
= nlg n - n lg e
= Ω(n lg n)

Dijkstra’s algorithm is used on greedy approach for single source shortest path problem.

Merge sort→ Divide and conquer
Huffman coding→ Greedy approach
Optimal polygon triangulation→ Dynamic programming
Subset sum problem → Backtracking
Note: We can also use subset sum problem as well backtracking.

Statement-I: FALSE
→ Abstraction is a process of hiding the implementation details and showing only functionality to the user.
→ The data type created by the data abstraction process is called abstract data type(ADT).
→ ADT is a class of objects whose logical behavior is defined by a set of values and a set of operations.
Statement-II: FALSE
→ Encapsulation is a mechanism to associate the code and data.
→ Encapsulation is wrapping up of data into single unit.

Main program will call the function CBSE(60)
According to the function definition,
Function call CBSE(100) will give the value of 99,
100<100 condition is false and it will return x-1 which is 99
x=CBSE(90)
90<100 is true----> x=CBSE(100) and it will return x-1
CBSE(100) will return 99 to Function CBSE(90) and this function will return to 98(99-1).
Repeat this procedure,
CBSE(60) will return 95

Statement-I and II are TRUE
A class which is declared as abstract is known as an abstract class. It can have abstract and non-abstract methods. It needs to be extended and its method implemented. It cannot be instantiated.
Rules:
1. An abstract class must be declared with an abstract keyword.
2. It can have abstract and non-abstract methods.
3. It cannot be instantiated.
4. It can have constructors and static methods also.
5. It can have final methods which will force the subclass not to change the body of the method.

FALSE: XML tags are case-sensitive.
FALSE: In JavaScript, identifier names are not case-sensitive.
FALSE: Cascading Style Sheets (CSS) can be used with XML.
FALSE: Somel well-formed XML documents must contain a document type definition.

Statement-1:
→ Regression testing is re-running functional and non-functional tests to ensure that previously developed and tested software still performs after a change. If not, that would be called a regression.
→ Changes that may require regression testing include bug fixes, software enhancements, configuration changes, and even substitution of electronic components.
→ As regression test suites tend to grow with each found defect, test automation is frequently involved.
Statement-2: Black box testing methods are
1. Graph-Based Testing Methods
2. Equivalence Partitioning: It is a black box testing technique that divides the input domain of a program into classes of data from which test cases can be derived.
3. Boundary Value Analysis
4. Orthogonal Array Testing

Statement-1: TRUE: Top-down testing typically requires the tester to build method stubs.
Stub is a dummy subprogram. Stub uses the subordinate module’s interface, may do minimal data manipulation, provides verification of entry, and returns control to the module undergoing testing.
Statement-2: FALSE: Bottom up testing typically requires the tester to build test drivers.
Driver is nothing more than a “main program “ that accepts test case data, passes such data to the component(to be tested) and prints relevant results.
Driver is serve to replace modules that are subordinate to (called by) the component to be tested.

Version→ An instance of a system that differs, in some way, from other instances.
Release→ An instance of a system that is distributed to customers.
Variant→ An instance of a system which is functionally identical to other instances, but designed for different hardware/software configurations.

Given data,
-- Functional Point(FP)=352
-- Team=4 persons
-- Average each person(FP) productivity=8
-- Architect month salary=80,000
-- Programmers month salary=2*60,000
-- Tester month salary=50,000
-- projected cost of project=?
Step-1: Total number of months=Functional Point(FP) / (Team* Average each person(FP) productivity)
= 352 / (4*8)
= 352 / 32
= 11 months
Step-2: Total cost of the project= (one Architect month salary + 2*Programmers month salary + one tester month salary) * Total number of months
= (80000 + 2 * 60000 + 50000) * 11
= ₹ 27,50,000

→ Verification: Are we building the product right?
→ Validation: Are we building the right product?
→ Software debugging is the process of discovering the cause of a defect and fixing it.
→ is the process of demonstrating the existence.

Given data,
-- lines of code(LOC)= 50,000 (or 50K)
-- Multiplicative value ‘a’=1.4
-- Exponential ‘b’=1.0
-- Basic COCOMO formula= a*(LOC in K)^b
-- Multiplicative value ‘c’=3.0
-- Exponential ‘d’=0.33
-- Development=c*(basic COCOMO result)^d
Step-1: Basic COCOMO formula= a*(LOC in K)^b
= 1.4*(50)^1.0
= 70 Step-2: Development= c*(basic COCOMO result)^d
= 3(70)^0.33
= 12.18 months

Given data,
-- Total number of pages=64
-- Page size=512
-- Page frames=32
-- Logical address=?
-- physical address=?
Step-1: Logical address=Total number of pages*Page size
= 2⁶*2⁹
= 2¹⁵
Step-2: Physical address= Page size*Page frames
= 2⁹*2⁵
= 2¹⁴

Book block→ Contains boot program and partition table.
Super block→ Information about file system, free block list, free inode list etc.
Inode block→ Contains a table for every file in the file system. Attributes of files are stored here.
Data block→ Contains operating system files as well as program and data files created by users.

Fair-share scheduling is a scheduling algorithm for computer operating systems in which the CPU usage is equally distributed among system users or groups, as opposed to equal distribution among processes.

TRUE: If a user level thread of a process executes a system call, all threads in that process are blocked.
FALSE: Scheduling is application dependent.
FALSE: Thread switching doesn’t require kernel mode privileges.
FALSE: The library procedures invoked for thread management in user level threads are local procedures.
Advantage:
1. user-level threads package can be implemented on an Operating System that does not support threads.
2. User-level threads does not require modification to operating systems.
3. Simple Representation: Each thread is represented simply by a PC, registers, stack and a small control block, all stored in the user process address space.
4. Simple Management: This simply means that creating a thread, switching between threads and synchronization between threads can all be done without intervention of the kernel.
5. Fast and Efficient: Thread switching is not much more expensive than a procedure call.
Disadvantages:
1. User-Level threads are not a perfect solution as with everything else, they are a trade off.
2. There is a lack of coordination between threads and operating system kernel.
3. User-level threads requires non-blocking systems call i.e., a multithreaded kernel.

TRUE: It is generally the parent of the login shell.
TRUE: It has PID 1.
FALSE: It is the second process in the system.
TRUE: Init forks and execs a ‘getty’ process at every port connected to a terminal.

f(n)=c(n)+h(n)
where
f(n)= Best path to reach the destination node
c(n)=Cost of path
h(n)= heuristic value of a node
Cost of choosing B or C is
=(22+3)+(24+2)
=51
Note: We add cost of B and C because they belongs to AND graph.
Cost of choosing A =42+4=46
Since cost of choosing node choosing B or C that’s why we will expand ‘A’.

In Artificial Intelligence (AI), Sequence of levels is present in the planning graph.
→ A planning graph consists of a sequence of levels that correspond to time steps in the LEVELS plan, where level 0 is the initial state.
→ Each level contains a set of literals and a set of actions.
→ The literals are all those that could be true at that time step, depending on the actions executed at preceding time steps.
→ The actions are all those actions that could have their preconditions satisfied at that time step, depending on which of the literals actually hold.
→ The planning graph records only a restricted subset of the possible negative interactions among actions i.e.., it might be optimistic about the minimum number of time steps required for a literal to become true.
→ This number of steps in the planning graph provides a good estimate of how difficult it is to achieve a given literal from the initial state.
→ The planning graph is defined in such a way that it can be constructed very efficiently.
→ Planning graphs work only for propositional planning problems-ones with no variables.

→ Heuristic search is the best method to go for the game playing problem
→ A heuristic is a method that might not always find the best solution but is guaranteed to find a good solution in reasonable time.
Example: Hill Climbing, Simulated Annealing, Best first search,A* algorithm,etc..,

Method-1: Boolean simplification
((R ∨ Q) ∧ (P ∨ Q’))
(R∨Q)∧(P∨Q’)∧(R∨P)
(PR ∨ Q’R ∨ PQ) ∧ (R∨P)
PR ∨ RQ’ ∨ PQR ∨ PR ∨ PRQ’ ∨ PQ
(RQ’∨PQ’R)∨(PQR∨PQ)∨PR
RQ’ ∨ PQ ∨ PR
((R ∨ Q) ∧ (P ∨ Q’) ∧ (R ∨ P))
Method-2: Using Truth table

Statement-1:
A linear grammar is a context free grammar that has at most one nonterminal in the right hand side of each of its productions and language generated by linear grammar is known as a linear language.
ex-1: S→ aSb | ab
ex-2: S→ aS | Sb | ϵ
The grammar for (a)--> S→ϵ,S→SaSbS,S→SbSaS }

which is not linear. It is DCFL
Statement-2:
The example grammar is
S→ aSb | aSbb | ϵ
Hence it is linear language and it is not DCFL.

Option(A): It is incorrect option because using multi-dimensional turing machine we can speed up the process of accepting the language but it does not mean that Single-tape-turing machine can't accept the string that multidimensional turing machine accepts.

Option(B): is also incorrect because both machines are same so they can accept the same string with same speed.

Option(C) : It is correct option because Non deterministic pushdown automata is more powerful than deterministic pushdown automata because by using non-deterministic pushdown automata L= {ww | w belongs to (a,b)*} can be accepted but the same language can't be accepted using deterministic pushdown automata.

Option(D) : it is incorrect option because DFA and NDFA both are equivalent to each other i.e. we can convert DFA into NFA and NFA into DFA. DFA and NFA are equal in powers and can accept the same strings.

Option(A) : it is correct option because L= {aⁿ bⁿ cⁿ} is a context sensitive language and it can also be accepted by the turing machine. Hence every CSL also recursive language.

Option(B): It is incorrect option.

Option(C): Yes it is true that recursively enumerable languages are closed under union.

Option(D): It is a correct option because recursively enumerable and recursive languages are closed under reversal.

NOTE: The difference between recursive and recursively enumerable language is that if a language is recursive then there will be definitely a turing machine which will halt and will say whether the string is accepted or not. But if a language is recursively enumerable then the turing machine will halt if the string is accepted but it is not necessary that the turing machine will halt to indicate that the string is not accepted. in this case the user might end up in infinite wait by thinking that turing machine will halt string acceptance process is still in progress.

A binary linear code with minimum distance 2t + 1 then it can correct up to ‘T’ bits of error.

MS-DOS→ Single user operating system
XENIX→ Multi user operating system. XENIX is a multi-user solution that allows multiple users to be attached via inexpensive terminals to a single machine, thereby allowing the users to share the resources of the machine.
OS/2→ Multi user operating system.

Lempel–Ziv–Welch is a universal lossless data compression algorithm created by Abraham Lempel, Jacob Ziv, and Terry Welch
abbaabbaab
⇒ Dictionary created by L2 - coding will contain words:
a | b | ba | ab | baa | b
b - already present in dictionary
So the words are a, b, ba, ab, baa.
⇒ Hence ‘B’ and ‘D’ both are not present in the dictionary.
Note: (B) and (D) is correct answers

Total input to neuron f(x)=(W^TXX)+Ⲑ
=(0.2*0.2)+(-0.1*0.4)+(0.1*0.2)
=0.04-0.04+0.02
=0.02

Head: The head command is a command-line utility for outputting the first part of files given to it via standard input. It writes results to standard output. By default head returns the first ten lines of each file that it is given.
tr: Translates lowercase to uppercase (or) uppercase to lowercase.
Option-B will display first three lines of file “shortlist” from lower to upper

: w → saves file and remains in editing mode
: x → saves the file and quits editingmode
: q → quits editing mode and no changes are saved to the file
: sh→ escapes unix shell