## Gate 2013

Question 1 |

^{2 }+ y

^{2}. Which one of the following statements is

**TRUE**about ⊕?

Commutative but not associative | |

Both commutative and associative | |

Associative but not commutative | |

Neither commutative nor associative |

A binary relation on a set S is called cumulative if a*b = b*a ∀ x,y∈S.

Associative property:

A binary relation on set is called associative if (a*b)*c = a*(b*c) ∀ x,y∈S.

Given x⊕y = x

^{2}+ y

^{2}--------(1)

Replace x, y in (1)

y⊕x = y

^{2}+ x

^{2}which is same as (1), so this is cumulative

(x⊕y)⊕z = (x

^{2}+ y

^{2}) ⊕ z

= (x

^{2}+ y

^{2}) + z

^{2}

= x

^{2}+ y

^{2}+ z

^{2}+ 2x

^{2}y

^{2}----------(2)

x⊕(y ⊕ z) = x ⊕ (y

^{2}+ z

^{2})

= x

^{2}+ (y

^{2}+ z

^{2})

^{2}

= x

^{2}+ y

^{2}+ z

^{2}+ 2y

^{2z2 ----------- (3) (2) & (3) are not same so this is not associative. }

Question 2 |

8/(2e ^{3}) | |

9/(2e ^{3}) | |

17/(2e ^{3}) | |

26/(2e ^{3}) |

P(x:λ)=(e

^{-λ}λ

^{x})/x! for x = 0,1,2….

‘λ’ is the average number (mean)

Given that mean = λ = 3

The probability of observing fewer than three cars is

P(zero car) + P(one car) + P(two cars)

=(e

^{-3}3

^{0})/0!+(e

^{-3}3

^{1})/1!+(e

^{-3}3

^{2})/2!

=e

^{-3}+e

^{-3}∙3+(e

^{-3})∙9)/2

=(17e

^{-3<})/2

=17/(2e

^{3})

Question 3 |

Try to derive options from the given matrix.

Observe that col 2 + col 3 will reuse x(x+1) term

C

_{2}→ C

_{1}+ C

_{2}

Question 4 |

-256 | |

-128 | |

-127 | |

0 |

^{n-1}to 2

^{n-1}-1.

The smallest 8-bit 2’s complement number is 1000 0000.

MSB is 1. So it is a negative number.

To know the magnitude again take 2’s complement of 1000 0000.

1000 0000

0111 1111 ← 1’s complement

1000 0000 ← 2’s complement (1’s complement +1)

= 128

-128 is 1000 0000 in 2’s complement representation.

Question 5 |

Priority encoder | |

Decoder | |

Multiplexer | |

Demultiplexer |

^{2}× 2 encoder. The inputs have priorities. So, it is a priority encoder.

Question 6 |

O(log n) | |

O(n) | |

O(n log n) | |

O(n ^{2}) |

Selection sort time complexity O(n

^{2}) in terms of number of comparisons. Each of these scans requires one swap for n-1 elements (the final element is already in place).

Question 7 |

O(1) | |

O(log n) | |

O(n) | |

O(n log n) |

Question 8 |

_{1}= ϕ and L

_{2 }= {a}. Which one of the following represents L

_{1}L

_{2}* ∪ L

_{1}*?

{є} | |

ϕ | |

a* | |

{є,a} |

Rϕ = ϕR=ϕ

So L

_{1}L

_{2}* = ϕ

and L

_{1}* = {ϕ}* = {ϵ}

So L

_{1}L

_{2}* ∪ L

_{1}* = {ϵ}

Question 9 |

n/2 | |

n-1 | |

2n-1 | |

2 ^{n} |

1) epsilon production

2) production of the form A → a

Consider the grammar:

S → Sa | a

If we were to derive the string “aaa” whose length is 3 then the number of reduce moves that would have been required are shown below:

S→ Sa

→Saa

→aaa

This shows us that it has three reduce moves. The string length is 3 and the number of reduce moves is also 3. So presence of such kinds of production might give us the answer “n” for maximum number of reduce moves. But these productions are not allowed as per the question.

Also note that if a grammar does not have unit production then the maximum number of reduce moves can not exceed “n” where “n” denotes the length of the string.

3) No unit productions

Consider the grammar:

S→ A

A→ B

B→C

C→a

If we were to derive the string “a” whose length is 1 then the number of reduce moves that would have been required are shown below:

S→ A

A→ B

B→C

C→a

This shows us that it has four reduce moves. The string length is 1 and the number of reduce moves is 4. So presence of such kind of productions might give us the answer “n+1” or even more, for maximum number of reduce moves. But these productions are not allowed as per the question.

Now keeping in view the above points suppose we want to parse the string “abcd”. (n = 4) using bottom-up parsing where strings are parsed finding the rightmost derivation of a given string backwards. So here we are concentrating on deriving right most derivations only.

We can write the grammar which accepts this string which in accordance to the question, (i.e., with no epsilon- and unit-production (i.e., of type A → є and A → B) and no production of the form A→a) as follows:

S→aB

B→bC

C→cd

The Right Most Derivation for the above is:

S → aB (Reduction 3)

→ abC (Reduction 2)

→ abcd (Reduction 1)

We can see here the number of reductions present is 3.

We can get less number of reductions with some other grammar which also doesn’t produce unit or epsilon productions or production of the form A→a:

S→abA

A→ cd

The Right Most Derivation for the above is:

S → abA (Reduction 2)

→ abcd (Reduction 1)

Hence 2 reductions.

But we are interested in knowing the maximum number of reductions which comes from the 1st grammar. Hence total 3 reductions as maximum, which is (n – 1) as n = 4 here.

Question 10 |

**TRUE**if the processes have no I/O operations and all arrive at time zero?

This algorithm is equivalent to the first-come-first-serve algorithm. | |

This algorithm is equivalent to the round-robin algorithm. | |

This algorithm is equivalent to the shortest-job-first algorithm. | |

This algorithm is equivalent to the shortest-remaining-time-first algorithm. |

Question 11 |

GROUP I GROUP II (P) Service oriented computing (1) Interoperability (Q) Heterogeneous communicating systems (2) BPMN (R) Information representation (3) Publish-find-bind (S) Process description (4) XML

P-1, Q-2, R-3, S-4 | |

P-3, Q-4, R-2, S-1 | |

P-3, Q-1, R-4, S-2 | |

P-4, Q-3, R-2, S-1 |

Question 12 |

TCP, UDP, UDP and TCP | |

UDP, TCP, TCP and UDP | |

UDP, TCP, UDP and TCP | |

TCP, UDP, TCP and UDP |

DNS runs over UDP protocol within port no-53.

Email needs, SMTP protocol which runs over TCP protocol within port no –25.

Question 13 |

Encryption: X’s private key followed by Y’s private key; Decryption: X’s public key followed by Y’s public key | |

Encryption: X’s private key followed by Y’s public key; Decryption: X’s public key followed by Y’s private key | |

Encryption: X’s public key followed by Y’s private key; Decryption: Y’s public key followed by X’s private key | |

Encryption: X’s private key followed by Y’s public key; Decryption: Y’s private key followed by X’s public key |

Encryption: Source has to encrypt with its private key for forming Digital signature for Authentication. Source has to encrypt the (M, σ) with Y’s public key to send it confidentially.

Decryption: Destination Y has to decrypt first with its private key, then decrypt using source public key.

Question 14 |

Network layer – 4 times and Data link layer – 4 times | |

Network layer – 4 times and Data link layer – 3 times | |

Network layer – 4 times and Data link layer – 6 times | |

Network layer – 2 times and Data link layer – 6 times |

From above given diagram, its early visible that packet will visit network layer 4 times, once at each node [S, R, R, D] and packet will visit Data Link layer 6 times. One time at S and one time at D, then two times for each intermediate router R as data link layer is used for link to link communication.

One at packet reaches R and goes up from physical –DL-Network and second time when packet coming out of router in order Network –DL-Physical.

Question 15 |

it is on a set of fields that form a candidate key. | |

it is on a set of fields that include the primary key. | |

the data records of the file are organized in the same order as the data entries of the index. | |

the data records of the file are organized not in the same order as the data entries of the index. |

Basically, Indexed column is used to sort the rows of table. Whole data record of file is sorted using index so the correct option is (C).

Question 16 |

X: P(a)P(b)P(c) Y: P(b)P(c)P(d) Z: P(c)P(d)P(a) | |

X: P(b)P(a)P(c) Y: P(b)P(c)P(d) Z: P(a)P(c)P(d) | |

X: P(b)P(a)P(c) Y: P(c)P(b)P(d) Z: P(a)P(c)P(d) | |

X: P(a)P(b)P(c) Y: P(c)P(b)P(d) Z: P(c)P(d)P(a) |

Question 17 |

1. For every non-deterministic Turing machine, there exists an equivalent deterministic Turing machine. 2. Turing recognizable languages are closed under union and complementation. 3. Turing decidable languages are closed under intersection and complementation. 4. Turing recognizable languages are closed under union and intersection.

1 and 4 only | |

1 and 3 only | |

2 only | |

3 only |

Turing recognizable means recursively enumerable languages which is closed under UNION but they are not closed under complementation, so statement 2 is false.

Turing decidable means recursive languages and they are closed under Intersection and complementation.

Turing recognizable means recursively enumerable languages which is closed under UNION and INTERSECTION.

Question 18 |

1. The problem of determining whether there exists a cycle in an undirected graph is in P. 2. The problem of determining whether there exists a cycle in an undirected graph is in NP. 3. If a problem A is NP-Complete, there exists a non-deterministic polynomial time algorithm to solve A.

1, 2 and 3 | |

1 and 2 only | |

2 and 3 only | |

1 and 3 only |

1. Detecting cycle in a graph using DFS takes O(V+E)=O(V

^{2})

Here, for complete graph E<= V

^{2}. So, It runs in polynomial time.

2. Every P-problem is NP because P subset of NP (P ⊂ NP)

3. NP – complete ∈ NP.

Hence, NP-complete can be solved in non-deterministic polynomial time.

Question 19 |

Θ(n ^{2}) | |

Θ(n ^{2} log n) | |

Θ(n ^{3}) | |

Θ(n ^{3} log n) |

Bellman–Ford runs in O(|V| * |E|) time, where |V| and |E| are the number of vertices and edges respectively.

Note: For complete graph: |E| = n(n-1)/2 = O(n

^{2})

Question 20 |

(j mod v) * k to (j mod v) * k + (k-1) | |

(j mod v) to (j mod v) + (k-1) | |

(j mod k) to (j mod k) + (v-1) | |

(j mod k) * v to (j mod k) * v + (v-1) |

Question 21 |

**NOT**represent exclusive NOR of x and y?

xy+x'y' | |

x⊕y' | |

x'⊕y | |

x'⊕y' |

x’ ⊕ y’ = xy’ + x’y = x⊕y. Hence option D is correct.

Question 22 |

At x = 3, f(x) = 2

LHL (3), f(3

^{-})=(x+3 )/3=(3+3)/3=2

RHL (3), f(3

^{+})=x-1=3-1=2

∴ f(x) is continuous.

Option B:

At x = 3, f(x) = 4

For x ≠ 3, f(x)=f(3

^{+})=f(3

^{-})=8

^{-x}=8-3=5

This is not continuous.

Option C:

At x ≤ 3, f(x) = x+3 = 3+3 = 6

At RHL(3), f(3

^{+})=4

This is not continuous.

Option D:

f(x) at x=3 is not defined.

There is a break at x=3, so this is not continuous.

Question 23 |

8.983 | |

9.003 | |

9.017 | |

9.045 |

Question 24 |

1/8 | |

1 | |

7 | |

8 |

The probability that there exists one edge between two vertices = 1/2

So, the total probability that all three edges of the above exists

= 1/2 × 1/2 × 1/2 (as they are independent events)

= 1/8

Total number of ways in which we can select ‘3’ such vertices among ‘8’ vertices =

^{8}C

_{3}= 56

Total number of cycles of length ‘3’ out of 8 vertices = 56 × 1/8 = 7

Question 25 |

P: Number of odd degree vertices is even. Q: Sum of degrees of all vertices is even.

P only | |

Q only | |

Both P and Q | |

Neither P nor Q |

The sum of the degrees of all the vertices of a graph is an even number (exactly twice the number of edges).

In every graph, the number of vertices of odd degree must be even.

Question 26 |

(P) The line graph of a cycle is a cycle. (Q) The line graph of a clique is a clique. (R) The line graph of a planar graph is planar. (S) The line graph of a tree is a tree.

P only | |

P and R only | |

R only | |

P, Q and S only |

R) False. We can give counter example. Let G has 5 vertices and 9 edges which is planar graph. Assume degree of one vertex is 2 and of all others are 4. Now, L(G) has 9 vertices (because G has 9 edges) and 25 edges. But for a graph to be planar,

|E| ≤ 3|v| - 6

For 9 vertices |E| ≤ 3 × 9 - 6

⇒ |E| ≤ 27 - 6

⇒ |E| ≤ 21. But L(G) has 25 edges and so is not planar.

As (R) is false, option (B) & (C) are eliminated.

Question 27 |

"None of my friends are perfect."

∃x(F(x)∧¬P(x)) | |

∃x(¬F(x)∧P(x)) | |

∃x(¬F(x)∧¬P(x)) | |

¬∃x(F(x)∧P(x)) |

P(x) = x is perfect

The meaning of ∃x(P(x)∧F(x)) is atleast one person who is my friend and perfect.

The negation of ∃x(P(x)∧F(x)) is “This is not the case that atlease one person who is my friend and perfect”.

So ~∃x(P(x)∧F(x)) is none of my friends are perfect.

Question 28 |

MBR ← PC MAR ← X PC ← Y Memory ← MBRWhich one of the following is a possible operation performed by this sequence?

Instruction fetch | |

Operand fetch | |

Conditional branch | |

Initiation of interrupt service |

Question 29 |

1281 | |

1282 | |

1283 | |

1284 |

Suppose we have x cylinders & in each cylinder we have 16 surface and 64 sectors so we need to store 42797 KB of data.

x * 16* 64 *512 + 16*64* 512 + 64* 512 = 42797 KB , by solving this we get x = 82.5 so we need 83 cylinders.

We can add this to the no. of cylinders in the starting address <1200, 9 ,40 >, i.e. 1200, but we also need to cover 40 more sectors which will need one more cylinder, this cylinder is not full but still it has to be accommodated.

Hence 1200+83+1 = 1284 and currently we will be on 1284 cylinder.

Question 30 |

Θ(1) | |

Θ(√logn) | |

Θ (logn/loglogn) | |

Θ(log n) |

So, Θ((logn/ log log n)log(logn/log log n))

= Θ(logn/log logn (log logn - log log logn))

= Θ((log n/log logn) × log log n)

= Θ (log n)

Hence, option (C) is correct answer.

Question 31 |

`int` `unknown(` `int` `n) {` ` ` `int` `i, j, k = 0;` ` ` `for` `(i = n/2; i <= n; i++)` ` ` `for` `(j = 2; j <= n; j = j * 2)` ` ` `k = k + n/2;` ` ` `return` `k;` ` ` `}` |

Θ(n ^{2}) | |

Θ(n ^{2} log n) | |

Θ(n ^{3}) | |

Θ(n ^{3} logn) |

So, the total number of times loop runs is (n/2 logn).

So, the final k value will be n/2*(n/2 logn) = O(n

^{2}logn)

= (n/2+1).n/2 ∙log n

= (n

^{2}log n)

Question 32 |

L _{2} is context-free. | |

L _{1}∩ L_{2} is context-free. | |

Complement of L _{2} is recursive. | |

Complement of L _{1} is context-free but not regular. |

_{1}= 0*1*0* which is regular language and in L

_{2}we have one comparison (i.e. p ≠ r) so it is CFL.

Intersection of a regular language with a context free language is context free language (by closure properties of regular language) So L

_{1}∩ L

_{2}is context-free.

L

_{2}is CFL and CFL is not closed under complementation so we have to assume L

_{2}as CSL (since every CFL is CSL) and CSL is closed under complement so Complement of L

_{2}must be CSL and every CSL is recursive so Complement of L

_{2}is recursive.

Since L

_{1}is regular and regular language is closed under complement so complement of L

_{1}must be regular and hence the statement Complement of L

_{1}is context-free but not regular is a false statement.

Question 33 |

1. Complement of L(A) is context-free. 2. L(A) = L((11*0+0)(0 + 1)*0*1*) 3. For the language accepted by A, A is the minimal DFA. 4. A accepts all strings over {0, 1} of length at least 2.

1 and 3 only | |

2 and 4 only | |

2 and 3 only | |

3 and 4 only |

The regular expression corresponding to the given FA is

Hence we have regular expression: (11*0 +0) (0+1)*

Since we have (0+1)* at the end so if we write 0*1* after this it will not have any effect, the reason is whenever string ends with the terminals other than 1*0* there we can assume 1*0* as epsilon.

So it is equivalent to (11*0 +0) (0+1)*0*1*

The given DFA can be minimised, since the non-final states are equivalent and can be merged and the min DFA will have two states which is given below:

Hence statement 3 is false.

Since DFA accept string “0” whose length is one, so the statement “A accepts all strings over {0, 1} of length at least 2” is false statement.

Question 34 |

-2 | |

-1 | |

1 | |

2 |

Suppose, 'W' executes first, and makes value of semaphore S=1. Now it increment value of x to 1 and comes out and make S=2. Now 'X' executes, where the value of x=1 is stored in R

_{1}and then R

_{1}is incremented and value in R

_{1}is 2. Now 'X' gets preempted. Also to be noted that value of semaphore S is now '1' because the execution during process X got preempted and wasn't able to increase value of S to 2.

Now process Y will get completely execute and then Z will get completely execute. Now the value of 'x' is -3. Now again 'X' will get executed and the value stored in R

_{1}i.e., '2' will get stored in 'x'. So the value in 'x' will be finally 2.

So the maximum possible value of 'x' is 2.

Question 35 |

I, II, III and IV | |

I, II and III only | |

I, II and IV only | |

II, III and IV only |

Question 36 |

1 | |

2 | |

2.5 | |

5 |

^{6}bits ------ 1 sec

∴10

^{4}bits -----5×10

^{8}/10

^{4}=10

^{4}/5×10

^{8}sec=1/5×10

^{4}sec

1 sec------2×10

^{5}km

1/5×10

^{4}-----2×10

^{5}/5×10

^{4}= 4 km

Maximum length of cable=4/2=2 km

Question 37 |

Last fragment, 2400 and 2789 | |

First fragment, 2400 and 2759 | |

Last fragment, 2400 and 2759 | |

Middle fragment, 300 and 689 |

HLEN = 10 - So header length is 4×10=40, as 4 is constant scale factor.

Total Length = 400 (40 Byte Header + 360 Byte Payload)

Fragment Offset = 300, that means 300×8 Byte = 2400 bytes are before this last fragment.

So the position of datagram is last fragment.

Sequence number of First Byte of Payload = 2400 (as 0 to 2399 Sequence no are used)

Sequence number of Last Byte of Payload = 2400+360-1=2759

Question 38 |

There is no change. | |

Average cohesion goes up but coupling is reduced. | |

Average cohesion goes down and coupling also reduces. | |

Average cohesion and coupling increase. |

Question 39 |

Which one of the following represents the CORRECT implementations of ExitX and EntryY?Process X:Process Y:private i; private i; for (i=0; i < n; i++) { for (i=0; i < n; i++) { a[i] = f(i); EntryY(R, S); ExitX(R, S); b[i]=g(a[i]); } }

ExitX(R,S) { P(R); V(S); } EntryY(R,S) { P(S); V(R); } | |

ExitX(R,S) { V(R); V(S); } EntryY(R,S) { P(R); P(S); } | |

ExitX(R,S) { P(S); V(R); } EntryY(R,S) { V(S); P(R); } | |

ExitX(R,S) { V(R); P(S); } EntryY(R,S) { V(S); P(R); } |

Option C - Correct because each and every value inserted by the process X in the array will be immediately consumed by process Y.

Question 40 |

X -> c.X, c/d X -> .cX, c/d X -> .d, c/d X -> c.X, $ X -> .cX, $ X -> .d, $Which of the following statements related to merging of the two sets in the corresponding LALR parser is/are FALSE?

- Cannot be merged since look aheads are different.
- Can be merged but will result in S-R conflict.
- Can be merged but will result in R-R conflict.
- Cannot be merged since goto on c will lead to two different sets.

1 only | |

2 only | |

1 and 4 only | |

1, 2, 3 and 4 |

In the given LR(1) items there is not any reduce move, so after merging it will not have SR conflict and hence statement 2 and statement 3 are false.

Statement 4 is also wrong, because goto is carried on Non-Terminals symbols, not on terminal symbols, and c is a terminal symbol.

Hence all statements are false.

Question 41 |

3 only | |

3 and 4 only | |

1, 2 and 3 only | |

2 and 3 only |

Completeness problem for context free language is undecidable, so 2 is undecidable.

Whether language generated by a Turing machine is regular is also undecidable, so 3 is undecidable.

Language accepted by an NFA and by a DFA is equivalent is decidable, so 4 is decidable.

Question 42 |

`int` `f(` `int` `&x, ` `int` `c) {` ` ` `c = c - 1;` ` ` `if` `(c==0) ` `return` `1;` ` ` `x = x + 1;` ` ` `return` `f(x,c) * x;` `}` |

3024 | |

6561 | |

55440 | |

161051 |

f(5,5)→f(x,4)*x

f(x,3)*x*x

f(x,2)*x*x*x

⇒x*x*x*x=x

^{4}

Now x=x+1, there are 4 different calls namely f(6,4),f(7,3),f(8,2),f(9,1)

Because of pass by reference, x in all earlier functions is replaced with 9.

⇒ 9*9*9*9=9

^{4}=6561

Question 43 |

10, 20, 15, 23, 25, 35, 42, 39, 30 | |

15, 10, 25, 23, 20, 42, 35, 39, 30 | |

15, 20, 10, 23, 25, 42, 35, 39, 30 | |

15, 10, 23, 25, 20, 35, 42, 39, 30 |

From the data,

The Postorder traversal sequence is:

→ 15, 10, 23, 25, 20, 35, 42, 39, 30.

Question 44 |

MultiDequeue(Q){ m = k while (Q is not empty and m > 0) { Dequeue(Q) m = m - 1 } }What is the worst case time complexity of a sequence of n MultiDequeue() operations on an initially empty queue? (GATE CS 2013)

Θ(n) | |

Θ(n + k) | |

Θ(nk) | |

Θ(n ^{2}) |

Question 45 |

_{1}, I

_{2}, I

_{3}, ..., I

_{12}is executed in this pipelined processor. Instruction I

_{4}is the only branch instruction and its branch target is I

_{9}. If the branch is taken during the execution of this program, the time (in ns) needed to complete the program is

132 | |

165 | |

176 | |

328 |

Cycle time = max of all stage delays + buffer delay = max (5 ns, 7 ns, 10 ns, 8 ns, 6 ns) + 1 = 10+1 = 11ns

Out of all the instructions I

_{1}, I

_{2}, I

_{3}....I

_{12}it is given that only I

_{4}is a branch instruction and when I

_{4}takes branch the control will jump to instruction I

_{9}as I

_{9}is the target instruction.

As can be seen from the timing diagram there is a gap of only 3 stall cycles between I

_{4}and I

_{9}because after I

_{4}enters Decode Instruction (DI) whether there is a branch or not will be known at the end of Execute Instruction (EI) phase. So there are total 3 phases here namely DI, FO, EI. After 3 stall cycles I

_{9}will start executing as that is the branch target.

As per the timing diagram total no. of clock cycles to complete the program = 15

Since 1 clock cycle = 11ns, time to complete the program = 15*11 = 165ns

Question 46 |

4 | |

5 | |

6 | |

7 |

Capacity of the chips available = 1K

No. of address lines = 16K/1K = 16

Hence we can use 4 × 16 decoder for this. But we were only given 2 × 4 decoders.

So 4 decoders are required in inner level as from one 2×4 decoder we have only 4 output lines whereas we need 16 output lines.

Now to point to these 4 decoders, another 2×4 decoder is required in the outer level.

Hence no. of 2×4 decoders to realize the above implementation of RAM = 1 + 4 = 5

Question 47 |

**NOT**logically equivalent to ¬∃x(∀y(α) ∧ ∀z(β))?

∀x(∃z(¬β)→∀y(α)) | |

∀x(∀z(β)→∃y(¬α)) | |

∀x(∀y(α)→∃z(¬β)) | |

∀x(∃y(¬α)→∃z(¬β)) |

∀x(∃z(¬β) → ∀y(α))

⇒ ∀x(¬∃z(¬β) ∨ ∀y(α))

⇒ ∀x(∀z(β)∨y(α))

⇒ ¬∃x¬(∀z(β)∨∀y(α))

⇒ ¬∃x(¬∀z(β)∧¬∀y(α))

A is Not equivalent to the given.

Option B:

∀x(∀z(β)→∃y(¬α))

⇒ ∀x(¬∀z(β)∨∃y(¬α))

⇒ ¬∃x¬(¬∀z(β)∨∃y(¬α))

⇒ ¬∃x(∀z(β)∨∀y(α))

B is Matching and equivalent to given.

Option C:

∀x(∀y(α)→∃z(¬β))

⇒ ∀x(¬∀y(α)∨∃z(¬β))

⇒ ¬∃x¬(¬∀y(α)∨∃z(¬β))

⇒ ¬∃x(∀y(α)∧z(β))

C is equivalent to the given.

Option D:

∀x(∃y(¬α)→∃z(¬β))

⇒ ∀x(¬∃y(¬α)∨∃z(β))

⇒ ∀x(∀y(α)∨∃z(β))

⇒ ¬∃x¬(∀y(α)∨∃z(β))

⇒ ¬∃x(¬∀y(α)∧¬∃z(β))

⇒ ¬∃x(¬∀y(α)∧∀z(¬β))

So D is Not equivalent to the given.

Question 48 |

0 | |

1 | |

2 | |

3 |

In the above code total number of spills to memory is 1.

Question 49 |

c = a + b; d = c * a; e = c + a; x = c * c; if (x > a) { y = a * a; } else { d = d * d; e = e * e; }Suppose the instruction set architecture of the processor has only two registers. The only allowed compiler optimization is code motion, which moves statements from one place to another while preserving correctness. What is the minimum number of spills to memory in the compiled code?

3 | |

4 | |

5 | |

6 |

_{1}← a, R

_{2}← b

The 1st statement c = a + b; can be written as R

_{2}= R

_{1}+R

_{2}, here R

_{2}is used to store the value of 'c' as we don't need 'b' any further.

Let R

_{3}be used to store 'd', so we can write the 2nd statement d = c * a; as R

_{3}= R

_{2}*R

_{1}

Let R

_{4}be used to store 'e', so we can write the 3rd statement e = c + a; as R

_{4}= R

_{2}+R

_{1}

We can reuse R

_{2}to store 'x' as the value of 'c' is not needed after statement-4.

We can write the 4th statement x = c*c; as R

_{2}= R

_{2}*R

_{2};

Using the four registers R

_{1}, R

_{2}, R

_{3}and R

_{4}we can write the remaining statements of the program without needing any new registers...

if (x > a) {

y = a * a;

}

else {

d = d * d;

e = e * e;

}

So the minimum no. of registers needed is 4.

Question 50 |

Only one | |

Only two | |

Only three | |

All four |

{

for (int i=0; i<5; i++)

for (int j=0; j<3; j++)

if (A[i] = = oldc[j])

A[i] = newc[j];

}

The procedure is tested with the following four test cases.

1. oldc = “abc”, newc = ”dab”

2. oldc = “cde”, newc = ”bcd”

3. oldc = “bca”, newc = ”cda”

4. oldc = “abc”, newc = ”bac”

Given input string of length 5 consisting of a, b, c, d, e, duplicates allowed.

Similarly for (4), we done 2 replacements for A[0] with element newc[0] & newc[1].

Updating the newc value with another newc value is called as a flaw here. Hence 2 flaws.

Question 51 |

The procedure given below is required to find and replace certain characters inside an input character string supplied in array A. The characters to be replaced are supplied in array oldc, while their respective replacement characters are supplied in array newc. Array A has a fixed length of five characters, while arrays oldc and newc contain three characters each. However, the procedure is flawed

void find_and_replace(char *A, char *oldc, char *newc) { for (int i = 0; i < 5; i++) for (int j = 0; j < 3; j++) if (A[i] == oldc[j]) A[i] = newc[j]; }

The procedure is tested with the following four test cases (1) oldc = "abc", newc = "dab" (2) oldc = "cde", newc = "bcd" (3) oldc = "bca", newc = "cda" (4) oldc = "abc", newc = "bac" The tester now tests the program on all input strings of length five consisting of characters ‘a’, ‘b’, ‘c’, ‘d’ and ‘e’ with duplicates allowed. If the tester carries out this testing with the four test cases given above, how many test cases will be able to capture the flaw?

None | |

2 only | |

3 and 4 only | |

4 only |

1, 2 works fine, 3, 4 carries flaw.

Question 52 |

2 | |

4 | |

8 | |

16 |

^{p}B

So the no. of entries in one page is 2

^{p}/4, where 4 is the page table entry size given in question.

So we know that process size or virtual address space size is equal to

No. of entries × Page size

So total no. of entries for 3 level page table is,

(2

^{p}/4)×(2

^{p}/4)×(2

^{p}/4)

So, No. of entries × Page size = VAS

(2

^{p}/4)×(2

^{p}/4)×(2

^{p}/4)× (2

^{p}) = 2

^{46}

2

^{4p}= 2

^{52}

4p = 52

p = 13

∴ Page size = 2

^{13}

Question 53 |

2 | |

4 | |

8 | |

16 |

Architecture of virtual indexed physically tagged (VIPT):

VIPT cache and aliasing effect and synonym.

Alias: Same physical address can be mapped to multiple virtual addresses.

Synonym: Different virtual addresses mapped to same physical address (for data sharing).

So these synonyms should be in same set to avoid write-update problems.

In our problem VA = 46bits

We are using 16bits for indexing into cache.

To have two synonym is same set we need to have same 16 bits index for PA & VA.

Assume that physical pages are colored and each set should have pages of same color so that any synonyms are in same set.

Since page size = 8KB ⇒ 13bits

These 13bits are not translated during VA→PA. So 13bits are same out of 16 Index bits, 13 are same we need to make 3bits (16-13) same now.

3bits can produce, 2

^{3}= 8 combinations which can be mapped on the different sets, so we need 8 different colors to color our pages. >br> In physically indexed cache indexing is done via physical address bits, but in virtual indexed cache, cache is indexed from (offset + set) bits. In physical Index cache indexing is done one to one (1 index maps to one page in one block of cache). In VIPT we have more/ extra bits, so mapping is not one-one. Hence these extra bits have to be taken care, such that if two virtual address refers to same page in cache block of different sets then they have to be assumed same i.e., we say of same color and put same color page in one set to avoid write update problems.

Question 54 |

3 | |

4 | |

5 | |

6 |

Now D+ = {D}.

Hence we have to add A,B,C,E,F,G,H to D and check which of them are Candidate keys of size 2.

AD

^{+}= {ABCDEFGH}

BD

^{+}= {ABCDEFGH}

ED

^{+}= {ABCDEFGH}

FD

^{+}= {ABCDEFGH}

But CD

^{+}, GD

^{+}and HD

^{+}does not give all the attributes hence CD, GD and HD are not candidate keys.

Hence no. of candidate keys are 4: AD, BD, ED, FD.

Question 55 |

in 1NF, but not in 2NF. | |

in 2NF, but not in 3NF. | |

in 3NF, but not in BCNF. | |

in BCNF. |

Now D+ = {D}.

Hence we have to add A,B,C,E,F,G,H to D and check which of them are Candidate keys of size 2.

AD

^{+}= {ABCDEFGH}

BD

^{+}= {ABCDEFGH}

ED

^{+}= {ABCDEFGH}

FD

^{+}= {ABCDEFGH}

But CD

^{+}, GD

^{+}and HD

^{+}does not give all the attributes hence CD, GD and HD are not candidate keys.

Here Candidate keys are AD, BD, ED and FD.

A → BC, B → CFH and F → EG etc are partial dependencies.

So given relation is in 1NF, but not in 2NF.

Question 56 |

**Nadir**

Highest | |

Lowest | |

Medium | |

Integration |

Question 57 |

specificity | |

neutrality | |

generality | |

adaptation |

Particularism = Exclusive attachment to one's own group, party (or) Nation.

Diffuseness = The spatial property of being spread out over a wide area (or) through a large volume.

Specificity = The quality of belonging (or) relating uniquely to a particular subject.

Question 58 |

502 | |

504 | |

506 | |

500 |

44, 42, 40, ...... 0

2(22 + 21 + 20 + …. 1)

Sum(n)=(n(n+1))/2=(22×23)/2=253

⇒2(253)

=506

Question 59 |

would fly | |

shall fly | |

should fly | |

shall have flown |

__would fly__in the sky.

Question 60 |

**INCORRECT**sentence:

He is of Asian origin. | |

They belonged to Africa. | |

She is an European. | |

They migrated from India to Australia. |

→ We can't use "an" infront of European. It can be pronounced as European. Here E is silent.

→ So, option C is the answer

Question 61 |

7 | |

8 | |

9 | |

10 |

Multiply on numerator & denominator

=-1+9

=8

Question 62 |

13/90 | |

12/90 | |

78/90 | |

77/90 |

⇨ Find which can be divisible by 7 upto 100

14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98

Total = 13

Probability of divisible by 7 is = 13/90

Which can’t be divisible by 7 is

⇒ 1 – (probability of divisible by 7)

⇒ 1 – (13/90)

⇒ 77/90

Question 63 |

Failure is the pillar of success. | |

Honesty is the best policy. | |

Life begins and ends with adventures. | |

No adversity justifies giving up hope. |

Option D is related to the given information.

Question 64 |

36 | |

30 | |

24 | |

18 |

Let ‘x’ be the total distance,

Speed = distance/ time

Total speed = (total distance)/(total time); Time =distance/speed

Time taken for train journey = (x⁄2)/60kmph=x/120

Time taken for bus journey = (x⁄4)/30kmph=x/120

Time taken for cycle journey = (x⁄4)/10kmph=x/40

Total time = x/120+x/120+x/40=5x/120

Total speed = (total distance)/(total time)=x/(5x⁄120)=(120×x)/5x=24kmph

Question 65 |

16,500 | |

15,180 | |

11,000 | |

10,120 |

Working hours decreased by (1/24) ⇒ 1-1/24 ⇒ 23/24

The new cost of erection = 13,200 × 6/5 × 23/24 =15,180