→ Named pipe is a special instance of a file that has no contents on the filesystem.
→ A FIFO special file (a named pipe) is similar to a pipe, except that it is accessed as part of the filesystem. It can be opened by multiple processes for reading or writing. When processes are exchanging data via the FIFO, the kernel passes all data internally without writing it to the filesystem. Thus, the FIFO special file has no contents on the filesystem; the filesystem entry merely serves as a reference point so that processes can access the pipe using a name in the filesystem.
→ The kernel maintains exactly one pipe object for each FIFO special file that is opened by at least one process. The FIFO must be opened on both ends (reading and writing) before data can be passed. Normally, opening the FIFO blocks until the other end is opened also.

Step-1: Given, 5 rows with 8 seats in each row.
Total number of seats = 5*40
= 40 seats
Total number of students= 30
Step-2: Given constraint that, 6th seat in the fifth row is empty
When we are deleting 6th seat, 30 students have 39 choices of seats
Step-3: Total number of choices = ³⁹C₃₀
Total ways to choose = ⁴⁰C₃₀
Step-4: Final probability = ³⁹C₃₀ / ⁴⁰C₃₀
= 1/4

→ The range of sinx value lies between -1 and 1 and whereas log(sinx) value will be the positive value.
→ So the domain of log(log sin(x)) is undefined which is empty Set.

The above problem clearly specifies that sum of subset problem. The sum of the subset problem using recursion will give exponential time. Using dynamic programming we can get pseudo-polynomial time.
Sum of subset problem:
Given a set of non-negative integers, and a value sum, determine if there is a subset of the given set with the sum equal to the given sum.

Example:
Array set[ ]= {1,2,3,4,5} and sum=6
Here there are possible subsets (2,4),(1,2,3) and (5,1).

An abelian group is a commutative group. As per the above options, option C is the correct answer because it follows commutative property.
(x * y )² = x² * y², for any x, y belonging to G

As per code segment,
Step-1: The ith loop will compute from value 1 to 9. If the condition is true, then it computes j=j*i statement.
Step-2: The statement j=j*i is nothing but calculating 9!. If the condition fails automatically while loop will be terminated. It means maximum we can execute 9 values.
Step-3: when x becomes 10 then maximum I value will be 9. So, we can calculate up to 9! And I become 10 then it terminates the condition.

→ Binary numbers are maximum 2n-1.
→ But in question they are given ternary numbers, it means 3x-1.
→ Both will take different no. of bits to represent the same number.
3^x -1 = 2ⁿ -1
3^x = 2ⁿ
Apply log on both side
x= log₃( 2ⁿ)
x=n*log₃2 .

Breadth-first search can be used to solve many problems in graph theory

Examples
1. Copying garbage collection, Cheney's algorithm
2. Find the diameter of the graph
3. Testing bipartiteness of a graph.
4. Finding the shortest path between two nodes u and v, with path length measured by the number of edges (an advantage over depth-first search)
5. (Reverse) Cuthill–McKee mesh numbering
6. Ford–Fulkerson method for computing the maximum flow in a flow network
7. Serialization/Deserialization of a binary tree vs serialization in sorted order, allows the tree to be reconstructed in an efficient manner.
8. Construction of the failure function of the Aho-Corasick pattern matcher.

→ The Microprogram is computing a sequence of microinstructions that controls the operation of an arithmetic and logic unit so that machine code instructions are executed.
→ The Microprogram is set of microinstructions that define the individual operations in response to a machine-language instruction

Here the maximum number of comparisons is m+n-1.
For example: Take 2 sub-arrays of size 3 such as 1,3,5 and another subarray 2,4,6. Then in this case number of comparisons is 5 which is m+n-1 can be taken as O(m+n).

Given data
Step-1: 90% of code were tested,
Testing with the probability=0.9
Step-2: We can write tested data into 0.9 because it is given in percentages.
Step-3: Reliability of the module = Tested data * probability
= 0.9 * 0.9
= 0.81(at most)

Explanation:
→ If there are K search-key values in the file, the path is no longer than ⌈log⌈n/2⌉(K)⌉.
→ A node is generally the same size as a disk block, typically 4 kilobytes, and n is typically around 100 (40 bytes per index entry).
→ With 1 million search key values and n = 100, at most log50(1000000)=4 nodes are accessed in a lookup.
Note: Contrast this with a balanced binary free with 1 million search key values around 20 nodes are accessed in a lookup. Above difference is significant since every node access may need a disk I/O, costing around 20 milliseconds!

→ The primary index is created for the primary key of a table. So, records are usually clustered according to the primary key. It can be sparse.
→ In the sparse index, index records are not created for every search key. An index record here contains a search key and an actual pointer to the data on the disk. To search a record, we first proceed by index record and reach the actual location of the data. If the data we are looking for is not where we directly reach by following the index, then the system starts a sequential search until the desired data is found.
→ The secondary index usually dense.
→ In the dense index, there is an index record for every search key value in the database. This makes searching faster but requires more space to store index records itself. Index records contain search key value and a pointer to the actual record on the disk.

→ It is the best example of referential integrity. In referential integrity, we are using a foreign key.
→ If we want to delete any entity in the dominant entity(Like primary key of a table) then subordinate entity(derived attribute) also deleted.
Note: If we want to delete any subordinate entity in entity then the dominant entity is not going to delete.

→ Memory-mapped I/O uses the same address space to address both memory and I/O devices.
→ The memory and registers of the I/O devices are mapped to (associated with) address values.
→ So when an address is accessed by the CPU, it may refer to a portion of physical RAM, or it can instead refer to the memory of the I/O device. Thus, the CPU instructions used to access the memory can also be used for accessing devices.
→ Each I/O device monitors the CPU's address bus and responds to any CPU access of an address assigned to that device, connecting the data bus to the desired device's hardware register.
→ To accommodate the I/O devices, areas of the addresses used by the CPU must be reserved for I/O and must not be available for normal physical memory.
→ The reservation may be permanent, or temporary (as achieved via bank switching).

It only satisfied statement I. because increasing the memory size increases the rate at which requests are satisfied but can not alter the possibility of deadlock and neither does it play any role in implementation.

Let the element just before x be y and that just after be z. In order to link y to z,
we need x→ Bwd→ Fwd = x.
Fwd and in order to link z to y, we need x→ Fwd→ Bwd=x→ Bwd.

→ Pre order traverses Root, Left, Right.
→ Post order traverses Left, Right, Root.
→ In-order traverses Left, Root, Right.
Tree-1: Post order: GJIHEFBDCA
Tree-2: In order: GJIHEFBDCA

Step-1: Inverter→ NOT gate(b’) will generate 9ns
Step-2: 1st AND gate(ab’) takes 19ns because combining NOT gate(9ns)+extra(10ns)
Step-3: Second AND gate(bc) takes only 12ns because we are not using inverter here.
Step-4: A glitch will take 1st AND gate(ab’) - Second AND gate(bc)
=19-12
=7ns

→ Type checking is the process of verifying and enforcing the constraints of types, and it can occur either at compile time (i.e. statically) or at runtime (i.e. dynamically).
→ Type checking is all about ensuring that the program is type-safe, meaning that the possibility of type errors is kept to a minimum.
→ A language is statically-typed if the type of a variable is known at compile time instead of at runtime. Common examples of statically-typed languages include Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, and Scala.
→ Dynamic type checking is the process of verifying the type safety of a program at runtime. Common dynamically-typed languages include Groovy, JavaScript, Lisp, Lua, Objective-C, PHP, Prolog, Python, Ruby, Smalltalk and Tcl.

→ A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data. CRCs can be used for error correction
→ The design of the CRC polynomial depends on the maximum total length of the block to be protected (data + CRC bits), the desired error protection features, and the type of resources for implementing the CRC, as well as the desired performance.
→ A common misconception is that the "best" CRC polynomials are derived from either irreducible polynomials or irreducible polynomials times the factor 1 + x, which adds to the code the ability to detect all errors affecting an odd number of bits.
→ If we use the generator polynomial g(x)=p(x)(1+x), where p(x) is a primitive polynomial of degree r−1, then the maximal total block length is 2^r−1 −1 , and the code is able to detect single, double, triple and an odd number of errors.

Tt = L / B = 32 bytes/ 128 kbps = 32*8/128 ms = 2 ms
Round trip delay = 2 * Tp = 80 ms (given)
Optimal window size is = (T_t + 2*T_p) / T_t = 82 / 2 = 41
Option is not given, closest option is 40.

→ Given a question is based on circuit-switching.
→ In circuit-switching, the total time required to send data = Setup connection time + Transfer time + Teardown the connection time
→ In datagram-service, the total time required to send data = N*Setup connection time + Transfer time

Types of compilers

1. Incremental compiler: It rebuilds all program modules, incremental compiler re-compiles only those portions of a program that have been modified.
2. Cross-compiler: If the compiled program can run on a computer whose CPU or operating system is different from the one on which the compiler runs, the compiler is a cross-compiler.
3. A bootstrap compiler: is written in the language that it intends to compile. A program that translates from a low-level language to a higher level one is a decompiler.
4. Source-to-source compiler or transpiler: A program that translates between high-level languages is usually called a source-to-source compiler or transpiler.

→ A Use-Definition Chain (UD Chain) is a data structure that consists of a use, U, of a variable, and all the definitions, D, of that variable that can reach that use without any other intervening definitions. A definition can have many forms but is generally taken to mean the assignment of some value to a variable (which is different from the use of the term that refers to the language construct involving a data type and allocating storage).
→ A counterpart of a UD Chain is a Definition-Use Chain (DU Chain), which consists of a definition, D, of a variable and all the uses, U, reachable from that definition without any other intervening definitions.
→ Both UD and DU chains are created by using a form of static code analysis known as data flow analysis. Knowing the use-def and def-use chains for a program or subprogram is a prerequisite for many compiler optimizations, including constant propagation and common subexpression elimination.

→ Peephole optimization is a kind of optimization performed over a very small set of instructions in a segment of generated code. The set is called a "peephole" or a "window". It works by recognizing sets of instructions that can be replaced by shorter or faster sets of instructions.

Replacement Rules:
1. Null sequences – Delete useless operations.
2. Combine operations – Replace several operations with one equivalent.
3. Algebraic laws – Use algebraic laws to simplify or reorder instructions.
4. Special case instructions – Use instructions designed for special operand cases.
5. Address mode operations – Use address modes to simplify code.

Step-1: Memory capacity is 2m KB = 230m Bytes
Step-2: Total number of operations 2n
Step-3: Every instruction involving 3 operands and 1 operator
Step-4: Number of bits needed by instruction is= 3*(m+10)+n
=3m+n+30 bits

→ NOT, AND and OR gates are basic gates
→ NAND and NOR gates are universal gates.
→ With the help of universal gates, we can construct any boolean expressions. These gates are also called functionally complete.
→ AND+NOT=NAND→ Functionally Complete
→ OR+NOT=NOR→ Functionally Complete
→ NOR→ Functionally Complete
→ AND+OR→ Not functionally complete

F and L must point to the first and last elements respectively.
Option B: It needs only the operation F=F→ next
Option C: It needs only the operations L→ next=new node, L = new node
Option D: It needs only the operations T=F, F=F→ next, T→ next =F→ next, F→ next=T
→ All these operations do not depend on the length of the list.
→ Indeed in order to delete the last element from the list, we need to first locate the element before the last (which can not be accessed from L). Thus we must parse all the list from the first and till the element just before the last after which we can delete the last element and assign L to the one before.

Step-1: Both < letter > and < digit > produce only a single character
Step-2: Both < pairlet > and < pairdig > produce even number of characters
Step-3: < word > produces odd number of characters.
Step-4: As per the statements I, II and III. I statement having even number of characters
So, a statement I is wrong. Statement II and III are having odd number of characters.

→ In cryptography, the avalanche effect is the desirable property of cryptographic algorithms, typically block cyphers and cryptographic hash functions, wherein if input is changed slightly (for example, flipping a single bit), the output changes significantly (e.g., half the output bits flip).
→ In the case of high-quality block cyphers, such a small change in either the key or the plaintext should cause a drastic change in the ciphertext.

In neural network, the network capacity is defined as the number of patterns that can be stored and recalled in a network

→ Cloaking takes a user to other sites than he or she expects by disguising those sites' true content.
→ During cloaking, the search engine spider and the browser are presented with different content for the same Web page.
→ HTTP header information or IP addresses assist in sending the wrong Web pages.
→ Searchers will then access websites that contain information they simply were not seeking, including pornographic sites.
→ Website directories also offer up their share of cloaking techniques.

→ The most secure approach is to use two firewalls to create a DMZ.
1. The first firewall (also called the "front-end" or "perimeter" firewall) must be configured to allow traffic destined to the DMZ only.
2. The second firewall (also called "back-end" or "internal" firewall) only allows traffic from the DMZ to the internal network.

This setup is considered more secure since two devices would need to be compromised. There is even more protection if the two firewalls are provided by two different vendors because it makes it less likely that both devices suffer from the same security vulnerabilities.

→ Candidate means uniquely identified key.
→ In the above table, Room having duplicate values. So, we can’t say room is candidate key
→ The last name also having duplicates. So, we can’t say the last name is candidate key.
→ Shift also having duplicate keys, so we can’t say shift also a candidate key.
→ Combining Room and Shift we can say that candidate key.

Given data,
A) F= E * 0.5
B) E=A+B
C) D=B+0.5
D) G=E+F
E) C=A+10.5
It is given A, B, C are already assigned values, so we can perform any of B or C or E first but not A. so option(c) is incorrect .
Option(a) is incorrect because we can't perform operation D before operation A.
Option(d) is incorrect because we can't perform operation D before operation A.
Hence option(b) is only correct.

→ The above iterative code is computes the GCD of two numbers using euclidean algorithm.
→ The procedure is to subtract smaller number from larger. So that we can reduce larger number then doesn’t change the value of GCD.
→ if we performing number of iterations based on condition the larger of two numbers will end up with GCD.

Option A: False: A = {aⁿ bⁿ | n=1,2,3,…. } is Deterministic Context Free Language(DCFL) but not regular.
Option B: False: Equal number of a's and equal number of b's is also DCFL but not regular
Option C: False: L(A*B) ∩ B gives the set B but not set A.
L(A*B)= {AB+ AAB + …+AAAAB+B}
L(A*B)∩B=B

CFG (Context Free Grammar) is not closed under complementation

Let consider an example string:
Input = 1000
Output = 1111
The FSM, doesn't change until the first 1 come
I/p = 1000
1's complement = 0111
2's complement = 0111
---------------------------
1000 = I/p
----------------------------
It results 2's complement.

Explanation:
→ For CNF, it is 2x - 1
→ For GNF, it is x

→ Candidate Key of given relation R is {ab}.
→ So option A is right it is not in second normal form because its part of key(candidate key) determines non-key.
→ The domains of a, b, c and d include only atomic values.
So, which satisfies the definition of first normal form.

→ The query results a names of students who got an A grade in at least one of the courses taught by Sriram.
→ The above query they are using AND command, it means it satisfy all conditions.

Solution: A but official key given solution D
→ It gives compilation error because declaration of “intc” is wrong.
→ q+=b(a(q)) and r+=a(c(r)) will result compilation error.

→ The computation requires 100 seconds on a single processor implies that 40% of the computation takes 40 seconds on any number of processors and the remaining 60% takes 60 / (#processors) seconds on parallel computation which becomes 30 seconds on two processors and 15 seconds on four.
→ Hence, in total, the computation takes 40+30=70 seconds on two processors and 40+15=55 seconds on four processors.

→ Directory based coherence is a mechanism to handle Cache coherence problem in Distributed shared memory (DSM).
→ Non-Uniform Memory Access (NUMA). Another popular way is to use a special type of computer bus between all the nodes as a "shared bus" (System bus).
→ Directory-based coherence uses a special directory to serve instead of the shared bus in the bus based coherence protocols.
→ In directory-based cache coherence, this is done by using this directory to keep track of the status of all cache blocks, the status of each block includes in which cache coherence "state" that block is, and which nodes are sharing that block at that time, which can be used to eliminate the need to broadcast all the signals to all nodes, and only send it to the nodes that are interested in this single block.

Step-1: Initially, the heap structure is

Step-2: We have to perform 2 delete operations.
In max-heap (or) min-heap by default we are deleting root element only.
After 1st delete, the heap structure is

Step-3: After 2nd delete operation, the heap structure is

→ The functional user requirements of the software are identified and each one is categorized into one of five types: outputs, inquiries, inputs, internal files, and external interfaces.
→ Once the function is identified and categorized into a type, it is then assessed for complexity and assigned a number of function points.
→ Each of these functional user requirements maps to an end-user business function, such as a data entry for an Input or a user query for an Inquiry.
→ This distinction is important because it tends to make the functions measured in function points map easily into user-oriented requirements, but it also tends to hide internal functions (e.g. algorithms), which also require resources to implement.

Cohesion is a measure of the degree to which elements of a module are functional related.

→ The Operating System of a computer may periodically collect all the free memory space to form a contiguous block of free space. This is called garbage collection
→ We can also use compaction to minimize the probability of external fragmentation.
→ In compaction, all the free partitions are made contiguous and all the loaded partitions are brought together.

*(kd -> name +2) /* this is wrong statement */
We have to write *((*kd).name+2).
Note: They are specifically asked about a value stored at that location of the string by using "*" outside the brackets. Otherwise, option A and B would be correct.

There is a direct formula to find the number of child processes is 2ⁿ -1 =3 times and already one ‘yes’ they are given. So, it will print 4 times ‘yes’

√(224)_r = 13_r
For f(x) to be maximum
f'(x) = 4x - 2 = 0
⇒ x = 1/2
So at x = 1/2, f(x) is an extremum (either maximum or minimum).
f(2) = 2(2)² - 2(2) + 6 = 10
f(1/2) = 2 × (1/2)² - 2 × 1/2 + 6 = 5.5
f(0) = 6
So, the maximum value is at x=2 which is 10 as there are no other extremum for the given function.

Page fault table is

The main memory already has the pages 1 and 2, with page 1 having brought earlier than page 2. So, total 6 page faults. 6-2=4

A requires 3, B-4, C-6;
→ If A has 2, B has 3, C has 5 then a deadlock will occur i.e., 2+3+5=10.
→ If we have one extra resource then a deadlock will not occur i.e., 10+1=11.
→ If we have equal (or) more than 11 resources then deadlock will never occur.

Main memory = 1000K
Job 1 requiring 200 K arrives
Job 2 requiring 350 K arrives
Job 3 requiring 300 K arrives and assuming continuous allocation:
Free memory = 1000 − 850(200 + 350 + 300) = 150 K (till these jobs first fit and best fit are same)
Since, job 1 finishes, Free memory = 200 K and 150 K
Case 1: First fit
Job 4 requiring 120 K arrives
Since 200 K will be the first slot, so Job 4 will acquire this slot only. Remaining memory = 200 – 120 = 80 K
Job 5 requiring 150 K arrives
It will acquire 150 K slot
Job 6 requiring 80 K arrives
It will occupy 80 K slot, so, all jobs will be allocated successfully.
Case 2: Best fit
Job 4 requiring 120 K arrives
It will occupy best fit slot which is 150 K. So, remaining memory = 150 − 120 = 30 K
Job 5 requiring 150 K arrives
It will occupy 200 K slot. So, free space = 200 − 150 = 50 K
Job 6 requiring 80 K arrives
There is no continuous 80 K memory free. So, it will not be able to allocate.
So, first fit is better.

FCFS
Total seek time in FCFS Scheduling when the disk drive is reading from cylinder 20 for cylinders in the order 10, 22, 20, 2, 40, 6, and 38.

In this, maximum size of cluster=4(S6, S3, S7, S1)
→ Worst case of finding a number is equal to maximum size of cluster + 1(after searching all the cluster it enters into empty cluster)
→ Maximum number of comparisons = 4 + 1 = 5

T(n)= T(n-1) + T(n-2) – T(n-3)"
Solution:
Better way of solving is substitute.
T(1) = 1
T(2) = 2
T(3) = 3
T(4) = T(3) + T(2) - T(1) = 4
T(5) = T(4) + T(3) - T(2) = 5
:
:
T(n) = T(n-1) + T(n-2) - T(n-3) = n-1 + n-2 - n + 3 = n
So order is O(n)

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

→ R has no duplicate if R can have duplicates it can be removed in the final state.
→ S in non-empty if S is empty then R*S becomes empty.

→ Logical data independence:
The ability to change the Conceptual (Logical) schema without changing the External schema (User View) is called logical data independence. For example, the addition or removal of new entities, attributes, or relationships to the conceptual schema or having to rewrite existing application programs.

→ Physical data independence:
The ability to change the physical schema without changing the logical schema is called physical data independence. For example, a change to the internal schema, such as using different file organization or storage structures, storage devices, or indexing strategy, should be possible without having to change the conceptual or external schemas.
Note: Immunity is when data at one layer is changed, it does not affect the data at another level.

→ A functional dependency is a constraint between two sets of attributes in a relation from a database. In other words, functional dependency is a constraint that describes the relationship between attributes in a relation.
→ An attribute is fully functional dependent on another attribute, if it is Functionally Dependent on that attribute and not on any of its proper subset.
For example, an attribute X is fully functional dependent on another attribute Y, if it is Functionally Dependent on X and not on any of the proper subset of Y.

Must satisfied conditions:
i) X is functionally dependent on Y and
ii) X is not functionally dependent on any subset of Y.

→ There are 2 conflicting actions a and b is shown in above diagram.
→ In timestamp ordering protocol, conflicting actions in ascending order time-stamps are allowed i.e 'a' is allowed but not 'b'.
→ So we need to roll back T1 after that only it will be allowed. Because of all conflicting actions in ascending order timestamps in below diagram.

→ In mathematics the transitive closure of a binary relation R on a set X is defined as the smallest relation on X that contains R and is transitive. More formally, the transitive closure of a binary relation R on a set X is the transitive relation R+ on set X such that R+ contains R and R+ is minimal.
→ For example, if X is a set of airports and x R y means "there is a direct flight from airport x to airport y" (for x and y in X), then the transitive closure of R on X is the relation R+ such that x R+ y means "it is possible to fly from x to y in one or more flights". Informally, the transitive closure gives you the set of all places you can get to from any starting place.
→ To find the transitive closure of given relation, we can represent the given relation by the graph such that if x R y then there should be directed edge between x and y in a graph.
→ The time complexity of floyd warshall algorithm is O(V3) where V is the number of vertices in the given graph. Take V as the number of elements is set i.e., N.
→ Therefore time complexity for the given question is O(n3).

→ Reentrant code is commonly required in operating systems and in applications intended to be shared in multi-use systems. A programmer writes a reentrant program by making sure that no instructions modify the contents of variable values in other instructions within the program.
→ Each time the program is entered for a user, a data area is obtained which keep all the variable values for that user. The data area is in another part of memory from the program itself. When the program is interrupted to give another user a turn to use the program, information about the data area associated with that user is saved.
→ When the interrupted user of the program is once again given control of the program, information in the saved data area is recovered and the program can be re-entered without concern that the previous user has changed some instruction within the program.

In any recursive procedure:
→ P has an execution path where it does not call itself
→ P either refers to a global variable or has at least one parameter

Recursion Rules
Each recursive call should be on a smaller instance of the same problem, that is, a smaller subproblem.
The recursive calls must eventually reach a base case, which is solved without further recursion.

→ Since there is one line of output for each loop, we need to determine the number of
times the loop executes. Since i is constant, we need to see the growth of j only.
→ Let the initial value of j be denoted by J1 and the subsequent values by J_n for n= 2, 3,... so that J denotes a progression of j. We see that J_n = 2J_n-1;
→ J₁ = 2, which gives J_n = 2^n-1;
n = 1, 2, ...
→ The loop will execute as long as i/j=2.0/2^n-1 >0.001 which gives n<3log₂10+2 (or) n<11.97.
→ Thus the loop will execute 11 times which is equivalent to say there will be 11 lines of output.

This question need presence of mind.
Step-1: Observe all options, 4 options they are given 4th and 5th blank is temp and i+1.
So, they given clue that, 4th and 5th options must be temp and i+1.
Step-2: Based on the 4th and 5th options, we can guess that 1st blank is i → Suppose if we are considering i>min then the control goes out of the while loop in the initial case when i=0 and min=n. So, 1st blank should be i Step-3: According to 1st blank, we can eliminate A and C options.
Step-4: Assume 2nd blank is correct, we are considering j!= (n+i) mod n this condition in while loop.
→ The meaning of the condition is “j becomes equal to (n+i)mod n then control goes out of the while loop.”
Step-5: The condition (n+i)mod n=i and j is always equal to i because we are assigning the value of i to j in the code segment line 3.
Step-6: based on these constraint we can say that 4th option is correct.
Reason: The control never enters the 2nd while loop. Sometimes it will enter the 2nd while loop, when we shift the numbers. It means total K places left.