FORTRAN implementation do not permit recursion because they use the static allocation for variables.
→ Recursion requires dynamic allocation of data.

With initial value y(x₀) = y₀. Here the function f and the initial data x₀ and y₀ are known. The function y depends on the real variable x and is unknown. A numerical method produces a sequence y₀, y₁, y₂, ....... such that y_n approximates y(x₀ + nh) where h is called the step size.
→ The backward Euler method is helpful to compute the approximations i.e.,
y_n+1 = y_n + hf(x _n+1, y_n+1)

(A) Happens when A and B are independent.
(B) Happens when A and B are mutually exclusive.
(C) Not happens.
(D) P(A∪B) ≤ P(A) + P(B) is true because P(A∪B) = P(A) + P(B) - P(A∩B).

If we use "goto" statements then it leads to structural decomposition of code then it is difficult to verify the programs.

In binary search, search for the half of the list and constant time for comparing. So,
∴

Associate property of a group (aob)oc = ao(boc)
For Abelian group, commutative also holds
i.e., (aob) = (boa)
Consider option (C):

Though not mentioned in question, from options it is clear that array index starts from 1 and not 0.
If we assume array index starting from 1 then, i^th row contains i number of non-zero elements. Before i^th row there are (i-1) rows, (1 to i-1) and in total these rows has 1+2+3......+(i-1) = i(i-1)/2 elements.
Now at i^th row, the j^th element will be at j position.
So the index of (i, j)^th element of lower triangular matrix in this new representation is
j = i(i-1)/2

In Intermediate code optimizations can also enhances the probability of optimizer.

In FIFO, whichever comes first that can be removed first. If the variable was initialized very early, it is in set of first pages. So it was removed.
In LRU which can eliminate (or) removed which is least recently used.
In LFU the frequency of the page is more. So it is in constant use so cannot be replaced.

Push 1 Push 2 Push 3 Pop 3 Push 4 Pop 4 Push 5 Pop 5 Pop 2 Pop 1.
→ Remaining options are not possible.

No. of substrings of length
n = 1
(n-1) = 2
(n-2) = 3
So, Total = n(n+1)/2

NPDA to DPDA conversion is not possible. They have different powers.

In linked list finding an element take O(n) which is not suitable for the binary search. And time complexity of binary search is O(log n).

Context free grammars are used to represent syntactic rules while designing a compiler.
Syntactic rules not checking the meaningful things such as if a variable is declared before it use (or) not.
Like this, things are handled by semantic analysis phase.

In quick sort, we use divide and conquer technique.

Passing an array element as a parameter then it gives different output values for the call-by-reference and call-by-name parameters.
{ ........
a[ ] = {1, 2, 3, 4}
i = 0
fun(a[i]);
print a[0];
}
fun(int x)
{
int i = 1;
x = 8;
}
O/p:
Call-by-reference = 8
Call-by-value = 1

A macro body can also have further macro definitions. However, these nested macro definitions aren't valid until the enclosing macro has been expanded. That means enclosing macro must have been called before the macros can be called.

In BFS algorithm, we can randomly select a source vertex and then run, after that whether we need to check distance to each and every vertex from source is still infinite (or) not. If we find any vertex having infinite distance then the graph is not connected.

In asymptotic complexity, we assume sufficiently large n. So, g₁(n) = n² and g₂(n) = n³.
Growth rate of g₁ is less than that of g₂ i.e., g₁(n) = O(g₂(n)) = O(n).

In first fit, block request will be satisfied from the first free block that fits it.
So, request for 300 will be satisfied by 350 size block reducing the free size to 50.
Request for 25, satisfied by 125 size block, reducing it to 125.
Request for 125 satisfied by the 125 size block.
And request for 50 satisfied by 50 size block.
So, all requests can be satisfied.
In best fit strategy, a block request is satisfied by the smallest block in which can fit it. So, request for 300 will be satisfied by 350 size block reducing the free size to 50.
Request for 25, satisfied by 50 size block as its the smallest size that fits 25, reducing it to 25.
Request for 125, satisfied by 150 size block, reducing it to 25.
Now, request for 50 cannot be satisfied as the two 25 size blocks are not contiguous.

For mod-N counter we need ⌈log₂ N⌉ flip flops.

The most important associative operation thats not commutative is function composition. If you have two functions f and g, their composition, usually denoted fog, is defined by
(fog)(x) = f(g(x))
It is associative, (fog)oh = fo(goh), but its usually not commutative. fog is usually not equal to gof.
Note that if fog exists then gof might not even exists.

It is not reflexive as xRx is not possible.
It is symmetric as if xRy then yRx.
It is not antisymmetric as xRy and yRx are possible and we can have x≠y.
It is not transitive as if xRy and yRz then xRz need not be true. This is violated when x=x.
So, symmetry is the answer.

Total no. of subsets with n elements is 2ⁿ.
And so, no. of subsets with odd cardinality is half of total no. of subsets = 2ⁿ /n = 2^n-1

Sum of degree of vertices = 2 × no. of edges
d * n = 2 * |E|
∴ |E| = d*n/2

P(A∩B') = P(A) - P(A∩B)
P₃ = P(A) - P₂
P(A) = P₂ + P₃

P(A∪B∪C) = P(A) + P(B) + P(C) - P(A∩B) - P(B∩C) - P(A∩C) + P(A∩B∩C)
Since all the events are independent, so we can write
P(A∪B∪C) = P(A) + P(B) + P(C) - P(A)P(B) - P(B)P(C) - P(A)P(C) + P(A)P(B) P(C)
= 0.8 + 0.5 + 0.3 - 0.4 - 0.5 - 0.24 + 0.12
= 0.93

For 1 element:
We can't draw lattice with 1 element.
For 2 element:

For 3 element:

For 4 element:

L = 0*1*
L contains all binary strings where a 1 is not followed by a 0.

Note: Out of syllabus.
The major reason of multiplexing address and data bus is to reduce the number of pins for address and data and dedicate those pins for other several functions of micro-processor.

RISC systems use fixed length instruction to simplify pipeline.
Now the challenge is: How to fit multiple sets of instructions types into limited or fixed size instruction format.
Here comes expanding opcode into the picture, So RISC system uses expanding opcode technique to have fixed size instructions.

FA or Finite state machine to add two integers can be constructed using two states:
→ q₀: Start state to represent carry bit is 0.
→ q₁: State to represent carry bit is 1.
The inputs to the FA will be pairs of bits, i.e., 00, 01, 10, 11.

The FA starts in state 1 (since carry is 0) and inputs a pair of bits. If the pair is 11, the FA outputs a '0' and switches to state 2 (since the carry is 1), where the next pair of bits is input and is added to a carry bit of 1.

(i) - (b), (ii) - (c), (iii) - (d), (iv) - (a)

Backus Normal Form (BNF) is a notation technique for context free grammars, often used to describe the syntax of languages used in computing.
Yacc (Yet Another Compiler- Compiler) is a computer program for the UNIXoperating system. It is a LALR parser generator, generating a parser, the part of a compiler that tries to make syntactic sense of the source code, specially a LALR parser, based on an analytic grammar. Yacc is written in portable C.

BCNF decomposition can always be lossless, but itmay not be always possible to get a dependency preserving BCNF decomposition.

Because FD's are defined on the schema itself, not the instance. So, based on the state of the instance we cannot say what holds for schema (there can be many instances for R).

R - (R - S)
→ No need of using Union operation here. → In question they gave (∪, −) but we don't use both.
→ And also they are saying that only the minimum number of operators from (∪, −) which is equivalent to R ∩ S.
So, the expression is minimal.

Because if a set itself is countable then the subset of set is definitely countable.

(i) - (a), (ii) - (b), (iii) - (d), (iv) - (c)

Logical data independence is more difficult to achieve than physical data independence, since application programs are heavily dependent on the logical structure of the data that they access.

Using eigen values, the characteristic equation we get is,
-λ³ + 2λ² - 2 = 0
Using Cayley-Hamiltonian theorem
-A³ + 2A² - 2I = 0
So, A^-1 = 1/2 (2A - A²)
Solving we get,

So, "imply" is False making "does not imply" True.