GATE CS 2015 Official Paper: Shift 2 (Previous Year Paper)

'Completely’ and ‘just’ are considered adverbs of emphasis and should be placed in front of the verbs they describe. Even if a verb is in its negative form, for eg. "don't know", the adverb should be placed before the entire form.

The only option that satisfies this criteria in both cases is option C.

Hence, option C is the correct answer.

The word ‘personnel’ means 'people who are employed in an organization'.

Out of the given options, this meaning is accurately represented only in the sentence from option 3. The other options are instead referring to the word 'personal'.

Hence, option 3 is the answer.

Here are the meanings of the given words:

• Fabric - cloth produced by weaving or knitting fibres
• Textile - a type of cloth or woven fabric
• Fibre - a thread or filament from which textile is formed
• Apparel - clothing in general
  

We can see that the word that most accurately defines the given set of words is ‘apparel’.

Hence, option 4 is correct.

The given problem requires the total weight of 10 poles, each of same weight.

We check the given statements for evaluation of the total weight.

Statement I:

Given that one fourth of weight of a pole is 5 kg.

Let weight of a pole $= x;kg$

$\begin{array}{l} \frac{x}{4} = 5\ x = 20;kg \end{array}$

Total weight of 10 poles $= 10x = 200;kg$

Statement II:

The total weight of 10 poles is 160 kg more than the total weight of two poles.

Let weight of a pole $= x;kg$

So, total weight of 10 poles $= 10x$

$\begin{array}{l} 10x = 2x + 160\ 8x = 160\ x = 20;kg \end{array}$

Hence, total weight of 10 poles $= 10x = 20 \times 10 = 200;kg$

Thus, the given problem can be solved by using any of the two statements.

Given $f\left( x \right) = 1-\left| x \right|$ in $- 1 \le x \le 1$

Since, $\left| x \right| > 0,;for;all;x$

So, $\left| x \right|$can take minimum value of 0 and maximum value of 1. Also on increasing value of $\left| x \right|$, value of $f\left( x \right)$ decreases. At $\left| x \right| = 0$, we obtain

$f\left( x \right) = 1 - \left| x \right|$

$= 1 - 0 = 1$ (function has maximum value)

Again, at $\left| x \right| = 1$, we obtain

$f\left( x \right) = 1 - \left| x \right|$

$= 1 - 1 = 0$ (function has minimum value)

Thus, at $\left| x \right| = 0$ value of $f\left( x \right)$ is maximum and at $\left| x \right| = 1$ value of $f\left( x \right)$ is minimum.

Out of all the given sentences, only the sentence in option 1 is entirely correct with respect to grammar and usage.

Here are the errors in the other sentences:

• Option 2: The verb 'were' should actually be 'was' since the subject 'information' is singular.
• Option 3: The word 'real' should instead be 'really' - an adverb to describe the adjective 'useful'.
• Option 4: 'Would not had been' is an ungrammatical tense construction.

Hence, the correct answer is option 1.

We redraw this triangle as

In triangle, the internal bisector of an angle bisect the opposite side in the ratio of the other two sides. So, we have

$\begin{array}{l} \frac{{QS}}{{SR}} = \frac{{PQ}}{{PR}}\ \frac{{QS}}{{SR}} = \frac{r}{q}\ \frac{{QS + SR}}{{SR}} = \frac{{r + q}}{q}\ \frac{{SR}}{{QR}} = \frac{q}{{r + q}}\ SR = \frac{{qp}}{{r + q}} \end{array}$

By using cosine formula in triangle ${\rm{\Delta }}PSR$,

$\begin{array}{l} \cos 60^\circ = \frac{{{{\left( {PR} \right)}^2} + {{\left( {PS} \right)}^2} - {{\left( {SR} \right)}^2}}}{{\left( {PR} \right)\left( {PS} \right)}}\ \frac{1}{2} = \frac{{{{\left( q \right)}^2} + {{\left( {PS} \right)}^2} - {{\left( {\frac{{qp}}{{r + q}}} \right)}^2}}}{{\left( q \right)\left( {PS} \right)}}\ PS = \frac{{qr}}{{r + q}} \end{array}$

Here $P,R,S,T,U$ are in A.P. So, the difference between two consecutive numbers will be equal, i.e.

$d = R - P = S - R = T - S = U - T$

Where $d$ is common difference for the given A.P. Now, we check the given sequences

Sequence I:

$2P,;2R,;2S;,;2T;,;2U$

The differences between two consecutive numbers are obtained as

$\begin{array}{l} D = 2R - 2P = 2\left( {R - P} \right) = 2d\ D = 2S - 2R = 2\left( {S - R} \right) = 2d\ D = 2T - 2S = 2\left( {T - S} \right) = 2d \end{array}$

Since, the differences are same in each case, so it is in A.P.

Sequence II:

$P - 3,;R - 3,;S - 3,;T - 3,;V - 3$

The differences between two consecutive numbers are obtained as

$\begin{array}{l} D = \left( {R - 3} \right) - \left( {P - 3} \right)\ = R - P - 3 + 3 = R - P = d\ D = \left( {S - 3} \right) - \left( {R - 3} \right)\ = S - R - 3 + 3 = S - R = d \end{array}$

Again, the differences are same in each case, so it is in A.P.

Sequence III:

${P^2},;{R^2},;{S^2},;{T^2},;{V^2}$

The differences between two consecutive numbers are obtained as

$\begin{array}{l} D = {R^2} - {P^2} = \left( {R - P} \right)\left( {R + P} \right)\ = d\left( {R + P} \right)\ D = {S^2} - {R^2} = \left( {S - R} \right)\left( {S + R} \right)\ = d\left( {S + R} \right) \end{array}$

In this case, the differences are not same, so it is not in A.P.

Thus, sequences I and II will be in A.P.

From the given data, we draw the schematic as

Let coordinate of N = (0,0)

Coordinate of M = (0,4)

Coordinate of O = $\left( { - \frac{1}{{\sqrt 2 }},\frac{1}{{\sqrt 2 }}} \right)$

Coordinate of P = $\left( { - \frac{1}{{\sqrt 2 }},\frac{1}{{\sqrt 2 }} - 2} \right)$

Hence by distance formula, we obtain

$\begin{array}{l} = \sqrt {{{\left( {{x_1} - {x_2}} \right)}^2} + {{\left( {{y_1} - {y_2}} \right)}^2}} \ = \sqrt {{{\left( {0 - \frac{1}{{\sqrt 2 }}} \right)}^2} + {{\left( {4 + 2 - \frac{1}{{\sqrt 2 }}} \right)}^2}} \ = 5.34;km \end{array}$

Concept:

Hypothetical syllogism,

If p → q and q → r then p → r

Formula:

p → q ≡ ¬ q → ¬ p ≡ ¬ p ∨ q 

Explanation:

C(x): x is known to be corrupt

E(x): x will be elected

K(x): x is kind

Statement S1 can be written as:

${\rm{S}}1 \equiv {\rm{C}}\left( {\rm{x}} \right){\rm{;}} \to \neg {\rm{E}}\left( {\rm{x}} \right)$ 

S2 can be written as:

${\rm{S}}2 \equiv {\rm{K}}\left( {\rm{x}} \right) \to {\rm{E}}\left( {\rm{x}} \right) \equiv \neg {\rm{E}}\left( {\rm{x}} \right) \to \neg {\rm{K}}\left( {\rm{x}} \right)$ 

By using hypothetical syllogism,

From S1 and S2, the conclusion is

${\rm{C}}\left( {\rm{x}} \right) \to {\rm{;}}\neg {\rm{;K}}\left( {\rm{x}} \right) \equiv {\rm{K}}\left( {\rm{x}} \right) \to \neg {\rm{C;}}\left( {\rm{x}} \right)$

If a person is kind, then he is not known to be corrupt.

R be the relation on the set of positive integers such that aRb if and only if a and b are distinct and have a common divisor other than 1.

Let A = {1, 2, 3, 4, 5, 6…}

aRb ≡ (a, b}

• R cannot be reflexive because aRa, a and a are not distinct.

Example: R = {(4,6)}

• R is symmetric because if aRb is there then bRa is also possible, in both a and b are distinct.

Example:  R = {(6, 4), (4,6)}  

• R is not transitive as aRb and bRc doesn’t mean aRc.

Example: R = {(6, 4), (4,6)} since (6,6) cannot be included and hence it cannot be transitive

So, given relation is symmetric but not transitive and not reflexive.

Code in C programming language:

#include<stdio.h>

int not_max_min(int a, int b, int c)

{

if ((a < b && b < c) || (c < b && b < a))

    return b;

else if ((b < a && a < c) || (c < a && a < b))

    return a;

else

    return c;

}

int main()

{

    int list[] = {2,1,34,3,9,31};

    printf("%d",not_max_min(list[0], list[1], list[2]));

    return 0;

}

Explanation:

Constant amount of comparison is needed to find neither maximum nor minimum element from and unordered distinct list and therefore time complexity for comparison is O(1).

Alternate method:

Here, it means to find an element which is greater than an element and lesser than another element. We have a given an unordered list contains n distinct element so, we just need three elements to get that element. To analyse that it will take constant amount of time.

Consider the example:

Let us take the elements as {15, 20, 16, 8, 80}. Output should be 15, 16, 20.

Here minimum = 8, maximum = 80

Pick any three elements from given list. Let the three elements: 15, 20, 8. By three comparisons, we can find that the middle element is 20.

It will take O(1) time to find an element in the list that is neither maximum nor minimum.

Statement I: TRUE

A decision problem is a problem that can be posed as a yes or no. If we can decide a problem, then its complement is also decidable. So, given statement is true.

Statement II: FALSE

NP class problems are the problems which can be solved in polynomial time using non-deterministic machine. None of the NP class problem is undecidable. So, this statement is incorrect

Statement III: TRUE

As it is explained in option II none of the NP class problem is undecidable. So, given statement is correct.

Concept:

If (*a && *a!= ‘ ’)

In this priority of != is greater than && in C. If will break either when a space occurs in the string or a Null ‘\0’ occurs in the string.

Explanation:

Consider the array of string with base address 100:

\

Recursive call:

Traverse the tree from top to bottom and left to write

Output: DCBA

Consider complete binary tree where left and right subtrees of the root are max-heaps given below

To convert the tree into a heap which is possible by calling MAX-HEAPIFY at root. MAX- HEAPIFY operation takes time as the height of the tree. i.e. if we have n elements in the tree then log(n) is the height of the tree.

Step 1: Swap 10 and 40

Step 2: swap 10 and 25

The above tree is a MAX-HEAP

To convert this into a max heap it takes only 2 swap and 2 comparison which is nothing but the height of the tree. So, log(n) time is required to convert the tree into a heap.

Software requirement specification (SRS) is a description of a software system to be developed.  Specification types that are included are functional, non- functional, interfaces, performance, maintainability etc.

But design specification is not included in software requirement specification.  Design is something related to implementation.

Concept:

If a NP complete problem is reducible to another problem in polynomial time than that other problem becomes NP hard.

If X ϵ NP complete and X reduces to Y in polynomial time than Y is NP hard.

3 - SAT is NP complete problem

Explanation:

Q₁ reduces in polynomial time to 3- SAT. As 3 - SAT is NP complete problem, Q₁ is easier than NPC. So, Q₁ can’t be NP hard. It is in NP.

3- SAT reduces in polynomial time to Q₂. As, 3- SAT is NP complete so, Q₂ will be NP hard.

Therefore, Q₁ is NP and Q₂ is NP hard.

Lexical analysis: Lexical analysis is the first phase of compiler also known as scanner. It converts the high-level input program into a sequence of tokens. Lexical analysis can be implemented by deterministic finite automata.

Parsing: Parser constructs a production tree. Parse tree is a hierarchical structure which represents the derivation of the programmer to yield input strings.

Register allocation: Register allocation reduces to graph coloring problem in which colors (registers) are assigned to the nodes such that two nodes connected by an edge do not receive the same color.

Expression evaluation: Expression evaluation is done using post order traversal.

• Abstract syntax tree (AST) is a tree that represents the abstract syntactic structure of a language construct where each interior node and the root represents an operator and the children of the node represent the operands of that operator.
• Control flow graph (CFG) is the graphical representation of control flow or computation during the execution of programs or applications. These are mostly used in static analysis as well as computer applications.

Option 1: FALSE

In CFG code of N₂ may be present before N₁ when there is a loop or goto.

Option 2: FALSE

CFG contains cycle when input program has loop.

Option 3: TRUE

Successors in AST and CFG depend on input program.

Option 3: FALSE

A single statement may belong to a block of statements.

BASIC COCOMO: 

It is the simplest version of the COCOMO model which uses only LOC (line of code) as an input matrix to predict the cost, time and team size.

In BASIC COCOMO,

Development effort(E) = a_b (KLOC) exp(b_b)

where KLOC is the size of the program in lines of code.

Development time (D) = c_b (E) exp(d_b)

Team size = (development effort) / (development time)

Data:

Available identical Resources = R = 6

Max needs per process = 2

Concepts:

Deadlock can occur If any process gets available resource < needed (requested) resource

Max resource per process to be in deadlock = needed – 1 = 2 – 1 = 1

For N process, max resource to be in deadlock = N × 1 = N

Condition for deadlock

N ≥ R

N ≥ 6

values of N could lead to a deadlock is 6

Explanation:

As there are 6 identical resources and Max requirement is 2, hence Max. number of process can be allowed is

But when the number of process is more than 5

Important Point:

In GATE, option 4 is 4, which won't give the correct answer and hence option 4 has been changed to 6

ACID Properties:

ATOMICITY: It states that either all the operations of a transaction are executed or NULL.

ISOLATION: It states that each transaction of the concurrent schedule is unaware from another transaction that is parallel executed even if that transaction is executed on same data item.

DURABILITY: It states that after the successful execution of the transaction on the database all the modifications must be reflected on the database even after the system failure.

CONSISTENCY: It states that after the execution of a transaction the database must be in the consistent state (as that before execution).

Explanation:

Let us assume that RS.50 is debited from one account and credited to another account, in such case T₁ transaction should execute first then T₂

Before transaction: Initially

x = 100 and y = 150 then x + y = 250

After transaction: Finally

x = 50 and y = 200 then x + y = 250

The constraint that the sum of the accounts x and y should remain constant is that of consistency.

BIND:

bind () function call binds a unique local name to the socket with descriptor socket. After calling socket (), a descriptor does not have a name associated with it.

LISTEN:

It causes a bound TCP socket to enter the listening state. It waits for the connections to socket.

ACCEPT:

It accepts a connection on a socket.

RECV:

It is used to read incoming data on connection-oriented sockets or connectionless sockets.

• Cookies are messages that web servers pass to your web browser when user visit Internet sites. Web browser stores each message in a small file, called cookie.txt.
• When user request another page from the server, browser sends the cookie back to the server. These files typically contain information about users visit to the web page, as well as any information user have volunteered, such as your name and interests.
• Cookies are not piece of code; they are just string typically in the form of key value pairs.

Key points about cookies:

It is used to track the browsing pattern of a user.

It gains entry to the user’s work area through an HTTP header.

It has an expiry date and time.

Destination ip address of incoming packet is ANDed with the net mask with the longest prefixed, if it matches with the corresponding interface otherwise we AND the input ip address with next longest prefixed netmask and so on, If no match is found them we choose default interface.

Hence:

The fragment offset: Offset of a fragment relative to the beginning of the original fragment IP datagram in units of 8 byte blocks.

Total size of input data in Network layer = 8880 + 8 = 8888

Each T.U. can carry Max 1480 Bytes of Network layer packet.

Hence # transmission $= ;\left\lceil {\frac{{8888}}{{1480}}} \right\rceil; = ;7$

Also 1480 × 6 = 8880

Hence the last transmission will carry only.

8  data bytes and a total of 28 bytes.

Also, No. of 8 – byte blocks of network ahead of last fragment is $\frac{{8888}}{8}; = ;1110$

Concept:

RTT (Round trip time) is the length of time it takes for a signal to be sent plus the length of time it takes for an acknowledgement of that signal to be received.

Bandwidth delay product: It gives the maximum amount of data that can be transmitted by the sender at a given time before waiting for acknowledgement.

It is measured in terms of RTT × Bandwidth.

Explanation:

In TCP, sequence number is limited to 16 bits i.e. TCP allows scaling of windows when bandwidth delay product is greater than 65,535.

Here, it is given that bandwidth = 1048560 bits/sec

RTT = α ms

Maximum possible window size = β

Bandwidth delay product = 1048560 × ∝

65535 B = 1048560 × α

α = 500 milliseconds

When we do scaling, window size increases from 64KB to 1 GB i.e. from 2¹⁶ B to 2³⁰ B.

A 14-bit shift count is used in TCP header.

i.e. from 65535 to 65535 × 2¹⁴ Bytes

Concept:

Check pointing is a mechanism where all the previous logs are removed from the system and stored permanently in the storage disk. Checkpoint declares a point before which the DBMS was in consistent state, and all the transactions were committed.

It maintains two list - undo list and redo list.

• If the recovery system sees a log with <Tn, start> and <Tn, commit> or just <Tn, commit> , it puts the transaction in the redo list.
• If the recovery system sees a log with <Tn, start> but no commit or abort log found, it puts the transaction in undo list.

Explanation:

Above operation are shown in table as:

Now, as T1 and T3 are uncommitted, they must be undone. T2 is committed but it is after checkpoint so, it must be redone. As, T4 is already committed before checkpoint so, it neither comes in undo list nor in redo list.

Full natural outer join of R₁ and R₂ is :

Hence option 3 is correct:

In best fit approach we choose smallest partition are process can fit in.

Fixed partitions

(Only one process can reside in one partition)

Hence partitions of size 200 KB and 300 KB will not be allotted to any process.

Concept:

Control flow graph (CFG) is the graphical representation of computation during the execution of programs or applications.

Control flow graph for the above intermediate code is given here as:

Control flow graph contains 6 vertices and 7 edges.

L₁: Regular

${L_1}; = ;a\left( {a; + ;b} \right)_a^{; + ;} \cup b\left( {a; + ;b} \right)_b^{; + ;}$

L₂: DCFL: (one comparison)

L₃: Regular

L₃ = \(a^*b^c^\)

• Dijkstra’s Shortest Path uses the greedy method to find the shortest path of a graph G(V, E).
• Floyd-Warshall algorithm uses dynamic programming approach to find all-pairs shortest paths of a graph G(V, E).
• Binary search on a sorted array uses divide and conquer technique to search an element
• Backtracking search on a graph is implemented using a depth-first search technique

We have to find the kth smallest element.

Condition is : if (left_end + 1 > k)

If this condition is true it means k^th smallest element is present of left side. So a recursive call is done to kth_smallest(a, left_end,k);

If condition becomes false and left_end+ 1 is not equal to k, then kth smallest element will be present of right side of array. So, a recrusive call will be done as :

Kth_smallest(a+left_end+1, n-left_end_1, k-left_end -1);

Example:

Consider an array of 10 numbers i.e. N= 10, k= 7

a= {5,4,3,2,1,7,6,10,9,8}

pivot = 5

Step 1: after partition array will be = {4,3,2,1,5,7,6,10,9,8}

Here, left_end = 4

if(left_end < k)                         //else condition is satisifed

so , (a+left_end+1, n-left_end_1, k-left_end -1);

it will become (a+5, 5, 3)

array a = {7, 6, 10, 9, 8}

pivot = 7

STEP 2: After partition ()

Array = {6,7,10, 9, 8}

Left_end = 1

if(Left_end + 1 < k)               // else condition is satisfied

so, (a+2, 3, 1)

array a = {10, 9, 8}

pivot = 10

STEP 3: After partition ()

Array a = {9, 8, 10}

Left_end = 2

Again left_end + 1 > k           // if condition satisified

So, (a, 2, 1)

Array a = {9, 8}

Pivot = 9

STEP 4:

Array = {8,9}

Left _ end = 1

Left_end +1 > k                  // if condition satisifed

So, (a,1,1)

Array = {8}

Pivot = 8

STEP 8: here, left_end = 0,

Left_end + 1 ==k , a[left_end ]= 8

At the end, it returns the left_end value.

Consider h(i) = i² mod 10

Consider h(i) = i³ mod 10

Secant method is used to find the roots of an equation. It is defined by the recurrence relation as:

${x_n} = ;{x_{n - 1}} - f\left( {{x_{n - 1}}} \right)\frac{{{x_{n - 1}} - ;{x_{n - 2}}}}{{f\left( {{x_{n - 1}}} \right) - f\left( {{x_{n - 2}}} \right)}}$

It means secant method requires two initial values that are close to the root.

If we take initially values as x₀ and x₁, we construct a line through the points (x₀, f (x₀)) and (x₁, f(x₁))

By this slope of equation will be:

$y = ;\frac{{f\left( {{x_1}} \right) - f\left( {{x_0}} \right)}}{{{x_1} - {x_0}}}\left( {x - {x_1}} \right) + f\left( {{x_1}} \right)$

The root of the equation will be when y =0;

$x = ;{x_1} - f;\left( {{x_1}} \right)\frac{{{x_1} - {x_0}}}{{f\left( {{x_1}} \right) - f\left( {{x_0}} \right)}}$

We then use this new value of x as x₂ and repeat the process using x₁ and x₂. Continue this process until higher precision is reached.  After all iterations

${x_n} = ;{x_{n - 1}} - f\left( {{x_{n - 1}}} \right)\frac{{{x_{n - 1}} - ;{x_{n - 2}}}}{{f\left( {{x_{n - 1}}} \right) - f\left( {{x_{n - 2}}} \right)}}$

According to above program, this is equivalent to :

x_t  =  x_b – (x_b - x_a) f_b / (f_b – f (x_a))

Current value of stack pointer = 016E

The stack pointer is used to point the top element of the stack, here the value of SP = (016E)₁₆

Before the fetch of the CALL instruction, value of PC = (5FA0)₁₆

First, we have to load the current value of PC into memory stack, it will take 2 Bytes 

And then we have to push PSW register, stack pointer again incremented by 2, So stack pointer finally incremented by 4.

So now the value of SP = (016E)₁₆   +   4   = (0172)₁₆ after execute CALL instruction.

(I) False: f(x) is not defined at x = 0

(II) True: Range of f is ( - µ, µ)

(III) True: \(\mathop \smallint \limits_{ - 1}^1 {x^{ - \frac{1}{3}}}dx; = ;2\mathop \smallint \limits_0^1 {x^{ - \frac{1}{3}}}dx; = ;3\)

X₀ = 1 X₁

X₁ = 0 X₁ + 1 X₂

X₂ = 0 X₁ + {λ}

Equivalent FA is:

Hence regular expression is:

1(0 + 10)∗1

w.k.t. ${G_n}; + ;{\bar G_n}; = ;{k_n}$

\(# edges;in;{K_n}; = ;{n_{{c_2}}}\)

Also self - complimentary graph G_n has half of the total number of edges in k_n.

\(\therefore ;# edges;in;{G_n}; = ;\frac{{{n_{{c_2}}}}}{2}; = ;some;natural;number.\)

$\therefore ;{n_{{c_2}}}; = ;2k$      where k ϵ N

$\frac{{n\left( {n - 1} \right)}}{2}; = ;2k$

$\therefore ;\frac{{n\left( {n - 1} \right)}}{4}$ must be a natural number

Thus 4 should be a factor of n or (n – 1)

(A) FALSE:

e.g.

The only edge in the above tree is bridge.

(B) TRUE:

If an edge is the part of the cycle than its removal will not disconnect the graph.

(C) FALSE:

e.g. 

Here no edge of the clique is a bridge

(D) FALSE:

e.g. 

Option 1: ∀ x ∃y R (x, y) ↔ ∃y ∀ x R(x, y)

∀ x ∃y R (x, y) is not equivalent to ∃y ∀ x R(x, y).

Let R (x, y) represent x > x for the set of numbers as the universe

Example:

∀ x ∃y R (x, y) means for every number x, there exist a number y that is less than x which is true.

While ∃y ∀ x R(x, y) means there is a number that is less than every number. Which is false

Option 2: (∀ x (∃y R(x, y) → S (x, y)]) → ∀ x ∃y S(x, y)

This option is not a tautology. It is a false expression because two predicates can’t be equivalent to single predicate on right side.

Option 4: ∀ x ∀ y P (x, y) → ∀ x ∀ y P (y, x)

Consider P (x, y) as x < y

then ∀ x ∀ y P (x, y) represents for every number x, all y are greater than x.

∀ x ∀ y P (y, x), it means for every number y, there is every x which is greater than y.

These two statements are not equivalent at the same time. So, it is not a tautology.

Option 3:

[∀x ∃y (P(x, y) → R(x, y)] ↔ [∀ x ∃y (¬ P(x, y) ∨ R (x, y)]

As, we know that P → R = ¬ P + R

Here, it is the same statement as that of implication, so it is a tautology.

Concept:

Code inspection:

It is the most formal type of review, which is a kind of static testing to avoid the defect multiplication at a later stage. The main purpose of code inspection is to find defects and it can also spot any process improvement if any.  It usually involves peer examination of the code and each one has a defined set of roles.

Code walkthrough:

It is a peer review in which a programmer leads the review process and the other team members ask questions and spot possible errors against development standards and other issues. This meeting is usually led by the author of the document under review and attended by other members of the team. Review sessions may be formal or informal.

Explanation:

Option 1 (FALSE)

Reason: Unit testing is not necessary before code inspection.

Option 2 (FALSE)

Reason: Code inspection and code walkthrough are not same as explained.

Option 4 (FALSE)

Reason: Code walkthrough is done by programmer lead members or designer of development team or other interested parties.

Option 3 (TRUE)

Reason: Adherence to coding standards is checked during code inspection.