GATE Computer Science Engineering(CSE) 2027 Test: Array & Linked List Free

j+(sum of natural number till i-1) because if you form a lower triangular matrix it contains elements in rows 1,2,3,...
So C is the correct answer.
PS: Though not mentioned in question, from options it is clear that array index starts from 1 and not 0.

A [ LB₁..............UB₁,LB₂.................UB₂ ]

BA = Base address.

C = size of each element.

Row major order.

Loc(a[i][j]) = BA + [ (i-LB₁) (UB₂ - LB₂ + 1) + (j - LB₂) ] * C.

Column Major order

Loc(a[i][j]) = BA + [ (j-LB₂) (UB₁ - LB₁ + 1) + (i - LB₁) ] * C.

substituting the values. answer is A.

The sum of the i^th row and i^th column is 0 as shown below. Since, the numbers of rows = no. of columns, the total sum will be 0.

as we our area of interest is only the 50 numbers so take An array of 50 numbers where A[0] corresponds to 51...A[49]
corresponds to 100 then after reading an input just increment the counter in correct position as said above

Here when the element of array A and oldc match , we replace that array element of A with array element of newc . For every element of A array update occurs maximum one time.

Similarly for (2) array element of A has updated with array element of newc less than or equal to one time,

Now, for (3) when i=0 , value of A match with oldc[2] i.e.'a' , and replace with newc[2] i.e. also 'a'. So, no changes
when i=1 value of array A[1]='b'
match with oldc[0]='b' and replace with newc[0]='c'.
Now, A[1]='c' which equal with next element of oldc[1]='c'.
So, replace again with newc[1]='d'.
Now, we can say here in array A[1] value replace with newc[0] value , and that newc[0] value replace with next newc[1]
value.

Similarly for (4) here 2 times replacement for A[0] with element newc[0] and newc[1]
Updating of newc value with another newc value is calling flaw here
So Ans B

Here when the element of array A and oldc match , we replace that array element of A with array element of newc . For every element of A array update occurs maximum one time.

Similarly for (2) array element of A has updated with array element of newc less than or equal to one time,

Now, for (3) when i=0 , value of A match with oldc[2] i.e.'a' , and replace with newc[2] i.e. also 'a'. So, no changes

when i=1 value of array A[1]='b'

match with oldc[0]='b' and replace with newc[0]='c'.

Now, A[1]='c' which equal with next element of oldc[1]='c'.

So, replace again with newc[1]='d'.

Now, we can say here in array A[1] value replace with newc[0] value , and that newc[0] value replace with next newc[1] value.

Similarly for (4) here 2 times replacement for A[0] with element newc[0] and newc[1]

Updating of newc value with another newc value is calling flaw here

By the logic of the algorithm it is clear that it is an attempted implementation of Binary Search. So option C is clearly eliminated. Let us now check for options A and D. A good way to do this is to create small dummy examples (arrays) and implement the algorithm as it is. One may make any array of choice. Running iterations of the algorithm would indicate that the loop exits when the x is not present. So option A is wrong. Also, when x is present, the correct index is indeed returned. D is also wrong. Correct answer is B. It is a correct implementation of Binary Search.

1.We first need to shift 2 in place of 1 keeping 5 AND 14 intact as it isn't mentioned in the question that the entire row
elements move.
2. 4 is shifted up,next to 2(keeping 12 and infinity intact in column 2).
3. Now in second row 6 is shifted left.
4.18 shifts up to the second row
5. And finally 25 is shifted left to the third column.
So this takes 5 moves and still maintains the tableau property. Also infinity is placed to the right of 25 and below 23(unfilled entries to be filled with ∞). The final table would look as follows.

B is a permutation of array A

Infact, B gives the reverse index of all the elements of array A. Since the array A contains numbers [1..n] mapped to the locations [1...n] and A is a permutation of the numbers [1...n], the array B will also be a permutation of the numbers [1...n]. For example:

.

To see that option c is incorrect, let array C be the array attained from doing the same transformation twice, that is, 

We can see that C = A, which makes option c incorrect.

suppose we have to insert node p after node q then
p->next=q->next
q->next=p
so two pointers
b)

LInked list are suitable for
Insertion sort:->>No need to swap here just find appropriate place and join the link
Polynomial manipulation:->> Linked List is natural soln for polynomial manipulation .http://iiith.vlab.co.in/?
sub=21&brch=46&sim=490&cnt=697
Radix sort:->here we are putting digits according to same position(unit,tens) into buckets;
which can be effectively handle by linked list.
Not Suitable for
Binary search:-> Bcz finding mid element itself takes O(n) time.
So Option B is ans.

Binary search using linked list is not efficient as it will not give O(logn), because we will not be able to find the mid in constant time. Finding mid in linked list takes O(n) time.

Recursive programs are not efficient because they take a lot of space, Recursive methods will often throw
Stack Overflow  Exception while processing big sets. moreover it has its own advantages too.

A) & B) Here it is not possble to do it in O(1) , unless we have pointer to end of one list. As we have not given that pointer, A & B are not option.
D) It is not possible to do here in O(1), because we will need to allocate memory for bigger array to hold both list & Copy it.
C) It is possible in O(1) as we can break list at any location & connect it anywhere. We don't need to traverse to end of anything here !

A & C is not correct as we can not do binary search in Linked list.
B seems like average case, be we are asked for worst case.
Worst case is we do not find the element in list. We might end up searching entire list & comparing with each element. So
answer -> D. n

It returns 1 if and only if the linked list is sorted in non-decreasing order- B option.
It returns 1 if the list is empty or has just 1 element also, but if and only if makes A option false.

The pointer points to the Rear node.

EnQueue: Insert newNode after Rear, and make Rear point to the newly inserted node:

//struct node *newNode;
newNode->next = rear->next;
rear->next = newNode;
rear=newNode;

DeQueue: Delete the Front node, and make the second node the front node.

//rear->next points to the front node.
//front->next points to the second node.
struct node* front;
front = rear->next;
rear->next = front->next;
free(front);

membership is linear search 

cardinality is linear - 

for union we need to ensure no duplicate elements should be present    for each element we need to check if
that element exists in other set for intersection also for every element in set1 we need to scan set2 

Answer: B

Initially p points to the first node and q points to the second node; the loop executes while q is non-NULL.

Each loop iteration performs three actions: it swaps the values at p and q, then advances p to q->next, and sets q to p ? p->next : 0.

Thus the algorithm swaps values in successive pairs: (node1,node2), (node3,node4), (node5,node6). A final single node with no partner (node7) remains unchanged.

Applying this to 1, 2, 3, 4, 5, 6, 7 produces after pairwise swaps the list 2, 1, 4, 3, 6, 5, 7.

The loop is interchanging the adjacent elements of the list. But after each interchange, next interchange starts from the
unchanged elements only (due to p = q -> next;).
1st iteration 1 2 3 4 5 6 7
=> 2 1 3 4 5 6 7
2nd iteration 2 1 4 3 5 6 7
3rd iteration 2 1 4 3 6 5 7
p pointing to null q pointing to 7, as p is false hence q=p? p->next:0; will return q=0 ending the loop
answer = option B