Solution: MTTR (Mean Time To Repair) = 20 hrs

MTBF (Mean Time Between Failure) = 10000 hrs

Availability = MTBF
-------------------
MTBF + MTTR

= 10000
-------------------
10000 + 20

= 99.8 % Available

Overall Answer : D

Solution:
Encapsulation and Inheritance are boon and bane from OO world.

Overall Answer : C

Solution: All sorts except Quick-sort accommodate a series that is already sorted. Try sorting a
series (1,1,1,1,1,1) or series (1,2,3,4,5,6) Quick-sort efficacy reduces to Θ (n2) from Θ (nlogn).

Overall Answer : D
Solution: AST, Attribute Grammar, Semantic Stack and Parse Table all are data-structures that
are used in Parsing stages of a given compiler, they do store some part of information but not
involved in “managing information about variables and their attributes”. Ideally Symbol table
can be seen as a tuple S = (variable, attributes). During all stages information is stored and gets
more refined in Symbol table.

Overall Answer : D

Solution: There is one critical point to note here. What is value of X at the end of current context
of loop ? Consider the following explanation.

Step 1. x = 21, i = 2, x <= 1000 (at the end of loop)

Step 2. x = 22, i = 3, x <= 1000 (------“-----------)
Step 3. x = 24, i = 4, x <= 1000 (------“-----------)
Step 4. x = 216, i = 5, x > 1000 (------“-----------)

It will fail at the Step 5. loop startup condition, so our value of (i) is struck at 5

Overall Answer : B
Solution: This is an interesting problem, only noteworthy point here is a sub-expression.

1. P(x,y) ^ P(x,v) which states both y and v has same parent.

2. So there are four combinations for y and v MM, MF, FM, FF (Male – M , Female – F).
3. But if you see M(v) is also given so it means that v cant be F.
4. Also y has a child w, that child can be a girl or boy.
5. But what do you call your father’s or mother’s brother (that’s v here). I think I call my father’s
or mother’s brother as my uncle. (its not established that whether y is male or female). Who
am I ? I am (w)

Overall Answer : C

Both 7 and 8 are based upon tree figure.

Solution (7): Post Order is Left Right Root so we have outcome of traversal as : UXWQZYVP

Overall Answer (7) : C

Solution (8) : if T is BST or Binary Search Tree we have to traverse in In Order way as :

UQXWPVZY (where U is having smallest numerical value and Y having highest). So 4th smallest
is W.

Overall Answer (8) : C

Solution: This is more of theoretical one.

Ethernet uses CSMA/CD which suggest there are multiple masters on same bus, This answers
both B and C option. Ethernet has MTU or Maximum Transfer Unit of a given message as 1500
bytes and we need repeaters or signal boosters beyond 100 meters. Check for notation
XXXXBaseY (eg. 10BaseT would mean 10 Mbps, base-band signaling, Twisted-pair type of
wire) where XXXX defines bandwidth from 10-1000 Mbps and Y define Wire type being
Twisted pair or Fiber and so on. Base here defines type of signaling used. There is lower limit of
length of cable also. Its 1 meter, cause otherwise there will be too many collisions. This answers
D and E.

Overall Answer : A

Solution: Any K-ary tree with n-nodes and h-height has Total number of nodes or n given by
h
n= ki expanding this
i=0

n = k0 + k1 + k2 … + k(h-1) + kh , interesting point here to note is that

if h = 0 then its root.

So kh denotes how many leaves we will have in k-ary tree and rest all are what we call inner-
nodes or penultimate nodes.

Overall Answer : D
Solution: Virtual Memory was designed for sole purpose of following goals.

1. We have program images greater than available ram. We want a mechanism to start our
program with adjustable image in memory and fetch chunks (what is called pages) on the
fly or by generating trap called faults (now called page-faults). That answers II.
2. MMU or Memory Management Unit will treat program images equally and would divide
into chunks and make it aware to OS. It would not peep into images or chunks. That
answers III.

Overall Answer : A

Solution: Consider following explanation

T(1) = 7
T(n+1) = 3n + T(n)

now if we expand this for (n) values we get following series

T(1) = 7
T(2) = 3x1 + T(1) = 3x1 + 7
T(3) = 3x2 + T(2) = 3x2 + 3x1 + 7
...
...
T(n+1) = 3xn + 3x(n-1) .... + 3x1 + 7

so if u see further
= 3x(1+2+3 ... + n) + 7

= 3x(n)x((n+1)/2) + 7, logically this can be seen as some function and constant

=f(n2) + C

=Θ (n2)

Overall Answer : C
Solution: In case of Binary logic the total number of bits required to implement 256 different
values are given by log2(256) = 8-bits

We need to change the base of logarithm for this.

log3(256) = 5.0474-bits, but we need to have integral value else we will loose .0474th of a state
so we need to have next higher integer.

Overall Answer : C

Solution: Consider the following explanation.

1. hash-tables are organized in such a way that when given a key you get a value define by a
mapping function of key and values. This means that key needs to be unique. This
answers A. Efficiency comes from the fact that we are deterministically reducing search
space by providing a unique key ourselves.
2. Certainly insertion, deletion and search is provided as in hash-tables analogous to
dictionary all based upon a certain unique key. That answers B.
3. Consider this Key-range=[1..5] and you are told to fetch all data in this range. The
approach is brute-force exhaustively scanning key 1 to 5 and fetching all data. Is it
efficient ? (think this from the point of view of how hash-table is organized)
4. Symbol tables are nothing but data dictionaries so given a identifier as key, gives its
attributes. That answers D.
5. This is tricky. Think of a two-tier hash table. One that hashes keys of a hash table that has
some values.

Here at top level given a key K1 we will be given a key K2 which will be used to find
actual value. Let the input to Hashtable-1 be two sets of keys (1,2,3,4) and (5,6,7,8)
Our goal is to find a set that says lets say (2,5) has overlapping set of keys. We give our
probable keys that we are looking for to reduce the search space and hence being efficient.

Overall Answer : C (for being most in-efficient)

Solution: Consider the explanation as under.

z*xk = bn is loop-invariant. It holds true for following conditions.

1. It must be true at start of loop (which it is, put z = 1, x = b and k = n in loop-invariant to

see L.H.S = R.H.S)
2. The loop should not change validity of loop-invariant. (do a dry-run for lets say b=2, n=4,
the loop-invariant holds true even in the loop)
When the loop terminates k=0
So we just need to put this value in our loop-invariant.
Giving, z = bn

Overall Answer : B

Solution: Address resolution protocol is best understood if we have two subnets and a router in
between them when sub-net 1 sends a packet to router for sub-net 2 following things happen.

1. Machine 1 on sub-net 1 (192.168.0.1) with AA:BB:CC:DD:EE:FF (hardware address are

of 6-bytes) sends a packet to Machine 2 (107.108.0.1) on sub-net 2.
2. It goes to router (192.168.0.254), lets say there are 253 hosts and router is given that IP.
3. Router scans its routing table to find that it lies on different network. Puts it on a different
interface (107.108.0.254).
4. Now once the packet is on sub-net2 ARP comes into picture sending ARP request of
asking hosts to confirm who has IP of Machine 2 (107.108.0.2) this ARP leads to finding
who the host is and finally router caching it.

There is reverse protocol called BOOTP protocol where we have machine address but we don’t
have IP address. Its used in diskless machines to get OS images from server. All nodes are
initially set to 0.0.0.0 They all have machine address of server but not the IP-address of server,
the router or arbiter for give them IP-address of server for a given hardware address.

Overall Answer : D

Solution: Consider the explanation below. (it’s pretty tricky scheduling of operations)

Let’s view AB + ABC + BC as AB(1+C) + BC. One assumption made here is, (r7, register) has
constant 1 stored prior to this schedule of operation. r0 has A, r1 has B and r3 has C.

Cycles Operation Action-performed

1 ADD r7, r2, r3 (remember r7 has 1 stored) 1+C
1 MUL r0, r1, r4 AB
1 MUL r1, r2, r5 BC
2 MUL r3, r4, r6 AB(1+C)
1 ADD r6, r5, r7 AB(1+C) + BC

Total cycles = 6 (and r0, r1, r2 content remains intact)

Some important observations here are:

1. Ordering of operations (or schedules of operations).

2. There are other schedules or ordering of operations, which results in consumption of 7
clock cycles. (Even the given ordering if one execute with 2 multiplications(AB, BC)
first then a addition(1+C) and then multiplication (AB(1+C)) and then addition(AB(1+C)
+ BC) leads to 7 clock cycles.). Immediate register-dependent instructions are costly. So,
one can choose a schedule that puts at-least one instruction in between such dependent
instructions.
3. Two easy answers are 5 (if one just looks cursory towards question), 7 if one takes any
normal schedule or ordering of operations. 8 or 9 can never be answer as it’s just being
deliberately redundant in register usage.

Overall Answer : B
Solution: Consider the following explanation.

View efficiency as =
(Time-taken-on-single-processor)/((Time-taken-on-parallel-processor)* (Total-no-of-processors))

let N be number of processors, here 4

Total tasks are 8 (T1 … T8)
Lets assume that each Tasks takes 1 unit of time.

1. So Time-taken-on-single-processor = 8 Units of time. (let it be Ts)

2. Time-taken-on-parallel-processor = 1 (for T1) + 1 (T2) + 2 (T3 …T6, T4 …T7, T5 … T8)
(because they are executed in parallel) = 4 Units of time (let it be Tp)
3. Total processors = 4 (let it be N)

Efficiency = Ts/(Tp * N) = 8 /16 = 50 %

Overall Answer : C

Solution: Consider the following explanation.

A DAG is a graph that has no cycles. Read “Which of the following must be true ?” suggests on
the lines of being necessary condition or “mandatory”. A DAG has a property that at-least one
node has out-degree to be 0 (else it will form a cycle). This means no outgoing edge. This
answers II. Consider following graph.

G=(V,E)
|V|=1

|V|=2

|V|=3

The note-worthy point here is in all graphs, there are some vertices, which are having in-degree to
be 0 that is no in-coming edge. But having an isolated vertex is just matter of choice one makes, it
maybe that the graph has no isolated vertex (see last graph of |V| = 3) or it maybe that it does has
an isolated vertex (see the first graph of |V| = 3). So it’s not mandatory to have it. This answers I
and III.

Overall Answer : D

Both 20 and 21 are based upon same question

Solution (20): Consider the following explanation.

Write-through policy of caching writes data onto cache and memory both.
Total-no-of-times-the-loop-runs = 256
No-of-bytes-written-per-write = 4 bytes (both cache and main memory)
Total-bytes-written = 256 * 4 = 1024 bytes (both cache and main memory)

Overall Answer (20) : C

Solution (21): Consider the following explanation.

Write-back policy of caching writes data onto memory only when cache is flushed. There are two
important points when the cache needs to be flushed.
1. When cache is full (i.e. exceeds cache capacity).
2. When cache entry (cache-line) is invalidated (i.e. when some external source, like other
programs modifies same memory address whose entry is in cache).

In present case cache-line invalidation never happens, as it’s assumed no other source modifies a
given memory address (m), whose entry is already there in cache.
Total-no-of-times-the-loop-runs = 256
No-of-bytes-written-per-write = 4 bytes (only in cache).
Total-bytes-written = 256 * 4 = 1024 bytes (only in cache)
Total-cache-capacity = 2048 bytes
Total-bytes-written < Total-cache-capacity, this suggests that there is no cache-line entry being
invalidated (if there is more than 2048 bytes of data, flush extra bytes to memory)and the cache is
not used fully as there are still 1024 bytes remaining in cache. This results in 0 writes in main
memory.

Overall Answer (21) : A

Solution: Consider the following explanation.

Decode C1E0 0000 into binary as : 1100 0001 1110 0000 0000 0000 0000 0000
S: 1100 0001 1110 0000 0000 0000 0000 0000; equivalent-in-decimal = 1
E: 1100 0001 1110 0000 0000 0000 0000 0000; equivalent-in-decimal = 131
F: 1100 0001 1110 0000 0000 0000 0000 0000; equivalent-in-decimal = 6291456

Put the above values in expression N = (-1)s x 1.F x 2E-127

N= (-1)1 x 1.6291456 x 2131-127
N= (-1)1 x 1.6291456 x 24
N= -1.6291456 x 16
N= -26.0663296
N= ~ - 26
Overall Answer : C

Solution: Consider the following explanation.

Let x S
( is belongs-to relation, where S is set of people such that S = {John, Joan, Jack, James, Jill},
who are either lawyer(s) or liar(s))
∀ (for-all) signifies that any given predicate calculus formula should hold for all members of set
(here set is S), in effect giving it “AND” behavior.
∃ (there-exists) signifies that any given predicate calculus formula should hold for any one of
members or set (here set is S), in effect giving it “OR” behavior.

Conditions
1. P(x) : x is a Liar
2. Q(x) : x is a Lawyer
3. x = John (instance 1)
4. Every member of set has to-be-either of Liar or Lawyer or both.

Consider (∀x P(x) v ∀x Q(x)) this is translated when applying above as below:
1. P(John) v Q(Jack) (since ∀ operator is applied individually and not on whole expression,
so 1 and 2 instances of (x) will have different set-members).
2. Similarly, ∀x (P(x) v Q(x)) is translated to P(John) v Q(John) (here ∀ operator is applied
to whole expression)
3. Any relation of type A → B is equal to A v B ( being NOT operator)
4. Replacing A with point 1 and B with point 2 the outcome is (P(John) v Q(Jack)) v
(P(John) v Q(John))
5. ( (P(John)) ^ (Q(Jack))) v (P(John) v Q(John)) ( ^ being AND operator)
6. ( (P(John)) v (P(John) v Q(John))) ^ ( (Q(Jack)) v (P(John) v Q(John)))
7. (P(John) v Q(John)) ^ ( (Q(Jack)) v (P(John) v Q(John))) is of the form
(A) ^ ( (B) v (A)) which translates to (((A) ^ (B)) v (A)) now A has to be true (cond. 4)
so irrespective of values of B, I (in question) holds true all times.
8. This only proves for 1 instance. Since ∀ operator is equal to “AND” it holds for all set
member values so if result in (7.) is to taken as RJohn, then I (in question) can be treated as
RJohn ^ RJoan … ^ RJill each one of them holding true as explained above.

Similar explanation holds true for III (in question) for ∃ operator. But ∃ defines “OR”
behavior. Also, since only one of the instances (John, Joan, Jack, James, Jill) needs to be true
so III holds true at all times, but each time with different instances. It can be treated as
RJohn v RJoan … v RJill , where any one of them needs to be true. As one of them is proved to
 be true already, it’s non-mandatory to have every single single-member to be proved true as ∃
requires any one to be true, thus making it true in all case.

Overall Answer : D

Both 24 and 25 are based upon same question

Solution (24) : Consider the following explanation.

Pass-by-value fetches fresh copies of actual parameters, each time they are used. Does not
modifies actual parameters values (of the calling program) from inside a procedure.

y = y + b is translated (b = b + b); b = 14 (in called-procedure), b = 7 (in calling procedure)

x = b + x is translated (a = b + a); a = 9 (in called-procedure), a = 2 (in calling procedure)
b = x + b is translated (b = a + b); b = 16 (in called-procedure), b = 16 (in calling procedure)
a = y is translated (a = b); a = 14 (in called-procedure), a = 14 (in calling procedure)

Overall Answer (24) : D

Solution (25) : Consider the following explanation.

Pass-by-value updates actual parameters, each time they are used. It does modifies actual
parameters values (of the calling program) from inside a procedure.

y = y + b is translated (b = b + b); b = 14 (in called-procedure), b = 14 (in calling procedure)

x = b + x is translated (a = b + a); a = 16 (in called-procedure), a = 16 (in calling procedure)
b = x + b is translated (b = a + b); b = 30 (in called-procedure), b = 30 (in calling procedure)
a = y is translated (a = b); a = 30 (in called-procedure), a = 30 (in calling procedure)
here both (y) and (b) points to same location so both modify it accordingly, same goes for (a) and
(x).

Overall Answer (25) : E

Solution: Let = {a}, then * = { , a, aa, aaa, …}

Here is null character.

Let A = {a, aa, aaa}

and B = {a, aa} (as B is subset of A)

Choice I is intuitively clear, that if and only A is finite B is finite. (we can’t have a subset
exceeding its parent set)

Choice II requires use of pumping lemma for regular expression, which states as follows
Let z=uvw
Where z = any chosen word from set B lets say aa
Then z <= some N where N is suitably chosen value lets say 3 (length of characters of word aaa
in set A)
And |uv | >= 1 (length of uv to be greater than 1) lets assume u = a and v = a too.
So that gives us
z=uvw = aa ( is null-char)

the lemma says B should also contain strings derived from expansion z = u. vi .w,
let examine this. Putting values of u and v and w as we know from above discussion.
z = a . ai. --> ai+1
for suitable values of (i) we have following pattern
z=a ……………………i=0
z= aa ………………… i=1
z=aaa………………… i=2
z=aaaa………………...i=3
…

please see that for i=1 z belongs to B, can the same be said for i => 2. So it implies that our finite
sets can’t cope up with increasing values of (i) and resulting strings out of it. A finite set can’t
prove beyond a certain point that it would contain strings generated by (z). so it’s not possible to
say A to be finite and would contain all strings generated by (z). Even if we assume A to contain
it (some how). Even then B is just a subset of it, so it possible contains a subset of those words
and hence can’t be regular. So there are two implications.
A cant be deterministically regular when considering finitely. Even if its assumed (for the sake of
proving its B to be regular)
B cant be regular because it contains only subset of A values. One may assume that B to have a
set that contains all value of A, but that’s true only in one case and not all. So its false.

Choice III Similar lemma exists for proving a given language is CFL or not. Certainly its subset
wont be CFL either.

Overall Answer : A

Solution:

V-bit is set when arithmetic overflow is there.

C-bit is set when carry-out generated at MSB.
Z-bit is set when result is zero.

1100 1100
(+) 1000 1111
1 0101 1011

There are two over-flow occurring. (Both shown as red)

The first red number (at the MSB side) its Carry-out at MSB so C=1
The second red number is arithmetic overflow so V=1 (its BCD overflow)
Finally result is non-zero so Z = 0

Overall Answer : B

Solution:
n
If you see ki forms a G.P or geometric progression, which can be broken down as :
i=1

= k1 + k2 + k3 … + kn

the finite G.P has sum formula as:

a(rn-1)
---------, where |r| > 1 (which is true in our case, as r = k)
r-1

substituting (a=k, r= k) this can be seen as:

(k/(k-1))*(kn-1) (* denotes multiplication)

= C * (kn-1) (C = k/(k-1))

so roughly we have
~ Θ (kn)

Overall Answer : A

Solution :

There are two operations in merge sort.

1. Sorting
2. Merging
Both these activities take same amount of effort using array or SLL or DLL. So Intuitively
merge-sort is data-structure independent.

Overall Answer : E

Solution: Consider the following explanation.

Instances on stack variable-values multiplication-count

1 (return-value=25) 5x5 exponent=6 (un-folding) 1

2 (return-value=625) 25x25 exponent=3 (----“”-----------) 2
3 (return-value=390625) 625x625 exponent=1 (----“”-----------) 3
4 (return-value=1) 390625x390625 exponent=0 (----“”-----------) 4
5 (return-value=390625) 390625x1 exponent=3 (folding) 5
6 (return-value=244140625) 390625x625 exponent=6 (folding) 6

Interesting points are mentioned here:

1. Unfolding is stage when activation record of functions accumulate (stack expands),

folding is stage when “returns” are accumulated (stack shrinks).
2. As mention in instance 4, even though the product turns out to be 152587890625, but the
function returns 1 as the exponent is 0.
3. Henceforth in folding stages accumulated return values (like in instance 5, accumulated
return is 1) are given to previous invocations of “power” function.

Overall Answer : D
Solution: Consider the following explanation.

Data-grams does not have lower-bound on size to be equal to MTU. That answers I. II and III are
correct because a data-gram can be of any size and hence can be fragmented and can be reaching
destination out of order (opposite to TCP packets which have sequence numbers) and hence needs
re-assembly there (in effect re-ordering also). TCP packets has a size limitations to be of 64
Kbytes segments.

Overall Answer : E

Solution: Consider the following explanation.

1. Clique is a complete sub-graph of graph G. To find a largest clique one needs to find set
of vertices that suffice total paths of (n(n-1))/2. This is NP-complete.
2. Finding all spanning tree requires constructing trees T1…TN such that each contains all
the vertex of graph G. There are two algorithms to find a variant of spanning tree called
minimal spanning tree, viz. prim’s algorithm and kruskal’s algorithm only these two have
polynomial time implementation.
3. Graph coloring problem is the problem of finding adjacent nodes and having different
color among them. This is NP class problem.
4. Longest simple cycle in undirected graph G is NP class problem.
5. Short cycle in G correspond to shortest path problem (here this path leads to itself), for
this there are polynomial time algorithms.

Overall Answer : B
Solution: Consider the following explanation.

1. Latency is defined as difference of time between when one submits an instruction and
when one gets the result.
2. Throughput is defined as total number of instructions in given amount of time.

Based upon this, latency of single instruction is more on M-7’s pipeline than on M-5’s pipeline.
This goes onto prove further that programs runs slower on M-7.

Let’s take time T (for measuring throughput, a time-window) = 30 nanosecond, now M-5 has
throughput of 3 instructions in given time of 30 nanosecond (30/10) and M7 has throughput of 4
instructions in given time of 30 nanosecond (30/7.5). Throughput does tell that how many
instructions per second a system executes, but doesn’t tell exact amount of time per instruction
required (time at which one input the instruction and time at which result came out).

T1 Stage1 Stage 2 Stage 3 Stage 4

… Stage T2
N

A N-stage pipeline

Latency(in seconds) = T2-T1, where as Throughput = Total-no-of-instructions/any-given-amount-

of-time

Overall Answer : A
Solution: Consider the following explanation.

There are two things important in this code-fragment.

1. U will execute as soon as one enters the loop (even if the loop runs once).
2. X has two paths one going out of loop and one returning to U (one of them occurs more
frequently than other and X is sitting at the place where it can either send it back or let it
go out of loop).

With 1 in mind U is bound to run at-least once. With 2 in mind U is expected to run 2 times
(that’s more frequent because X returns to U with greater probability or no. of times).

Expected here tells about most-frequent number of times seeing the graph at first instance.

Overall Answer : D
Solution: Consider the following solution.

S → (S) and S → x generates following strings

(((…(x)…))), where only variable components are number of left and right parenthesis. Top-
down parsing starts with non-terminals and end with final resulting string. It starts to replace left-
hand side non-terminals to suitable right-hand side terminals/non-terminals.

Top-down parsing:

Let the result be ((x)), so in top-down parsing, following steps are applied with respect to
productions. (Start with S).

Applying production 1: (S)

Applying production 1: ((S))
Applying production 2: ((x))

( )
S

( )

Incase of Bottom-up parsing one starts with result and end with starting symbol. It starts to
replace right-hand side terminal/non-terminal with left-hand side non-terminal.

Bottom-up parsing:

Let the result be ((x)), so in bottom-up parsing, following steps are applied with respect to
productions. (Start with ((x))).

Applying production 2: ((S))

Applying production 1: (S)
Applying production 1: S
 S

( )
S

( )

The grammar is not ambiguous because the left-most derivation and right-most derivation results
in same parse tree.

Overall Answer : D

Solution: Consider the following explanation.

x0 is LSB and x2 is MSB.

x 1x 0
00 01 11 10
x2
1
0

1 1 1 1

There are two literals in this case. (( x1).x0) + (x2.( x0)), where represents logical NOT.

Overall Answer : C
Solution: Consider the following explanation.

Greedy algorithms are algorithms, which make locally optimal choice at each stage with the hope
of finding globally optimal solution. Let’s define locally optimal variables for each of three class
of problems. In general, greedy algorithms have five main-features :

1. A candidate set, from which a solution is created.

2. A selection function, which chooses the best candidate to be added to the solution.
3. A feasibility function, that is used to determine if a candidate can be used to contribute to
a solution.
4. An objective function, which assigns a value to a solution, or a partial solution.
5. A solution function, which will indicate when we have discovered a complete solution.

Based upon this spanning-tree, clique and flow problem can be seen as under (in order):

1. Locally optimal variable here is finding a subset of tree that contains all nodes for that
subset and is connected. Intuitively this will have some positive-integer edge weights.
2. Locally optimal variable here is finding a subset of a clique (which is already a sub-graph,
which is complete), which is also complete.
3. Locally optimal variable here is finding a path that for a given stage gives maximum
capacity. Intuitively this will have some positive-integer edge weights.

All the above 5 factors can be applied onto 1 and not onto 2 and 3 for a reason as under:

1. Selection function cannot determine which sub-set to choose by itself in case of clique
finding.
2. Feasibility function also cannot determine validity of a candidate vertex whether it will
form a bigger clique or not.
3. Feasibility function cannot determine whether taking a maximum capacity at a stage will
result in global maximum capacity.

Overall Answer : A
Both 38 and 39 are based upon same question

Solution (38): Consider the following explanation.

If an event happens for k-times and probability of each such mutually-exclusive event is (1-p),
then overall probability is = (1-p)K

Overall Answer (38) : C

Solution (39): Consider the following explanation.

See “Suppose that in each of the k different executions the output of A is “No”” as the events are
over and one gets a final answer as “No”. It means experiment is over and there is no
“probabilistic” factor remaining. Hence it’s certain that the number is composite. So when an
experiment is bound to occur certainly then probability is 1. “No” is given as output when
number is prime and if one gets “No” in all events of an experiment then, it’s “certain” not
“probable” that the number is not prime.

Overall Answer (39) : A