Solution

Total distance =6010=600 km

New speed =600/4=150 km/hr

Increase in speed =150-60=90 km/hr

Solution

Solution

Speed of the train relative to man =66-6=60 km/hr

Solution

N = H.C.F of (4665 - 1305), (6905 - 4665) and (6905 - 1305)

N = H.C.F of 3360, 2240 and 5600

N = 1120

Sum of digits in N is = 1 + 1 + 2 + 0 = 4

Solution

Solution

Solution

Gullible means being easily persuaded to believe something.

Solution

Passing cloud means something that lasts only for a short period of time.

Solution

Only Option c) is grammatically correct.

Solution

It is given in the passage ‘PK will be remembered for his famous vocal tonic - those legendary pre-match pep talks he delivered to inspire players to defy odds.’

Solution

cursor = cursor->link()

Here cursor-> link() moves the cursor to the next node and that was assigned to cursor itself, hence now it is pointing to the next pointer.

Solution

The elements pushed in the stack are d-o-o-d-l-e-s one after the other by first while loop.

In the 2nd while loop the TOP of the stack will be printed until the stack gets empty hence from top to ‘s’ to ‘d’ all characters will be printed. Hence ‘seldood’ will be the answer.

Solution

In the highlighted section, you can see at one time instance the max number of operators in operator stack are 4

Solution

Here ptr is array not pointer

Solution

#include <stdio.h>

typedef struct { int k; int l; int a[2]; } T;

typedef struct { int i; T t; } S;

T x = {.l = 43, .k = 42, .a[1] = 19, .a[0] = 18 };

// x initialized to {42, 43, {18, 19} }

int main(void)

{

S l = { 1, // initializes l.i to 1

.t = x, // initializes l.t to {42, 43, {18, 19} }

.t.l = 41, // changes l.t to {42, 41, {18, 19} }

.t.a[1] = 17 // changes l.t to {42, 41, {18, 17} }

};

printf("l.t.k is %d\n", l.t.k); // .t = x sets l.t.k to 42 explicitly

// .t.l = 42 would zero out l.t.k implicitly

}

Solution

Perfect Binary Tree: A Binary tree is a Perfect Binary Tree in which all internal nodes have two children and all leaves are at the same level.

18

/ \

15 30

/ \ / \

40 50 100 40

A Perfect Binary Tree of height h (where height is the number of nodes on path from root to leaf) has (2^h) – 1 node.

Solution

Pointer Variable can also Store the Address of the Structure Variable.

Pointer to Array of Structure stores the Base address of the Structure array.

Pointer Is Declared and initialized as —

struct Cricket *ptr = match

Here the address of match[0] is stored in pointer Variable ptr

Solution

In c,

a [1][2]

=*(a [1] +2)

=*(*(a+1) +2)

=2[a [1]]

=2[1[a]]

Now, a [1] [2] means 1*(4) +2=6th element of an array

staring from zero i.e. 21.

Solution

L =(n-1)I+1 where L= no. of leaf nodes, I= Internal Node

41 = (n-1)10+1

41 = 10n - 10+1

10n= 41-1+10

N = 5

Solution

• In a MAX heap the smallest values of the heap will always be present on the last level of heap and time complexity of reaching the last level of heap is O(n).
• We have to search all the elements to reach the smallest element and heap using linear search.
• To traverse all elements using linear search will take O(n) time.

Solution

P: True. All input orderings give the worst case running time. The running time doesn’t depend on the order of the inputs in any significant way

Q: True: Using base 10, each integer has d = logn^5 = 5 logn digits. Each counting sort call takes Θ(n+10) = Θ(n) time, so the running time of Radix sort is Θ(nd) = Θ(nlogn).

Solution

Q: Dijkstra will visit the vertices in the following order: S, C, A, D, F, E, B. Dijkstra will relax the edge from D to E before the edge from F to E, since D is closer to S than F.

Solution

Here, we can get the first item using profit per weight even if we are using a 0/1 knapsack.

→ According to the above Profit/weight ratio, the item-1 has maximum profit. So, pick item-1.

→ Now M=7, Pick item-2 because it has more profit.

→ Now M=5, Now according to profit/weight ratio we can pick item-3 or item-5 but item-5 has more weight, so it exceeds capacity. If we are selecting item-3 means we are wasting 1 slot. So, here, profit/weight ratio fails. So, follow brute force technique in this position. We can pick item-4 because it has weight 5.

→ Now, M=0 and Profit=19. [item1 + item2 + item4]

Note: In exam time, we have enough time, so cross verify once again your procedure and answer.

Solution

There may be many possibilities to reach the same city to cover all other cities but the minimum distance is 10. And the shortest possible route is A-C-E-B-D-A

Solution

∑ is alphabet set of the language to be recognized and 𝞒 is set of symbols that can exist on the tape. 𝞒 contains all symbols of ∑ and {𝞫} . Along with this 𝞒 can contain other symbol also. So x and y must belong to 𝞒.

Solution

The given regular language is finite so the intersection must be finite, as only finite strings can be common. Hence, the intersection of a CFL and a finite regular language is always finite, so “whether the intersection of a CFL and a finite regular language is infinite” is trivially decidable.

Equality problem of two DCFL is decidable hence two deterministic push-down automata accept the same language is decidable.

We can check whether the given grammar follows the definition of Type 2 grammar (CFG) hence “Whether a given grammar is context-free” is decidable.

Solution

The regular expression generates string “bab” hence “set of all strings containing the substring bb” is false.

The regular expression generates string “bbb” hence “set of all strings containing at most two b’s” is false.

The regular expression does not generate string “ab” hence “set of all strings that begin and end with either a or b” is false.

Solution

Solution

Since initial state is final state and PDA has transitions (a,z0|z0) and (b,z0|z0) as self loop so PDA accepts (a+b)*

Solution

Assembler generates the object module and passes it to the linker. Linker has the responsibility of combining all the object modules to generate a single executable file of the source program. Linker intakes the object codes generated by the assembler and combines them to generate the executable module. The executable module generated by the linker is passed to the loader which allocates space to an executable module in main memory.

Solution

The DAG for: (p+q) *(p+q-r)

Solution

The correct SDT is

A-> A₁ 0 { A.val = 2× A₁ .val }

| A₁ 1 { A.val = 2× A₁ .val+1}

| 1 { A.val =1}

Consider the string “1011” and its value is 11.

Solution

There are two ways to evaluate the expression

Case 1: Compute (a-b) first then compute (d/e) and then find c*(d/e) and finally add both.

1. Load R0,a
2. SUB R0,R0,b //R0=a-b
3. Load R1,d
4. DIV R1,R1,e //R1=d/e
5. STORE R1,M1 //Store M1=d/e
6. Load R1,c //R1=c
7. MUL R1,R1,M1 //R1=c*(d/e)
8. ADD R0,R0,R1 //R0=R0+R1

Please note instruction 5 store the value of (d/e) in memory as it is required to load “c” into register in order to evaluate c*(d/e) . Hence total 8 cost units.

Case 2: Compute (d/e) first and then c*(d/e) and then (a-b) and finally add both.

1. Load R0,c //R0=c
2. Load R1,d //R1=d
3. DIV R1,R1,e //R1=d/e
4. MUL R0,R0,R1 //R0=c*(d/e)
5. Load R1,a
6. SUB R1,R1,b //R1=a-b
7. ADD R1,R1,R0 //R1=R1+R0

Minimum total cost is 7 units.

Solution

Solution

A transaction is said to follow Two Phase Locking protocol if Locking and Unlocking can be done in two phases.

1. Growing Phase: New locks on data items may be acquired but none can be released.
2. Shrinking Phase: Existing locks may be released but no new locks can be acquired.

Solution

From the given properties of the columns, only A and B are good for indexing.

Solution

• From the given set of functional dependencies, it can be observed that B is a candidate key of R.
• So all 300 values of B must be unique in R.
• There is no functional dependency given for S.
• To get the maximum number of tuples in output, there can be two possibilities for S.

1) All 200 values of B in S are the same and there is an entry in R that matches with this value. In this case, we get 200 tuples in output.

2) All 200 values of B in S are different and these values are present in R also. In this case also, we get 200 tuples.

Solution

If a functional dependency X->Y holds true where Y is not a subset of X then this dependency is called non trivial Functional dependency

Solution

A total of 17 page faults occurs for FIFO page replacement algorithm.

Solution

The total number of seeks obtained using LOOK disk scheduling algorithm is 314.

Solution

EMAT = h*(t+M) + (1-h)*(t + K*M + (1-P)*(M) + P*(PFST))

EMAT=149.50 ns

Solution

This solution may result in failure of progress, where neither P0 or P1 can proceed to enter their critical section. This will happen when P0 makes flag[0] = TRUE, and then there is a context switch. P1 makes the flag[1] = TRUE. Now both P0 and P1 will be waiting indefinitely in the while loop before entry to the critical section.

Rest of the statements are true, as the mutual exclusion is achieved. The code uses spin-lock mechanism to check the lock availability. ( while (flag[(i+1) % 2) == TRUE); )

Solution

Page table size decreases as we have fewer entries , TLB hit rate increases because of more coverage of memory pages-frames and Internal fragmentation increases as more space is wasted in a page.

Solution

Address Id - 10001101.00001110.11000100.00101110

Subnet Mask - 11111111.11111111.11000000.00000000

……………………………………………………………...

Subnet Id - 10001101.00001110.1100000.00000000

Solution

Trivial File Transfer Protocol (TFTP) process includes flow and error control. It can easily use UDP.

• UDP is used for management processes such as SNMP.

• SMTP uses TCP.

• UDP is used for some route updating protocols such as Routing Information Protocol (RIP).

Solution

Solution

Solution

We have three elements { -2,0,2}.

In a square matrix of order 2, we have 2 x 2 = 4 places.

Each of the 4 places can be filled with 3 elements.

So, 3 x 3 x 3 x 3 = 81 distinct matrices we can get.

Solution

Solution

To make it reflexive we must add (b,b),(c,c),(d,d)

To make it symmetric we need to add (c,b),(d,c)

To make it transitive we need to add (b,d),((d,b)

We need to add 7 more ordered pairs to make it equivalence relation

Solution

If b is inverse of a then a*b = b*a = e where e is identity element

The identity element for the given group is 1.

Thus i*b=1

b= -i

Solution

Expand the given quadratic equation and expand the given options too then compare

Solution

We can form words of length 5 in 10*10*10*10*10= 10^5 ways.

We can subtract the words that are formed with unique letters from the total, which will yield the word with at least one repeated letter.

i.e we can form words with distinct letters in 10P5 ways.

We require 10^5-10P5 = 69760

Solution

The domain of f(x) is restricted to the closed interval [0,2π], and its critical points occur at π/4 and 5π/4. Testing all intervals to the left and right of these values for f′(x) = cos x − sin x, you find that

Solution

A tautology results only True for every input

Solution

Y= 1000 1010

= -128 + 8+2

= -118

16Y= - 2048 + 128 +32

= 1000 1010 0000

= 0x8A0

Solution

The output of the circuit is A(B+C) + (B+C)A’

= (A+A’) (B+C)

= B+C

Solution

Solution

S=0; A is a positive number.

Actual exponent e= Biased exponent - bias

= E-16

= 31-16

= 15

Mantissa M= 11110..0

Value of A= (-1)S x 1.M x 2e.

= +( 1.1111 x 215 ).

= + (11111.0)x 211

= 31 x 2048

= 63488

Solution

Solution

S1 is false because direct mapped cache has more number of conflict misses compared to set associative cache of the same size.

S2 is true because in a fully associative cache a main memory block can be anywhere in the cache. If there is an empty block in the cache then there will not be any block replacement.

Solution

T= size of a track in bytes = number of sectors per track * size of each sector

= 50*512 bytes = 25K bytes

S = size of each surface in bytes = Number of tracks per surface * number of sectors per track * size of each sector = 1000*50*512 bytes = 25,000 K bytes

Solution

There are 500 memory accesses.

Hit rate of L1 is 80%, so out of 500 accesses, 0.8*500 = 400 are serviced from L1

L1 miss rate = 1 − 0.8 = 0.2

So, 0.2*500 = 100 accesses which are missed in L1 will go to L2.

But L2 hit rate is 90%, so out of the 100 accesses which come to L2 cache 0.9*100 = 90 are serviced from L2 and the remaining 10 are missed in L2.

The remaining 10 memory accesses which are missed in L2 will be serviced from main memory.

Hence, (400, 90, 10) is the answer.

Solution

It is given that the hit latency of the cache is 3ns. In a direct mapped cache the comparator delay contributes to the hit latency.

Since the k-bit comparator latency is given as k/5ns, we can write in this case k/5 = 3

So, the size of the comparator k = 3*5 = 15.

The size of the comparator is the same as the number of TAG bits in the physical address.

So, the number of TAG bits = 15.

Cache size = 512 KB

Cache Block size = 64 B

Number of blocks = 512KB / 64B = 8K = 2^13

Number of bits for LINE number = 13.

Block size is 64 B, so OFFSET = 6 bits.

In direct mapped cache the physical address is divided into 3 fields as

The physical address is 15+13+6 = 34 bits.

Solution

At location 2000 we have value 10. This is stored in R0 in the 1st instruction .

The initial value in R2 is 1000. In the second instruction we use this value of R2, 1000 to get the effective address and from location we get the value 5 and this is put into R1.

In the 3rd instruction, we add the values of R0, R1 (10+5) and this result 15 is stored back into R1.

In the 4th instruction R2 is incremented by 1, now R2 has value 1001.

In the 5th instruction the value of R1 is stored into memory location 1001 .

At the end of the program execution, R0 has 10, R1 has 15 and R2 has 1001.