## Programming

 Question 1
Consider the following C functions.

The return value of fun2 (5) is _______.
 A 55
Programming       Functions       GATE 2020
Question 1 Explanation:
#include
int fun1(int n) {
printf("--fun1 call--\n");
static int i = 0;
if(n>0){
++i;
printf("fun1(%d-1)\n",n);
fun1(n-1);
}
printf("fun1(%d)= %d\n",n, i);
return(i);
}
int fun2(int n) {
printf("\n******* fun2 call ********\n");
static int i = 0;
if(n>0){
printf("%d + fun1(%d)\n", i,n);
i=i+fun1(n);
fun2(n-1);
}
printf("fun2(%d)= %d\n",n, i);
return(i);
}
void main()
{
printf("final = %d\n", fun2(5));
}
Check step by step handrun of the code to understand the recursion:
******* fun2 call ********
0 + fun1(5)
--fun1 call--
fun1(5-1)
--fun1 call--
fun1(4-1)
--fun1 call--
fun1(3-1)
--fun1 call--
fun1(2-1)
--fun1 call--
fun1(1-1)
--fun1 call--
fun1(0)= 5
fun1(1)= 5
fun1(2)= 5
fun1(3)= 5
fun1(4)= 5
fun1(5)= 5
******* fun2 call ********
5 + fun1(4)
--fun1 call--
fun1(4-1)
--fun1 call--
fun1(3-1)
--fun1 call--
fun1(2-1)
--fun1 call--
fun1(1-1)
--fun1 call--
fun1(0)= 9
fun1(1)= 9
fun1(2)= 9
fun1(3)= 9
fun1(4)= 9
******* fun2 call ********
14 + fun1(3)
--fun1 call--
fun1(3-1)
--fun1 call--
fun1(2-1)
--fun1 call--
fun1(1-1)
--fun1 call--
fun1(0)= 12
fun1(1)= 12
fun1(2)= 12
fun1(3)= 12
******* fun2 call ********
26 + fun1(2)
--fun1 call--
fun1(2-1)
--fun1 call--
fun1(1-1)
--fun1 call--
fun1(0)= 14
fun1(1)= 14
fun1(2)= 14
******* fun2 call ********
40 + fun1(1)
--fun1 call--
fun1(1-1)
--fun1 call--
fun1(0)= 15
fun1(1)= 15
******* fun2 call ********
fun2(0)= 55
fun2(1)= 55
fun2(2)= 55
fun2(3)= 55
fun2(4)= 55
fun2(5)= 55
final = 55
 Question 2
Consider the following C functions.

The value returned by pp (3, 4) is ________.
 A 81
Programming       Functions       GATE 2020
Question 2 Explanation:
pp(3,4) ⇒
a=3,b=4
tot=1
ex=a=3
len=tob(b,arr) which is 3
[
tob(4,arr)==>
b=4
b%2 =4%2=0 Condition is false then arr[0]=0
=> b=b/2 =4/2 =2
b=2
b%2 =2%2=0 condition is false then arr[1]=0
=>b=b/2=2/2=1
b=1
then b%2=1%2 condition is true then arr[2]=1
=>b=b/2=1/2=0
The i value is 3 [length is 3]
]
i=0,
arr[0] ==1 condition is false
ex=3*3=9
i=1
arr[1]==1 condition is false
then
ex=9*9=81
i=2
then arr[2]==1 condition is true
tot=tot*ex=1*81=81
ex=81*81
Finally it returns tot value which 81
 Question 3

Consider the following C program:

```#include <stdio.h>

int counter = 0;

int calc (int a, int b) {
int c;

counter++;
if (b==3) return (a*a*a) ;
else  {
c = calc (a, b/3) ;
return (c*c*c) ;
}
}

int main ()  {
calc (4, 81);
printf ("%d", counter) ;
}
```

The output of this program is ______.

 A 4 B 5 C 6 D 7
Programming       Programming       Gate 2018
Question 3 Explanation:
 Question 4

Consider the following C program.

```#include <stdio.h>
struct Outnode {
char x, y, z ;
};

int main () {
struct Ournode p = {'1', '0', 'a'+2} ;
struct Ournode *q = &p ;
printf ("%c, %c", *((char*)q+1), *((char*)q+2)) ;
return 0 ;
}
```

The output of this program is

 A 0, c B 0, a+2 C ‘0’, ‘a+2’ D ‘0’, ‘c’
Programming       Programming       Gate 2018
Question 4 Explanation:
char x = ‘a’+2;
The x variable here stores a character ‘c’ in it.
Because +2 will increment ascii value of a from 92 to 95.
Hence the structure p contains 3 character values and they are ‘1’, ‘0’, and ‘c’.
q is a pointer pointing to structure p.
Hence q is pointing to ‘1’, q+1 pointing to ‘0’ and q+2 pointing to ‘c’.
Option d cannot be correct, as though they are characters, printf will not print them in single quotes.
 Question 5

Consider the following C program:

```#include<stdio.h>

void fun1(char *s1, char *s2)  {
char *tmp;
tmp = s1;
s1 = s2;
s2 = tmp;
}

void fun2(char **s2, char **s2)  {
char *tmp;
tmp = *s1;
*s1 = *s2;
*s2 = tmp;
}

int main ()  {
char *str1 = "Hi", *str2 = "Bye";
fun1(str1, str2);     printf("%s %s", str1, str2);
fun2(&str1, &str2);   printf("%s %s", str1, str2);
return 0;
}
```

The output of the program above is

 A Hi Bye Bye Hi B Hi Bye Hi Bye C Bye Hi Hi Bye D Bye Hi Bye Hi
Programming       Programming       Gate 2018
Question 5 Explanation:
The first call to the function ‘func1(str1, str2);’ is call by value.
Hence, any change in the formal parameters are NOT reflected in actual parameters.
Hence, str1 points at “hi” and str2 points at “bye”.
The second call to the function ‘func2(&str1, &str2);’ is call by reference.
Hence, any change in formal parameters are reflected in actual parameters.
Hence, str1 now points at “bye” and str2 points at “hi”.
Hence answer is “hi bye bye hi”.
 Question 6

Consider the following C code. Assume that unsigned long int type length is 64 bits.

```        unsigned long int fun(unsigned long int n)  {
unsigned long int i, j, j=0, sum = 0;
for (i = n; i > 1; i = i/2) j++;
for ( ; j > 1; j = j/2) sum++;
return sum;
}
```
The value returned when we call fun with the input 240 is
 A 4 B 5 C 6 D 40
Programming       Programming       Gate 2018
Question 6 Explanation:
Since 240 is the input, so first loop will make j = 40.
Next for loop will divide j value (which is 40) by 2, each time until j>1.
j loop starts:
j=40 & sum=1
j=20 & sum=2
j=10 & sum=3
j=5 & sum=4
j=2 & sum=5
j=1 & break
So, sum = 5.
 Question 7

Consider the following program written in pseudo-code. Assume that x and y are integers.

```Count (x, y)  {
if (y != 1)  {
if (x != 1)  {
print("*") ;
Count (x/2, y) ;
}
else  {
y = y - 1 ;
Count (1024, y) ;
}
}
}
```

The number of times that the print statement is executed by the call Count(1024, 1024) is ______.

 A 10230 B 10231 C 10232 D 10233
Programming       PRogramming       Gate 2018
Question 7 Explanation:
#include
int count=0;
Count(x,y){
if(y!=1){
if(x!=1){
printf("*");
count = count +1;
Count(x/2,y);
}
else{
y=y-1;
Count(1024,y);
}
}
}
void main()
{
Count(1024,1024);
printf("\n%d\n",count);
}

Count ( ) is called recursively for every (y = 1023) & for every y, Count ( ) is called (x = 10) times = 1023 × 10 = 10230
 Question 8

Consider the following C code:

```             #include <stdio.h>
int *assignval(int *x, int val)   {
*x = val;
return x;
}

void main ( )  {
int  *x = malloc(sizeof(int));
if(NULL == x)  return;
x = assignval(x, 0);
if(x)  {
x = (int *)malloc(size of(int));
if(NULL == x)  return;
x = assignval(x, 10);
}
printf("%dn",  *x);
free(x);
}
```

The code suffers from which one of the following problems:

 A compiler error as the return of malloc is not typecast approximately B compiler error because the comparison should be made as x==NULL and not as shown C compiles successfully but execution may result in dangling pointer D compiles successfully but execution may result in memory leak
Programming       Programming       Gate 2017 set-01
Question 8 Explanation:
Option A:
In C++, we need to perform type casting, but in C Implicit type casting is done automatically, so there is no compile time error, it prints10 as output.
Option B:
NULL means address 0, if (a == 0) or (0 == a) no problem, though we can neglect this, as it prints 10.
Option C:
x points to a valid memory location. Dangling Pointer means if it points to a memory location which is freed/ deleted.
int*ptr = (int*)malloc(sizeof(int));
free(ptr); //ptr becomes a dangling pointer
ptr = NULL; //Removing Dangling pointers condition
Option D:
x is assigned to some memory location
int*x = malloc(sizeof(int));
→ (int*)malloc(sizeof(int)) again assigns some other location to x, previous memory location is lost because no new reference to that location, resulting in Memory Leak.
Hence, Option D.
 Question 9

Consider the following two functions.

```void fun1(int n)   {                 void fun2(int n)   {
if(n == 0)  return;                  if(n == 0)  return;
printf("%d", n);                     printf("%d", n);
fun2(n - 2);                         fun1(++n);
printf("%d", n);                     printf("%d", n);
}                                    }
```

The output printed when fun1(5) is called is

 A 53423122233445 B 53423120112233 C 53423122132435 D 53423120213243
Programming       Programming       Gate 2017 set-01
Question 9 Explanation:

In fun2, we increment (pre) the value of n, but in fun1, we are not modifying the value.
Hence increment in value in recursion (back).
Hence, 5 3 4 2 3 1 2 2 2 3 3 4 4 5.
 Question 10

Consider the C functions foo and bar given below:

```         int foo(int val)   {
int x = 0;
while (val>0)   {
x = x + foo(val--);
}
return val;
}

int bar(int val)   {
int x = 0;
while (val>0)   {
x = x + bar(val-1);
}
return val;
}```

Invocations of foo(3) and bar(3) will result in:

 A Return of 6 and 6 respectively. B Infinite loop and abnormal termination respectively. C Abnormal termination and infinite loop respectively. D Both terminating abnormally.
Programming       Programming       Gate 2017 set-01
Question 10 Explanation:
while(val>0)
{
x = x + foo(val--);
}
In this case foo(val--) is same as foo(val) & val-- ;
Because the recursive function call is made without changing the passing argument and there is no Base condition which can stop it.
It goes on calling with the same value ‘val’ & the system will run out of memory and hits the segmentation fault or will be terminated abnormally.
The loop will not make any difference here.
while(val>0)
{
x = x + bar(val-1);
}
bar(3) calls bar(2)
bar(2) calls bar(1)
bar(1) calls bar(0) ⇾ Here bar(0) will return 0.
bar(1) calls bar(0)
bar(1) calls bar(0)……..
This will continue.
Here is a problem of infinite loop but not abrupt termination.
Some compilers will forcefully preempt the execution.
 Question 11
Consider the following C program.
```#include <stdio.h>
#include <string.h>

void printlength (char*s, char*t)   {
unsigned int c = 0;
int len = ((strlen(s) - strlen(t)) > c) ? strlen(s):strlen(t);
printf("%d\n", len);
}

void main ()  {
char*x = "abc";
char*y = "defgh";
printlength(x,y);
}
```
Recall that strlen is defined in string.h as returning a value of type size_t, which is an unsigned int. The output of the program is _________.
 A 3 B 4 C 5 D 6
Programming       Programming       Gate 2017 set-01
Question 11 Explanation:
main ( )
{
char*x = "abc";
char*y = "defgh";
printlength(x,y);
}
printlength(char*3, char*t)
{
unsigned int c = 0;
int len = ((strlen(s) - strlen(t))> c) ? strlen(s) : strlen(t);
printf("%d", len);
}
Here strlen(s) - strlen(t) = 3 - 5 = -2
But in C programming, when we do operations with two unsigned integers, result is also unsigned. (strlen returns size_t which is unsigned in most of the systems).
So this result '-2' is treated as unsigned and its value is INT_MAX-2.
Now the comparison is in between large number & another unsigned number c, which is 0.
So the comparison returns TRUE here.
Hence (strlen(s) - strlen(t))>0 will return TRUE, on executing, the conditional operator will return strlen(s)
⇒ strlen(abc) = 3
 Question 12

The output of executing the following C program is __________.

```           #include<stdio.h>
int total (int v)   {
static int count=0;
while(v)   {
count += v&1;
v ≫= 1;
}
return count;
}

void main()    {
static int x = 0;
int i = 5;
for(; 1> 0; i--)    {
x = x + total(i);
}
printf("%d\n", x);
}
```

 A 23 B 24 C 25 D 26
Programming       Programming       Gate 2017 set-01
Question 12 Explanation:
Arithmetic operators have least priority in this case, as count+=v & 1, we first compute v& 1 and then adds to count variable.

 Question 13

Match the following:

 A P→(ii), Q→(iv), R→(i), S→(iii) B P→(ii), Q→(i), R→(iv), S→(iii) C P→(ii), Q→(iv), R→(iii), S→(i) D P→(iii), Q→(iv), R→(i), S→(ii)
Programming       Match-the-Following       GATE 2017(set-02)
Question 13 Explanation:
Static char var:
⇾ A variable located in Data Section of memory

P→(ii), Q→(iv), R→(i), S→(iii)
 Question 14

Consider the following function implemented in C:

```void printxy (int x, int y)   {
int *ptr;
x = 0;
ptr = &x;
y = *ptr;
*ptr = 1;
printf("%d,%d",x,y);
}
```

The output of invoking printxy(1, 1) is

 A 0, 0 B 0, 1 C 1, 0 D 1, 1
Programming       Programming       GATE 2017(set-02)
Question 14 Explanation:
printxy (int x, int y)
{
int *ptr;
x = 0;
ptr = &x;
y = *ptr;
*ptr = 1;

}
printxy (1, 1)
 Question 15

Consider the C program fragment below which is meant to divide x and y using repeated subtractions. The variables x, y, q and r are all unsigned int.

```          while (r >= y)  {
r = r - y;
q = q + 1;
}
```

Which of the following conditions on the variables x, y, q and r before the execution of the fragment will ensure that the loop terminates in a state satisfying the condition x == (y*q + r)?

 A (q == r) && (r == 0) B (x > 0) && (r == x) && (y > 0) C (q == 0) && (r == x) && (y > 0) D (q == 0) && (y > 0)
Programming       Programming       GATE 2017(set-02)
Question 15 Explanation:
Divide x by y.
x, y, q, r are unsigned integers.
while (r >= y)
{
r = r – y;
q = q + 1;
}
Loop terminates in a state satisfying the condition
x == (y * q + r)
y ⇒ Dividend = Divisor * Quotient + Remainder
So, to divide a number with repeated subtractions, the Quotient should be initialized to 0 and it must be incremented for every subtraction.
So initially q=0 which represents
x = 0 + r ⇒ x = r
and y must be a positive value (>0).
 Question 16

Consider the following snippet of a C program. Assume that swap(&x, &y)  exchanges the contents of x and y.

```int main ()  {
int array[] = {3, 5, 1, 4, 6, 2};
int done = 0;
int i;

while (done == 0)  {
done = 1;
for (i=0; i<=4; i++)  {
if (array[i] < array[i+1])  {
swap (&array[i], &array[i+1]);
done = 0;
}
}
for (i=5; i>=1; i--)  {
if (array[i] > array[i-1])   {
swap(&array[i], &array[i-1]);
done=0;
}
}
}
printf("%d", array[3]);
}
```

The output of the program is ___________.

 A 3 B 4 C 5 D 6
Programming       Programming       GATE 2017(set-02)
Question 16 Explanation:
Swap (&x, &y) exchanges the contents of x & y.

(1) ⇒ 1st for i = 0 <= 4
a[0] < a[1] ≃ 3<5 so perform swapping
done =

(1) ⇒ no swap (3, 1)
(2) ⇾ perform swap (1, 4)

(1) ⇒ perform swap (1, 6)

(1) ⇒ perform swap (1, 2)

(1) ⇒ (done is still 0)
for i = 5 >= 1 a[5] > a[4] ≃ 1>2 – false. So, no swapping to be done
(2) ⇾ no swap (6, 2)
(3) ⇾ swap (4, 6)

(1) ⇒ Swap (3, 6)

(1) ⇒ Swap (5, 6)

⇒ Done is still 0. So while loop executes again.
(1) ⇾ no swap (6, 5)
done = 1
(2) ⇾ No swap (5, 3)
(3) ⇾Swap (3, 4)

So, array [3] = 3
 Question 17
Consider the following C program.
```#include
int main () {
int m=10;
int n, n1;
n=++m;
n1=m++;
n--;
--n1;
n-=n1;
printf(“%d”, n);
return 0;
}```
The output of the program is ______
 A 0 B 1 C 2 D 3
Programming       Programming       GATE 2017(set-02)
Question 17 Explanation:
int m=10; int n,n1; n=++m //n=11, m=11 n1=m++ //n1=11, m=12 n-- //n=10 --n1 //n=10 n-=n1 //n=n-n1 = 10-10 = 0 Thus n=0
 Question 18

Consider the following C program.

```#include<stdio.h>
#include<string.h>
int main ()  {
char* c = "GATECSIT2017";
char* p = c;
printf("%d", (int) strlen (c + 2[p] - 6[p] - 1));
return 0;
}
```

The output of the program is __________.

 A 1 B 2 C 4 D 6
Programming       Programming       GATE 2017(set-02)
Question 18 Explanation:
char * C = “GATECSIT2017”;
char * P = C;
(int) strlen (C + 2[P] – 6[P] – 1)

C + 2[P] - 6[P] – 1
∵2[P] ≃ P[2]
100 + P[2] – P[6] – 1
100 + T – I – 1
100 + 84 – 73 – 1
ASCII values: T – 84, I – 73
100 + 11 – 1
= 110
(int) strlen (110)
strlen (17) ≃ 2
 Question 19

Consider the following C program.

```void f(int, short);
void main ()
{
int i = 100;
short s = 12;
short *p = &s;
__________ ;         // call to f()
}
```

Which one of the following expressions, when placed in the blank above, will NOT result in a type checking error?

 A f(s, *s) B i = f(i, s) C f(i, *s) D f(i, *p)
Programming       Programming       2016 set-01
Question 19 Explanation:
int i = 100;
short s = 12;
short *p = &s;
_______ // call to f ( ) :: (void f(int,short);)
It is clearly mentioned the return type of f is void.
By doing option elimination
(A) & (C) can be eliminated as s is short variable and not a pointer variable.
(B) i = f(i, s) is false because f’s return type is void, but here shown as int.
(D) f(i, *p)
i = 100
*p = 12
Hence TRUE
 Question 20

Consider the following C program.

```#include<stdio.h>
void mystery(int *ptra, int *ptrb) {
int *temp;
temp = ptrb;
ptrb = ptra;
ptra = temp;
}
int main() {
int a=2016, b=0, c=4, d=42;
mystery(&a, &b);
if (a < c)
mystery(&c, &a);
mystery(&a, &d);
printf("%d\n", a);
}
```

The output of the program is ________.

 A 2016 B 2017 C 2018 D 2019
Programming       Programming       2016 set-01
Question 20 Explanation:

For the first mystery (&a, &b);

temp = ptr b
ptr b = ptr a
ptr a = temp
If (a The function mystery (int *ptra, int *ptrb) does not change the value of variables pointed by pointers, instead it only changes the addresses inside the pointers, which is in no way going to modify the values of a, b, c, d.
Hence, a = 2016 will be printed.
 Question 21

The following function computes the maximum value contained in an integer array p[] of size n (n >= 1).

```       int max(int *p, int n) {
int a=0, b=n-1;

while (__________) {
if (p[a] <= p[b]) {a = a+1;}
else                 {b = b-1;}
}

return p[a];
}
```

The missing loop condition is

 A a != n B b != 0 C b > (a + 1) D b != a
Programming       Programming       2016 set-01
Question 21 Explanation:
main ( )
{
int arr [ ] = {3, 2, 1, 5, 4};
int n = sizeof(arr) / sizeof (arr[0]);
printf (max(arr, 5));
}
int max (int *p, int n)
{
int a = 0, b = n – 1;
(while (a!=b))
{
if (p[a] <= p[b])
{
a = a + 1;
}
else
{
b =b – 1;
}
}
return p[a];
}
The function computes the maximum value contained in an integer array p [ ] of size n (n >= 1).
If a = = b, means both are at same location & comparison ends.
 Question 22

What will be the output of the following C program?

```void count(int n)  {
static int d=1;

printf("%d ", n);
printf("%d ", d);
d++;
if(n>1) count(n-1);
printf("%d ", d);
}

void main() {
count(3);
}
```
 A 3 1 2 2 1 3 4 4 4 B 3 1 2 1 1 1 2 2 2 C 3 1 2 2 1 3 4 D 3 1 2 1 1 1 2
Programming       Programming       2016 set-01
Question 22 Explanation:

Count (3)
static int d = 1
It prints 3, 1
d++; //d = 2
n>1, count(2)
prints 2, 2
d++; // d = 3
n>1, count(1)
prints 1, 3 → Here n = 1, so condition failed & printf (last statement) executes thrice & prints d
d++; //d=4 value as 4. For three function calls, static value retains.
∴ 312213444
 Question 23

What will be the output of the following pseudo-code when parameters are passed by reference and dynamic scoping is assumed?

```       a=3;
void n(x) {x = x * a; print(x);}
void m(y) {a = 1; a = y - a; n(a); print(a);}
void main() {m(a);}
```
 A 6, 2 B 6, 6 C 4, 2 D 4, 4
Programming       Programming       2016 set-01
Question 23 Explanation:

First m(a) is implemented, as there are no local variables in main ( ), it takes global a = 3;
m(3) is passed to m(y).
a = 1
a = 3 – 1 = 2
n(2) is passed to n(x).
Since it is dynamic scoping
x = 2 * 2 = 4 (a takes the value of its calling function not the global one).
The local x is now replaced in m(y) also.
Hence, it prints 4,4.
And we know it prints 6, 2 if static scoping is used.
It is by default in C programming.
 Question 24

The value printed by the following program is __________.

```     void f(int* p, int m) {
m = m + 5;
*p = *p + m;
return;
}

void main() {
int i=5, j=10;
f(&i, j);
printf("%d", i+j);
}
```
 A 30 B 31 C 32 D 33
Programming       Programming       GATE 2016 set-2
Question 24 Explanation:

P is a pointer stores the address of i, & m is the formal parameter of j.
Now, m = m + 5;
*p = *p + m;

Hence, i + j will be 20 + 10 = 30.
 Question 25

The following function computes XY for positive integers X and Y.

```       int exp (int X, int Y) {
int res = 1, a = X, b = Y;

while ( b != 0 ){
if ( b%2 == 0) { a = a*a; b = b/2; }
else           { res = res*a; b = b-1; }
}
return res;

}
```

Which one of the following conditions is TRUE before every iteration of the loop?

 A XY = ab B (res * a)Y = (res * X)b C XY = res * ab D XY = (res * a)b
Programming       Programming       GATE 2016 set-2
Question 25 Explanation:
int exp (int X, int Y)
{
int res = 1, a = X, b = Y;
while (b != 0)
{
if (b%2 == 0)
{
a = a*a;
b = b/2;
}
else
{
res = res*a;
b = b – 1;
}
}
return res;
}
From that explanation part you can understand the exponent operation, but to check the conditions, first while iteration is enough.
x = 2, y = 3, res = 2, a = 2, b = 2.
Only (C) satisfies these values.
xy = res * ab
23 = 2 * 22 = 8
Explanation:
Will compute for smaller values.
Let X = 2, Y = 3, res = 1
while (3 != 0)
{
if(3%2 == 0) - False
else
{
res = 1*2 = 2;
b = 3 – 1 = 2;
}
For options elimination, consider
return res = 2 (but it is out of while loop so repeat while)
__________
while (2 != 0)
{
if (2%2 == 0) - True
{
a = 2*2 = 4
b = 2/2 = 1
}
__________
repeat while
while (1 != 0)
{
if (1%2 == 0) - False
else
{
res = 2 * 4 = 8
b = 1 – 1 = 0
}
__________
while (0 != 0) - False
return res = 8 (23)
 Question 26

Consider the following program:

```    int f(int *p, int n)
{
if (n <= 1) return 0;
else return max (f(p+1,n-1),p[0]-p[1]);
}

int main()
{
int a[] = {3,5,2,6,4};
printf("%d", f(a,5));
}
```
Note: max(x,y) returns the maximum of x and y.

The value printed by this program is __________.

 A 3 B 4 C 5 D 6
Programming       Programming       GATE 2016 set-2
Question 26 Explanation:
Given

f(a, 5) ⇒ f(100, 5)
 Question 27
The output of the following C program is __________.
```void f1 (int a, int b)
{
int c;
c=a; a=b; b=c;
}
void f2 (int *a, int *b)
{
int c;
c=*a; *a=*b;*b=c;
}
int main()
{
int a=4, b=5, c=6;
f1(a, b);
f2(&b, &c);
printf (“%d”, c-a-b);
return 0;
}```
 A -5 B 6 C 7 D 8
Programming       Programming       GATE 2015 (Set-01)
Question 27 Explanation:
Function f1 will not swap the value of 'a' and 'b' because f1 is call by value.
But f2 will swap the value of 'b' and 'c' because f2 is call by reference. So finally the value of
a=4
b=6
c=5
So, answer will be
c - a - b
5 - 4 - 6 = -5
 Question 28
What is the output of the following C code? Assume that the address of x is 2000 (in decimal) and an integer requires four bytes of memory.
```#include <stdio.h>
int main()
{
unsigned int x[4][3] = {{1, 2, 3}, {4, 5, 6},
{7, 8, 9}, {10, 11, 12}};
printf("%u, %u, %u", x+3, *(x+3), *(x+2)+3);
}```

 A 2036, 2036, 2036 B 2012, 4, 2204 C 2036, 10, 10 D 2012, 4, 6
Programming       Programming       GATE 2015 (Set-01)
Question 28 Explanation:
⇒ Address of x = 2000
⇒ x [4] [3] can represents that x is a 2-dimensional array.
⇒ x+3 = (Address of x) + 3 * 4 * 3 [3×4×3 is inner dimention]
= 2000 + 36
= 2036
⇒ *(x+3) also returns the address i.e., 2036.
The '*' represents 1 - D but x is starting at 2036.
⇒ *(x+3)+3 = *(Address of x + 2 * 3 * 4) + 3
= *(2000 + 24) +3
= *(2024) + 3 ['*' will change from 2D to 1D]
= 2024 + 3 * 4
= 2024 + 12
= 2036
 Question 29
Consider the following pseudo code, where x and y are positive integers.
```begin
q := 0
r := x
while r >= y do
begin
r := r – y
q := q + 1
end
end```
The post condition that needs to be satisfied after the program terminates is
 A {r = qx+y ∧ r B {x = qy+r ∧ r C {y = qx+r ∧ 0 D {q+10}
Programming       Programming       GATE 2015 (Set-01)
Question 29 Explanation:
The loop terminates when r In each iteration q is incremented by 1 and y is subtracted from 'r'. Initial value of 'r' is 'x'. So, loop iterates x/y times and q will be equal to x/y and r = x%y.
⇒ x = qy + r
 Question 30
Consider the following C program segment.
```while (first <= last)
{
if (array [middle] < search)
first = middle +1;
else if (array [middle] == search)
found = True;
else last = middle – 1;
middle = (first + last)/2;
}
if (first < last) not Present = True;
```
The cyclomatic complexity of the program segment is __________.
 A 5 B 6 C 7 D 8
Programming       Programming       GATE 2015 (Set-01)
Question 30 Explanation:
Note: Out of syllabus.
 Question 31
Consider the following C function.
```int fun1 (int n)
{
int i, j, k, p, q = 0;
for (i = 1; i<n; ++i)
{
p = 0;
for (j = n; j > 1; j = j/2)
++p;
for (k = 1; k < p; k = k*2)
++q;
}
return q;
}```

 A n3 B n(log n)2 C nlog n D nlog (log n)
Programming       Programming       GATE 2015 (Set-01)
Question 31 Explanation:
for (i=1; i p=0;
for (j=n; j>1; j=j/2) --- p = O(log n) ++p;
for (k=1; k ++q;
}
∴ The return value of the function fun1,
q = n log p
= n log log n
 Question 32
Consider the following function written the C programming language.
 A ABCD EFGH B ABCD C HGFE DCBA D DCBA
Programming       Programming       GATE 2015 -(Set-2)
Question 32 Explanation:

if condition fails
& returns controls
∴ DCBA will be pointed
 Question 33
Consider the following C functions
 A 51 B 52 C 53 D 54
Programming       Programming       GATE 2015 -(Set-2)
Question 33 Explanation:
Recurrence Relation is
f(n) = 1; if n = 1
 Question 34
Consider the C program below The value printed by the above program is _______________
 A -2 B 2 C -1 D 15
Programming       Programming       GATE 2015 -(Set-2)
Question 34 Explanation:
When first time stkFunc (-1,10) will be called then, inside Switch(opcode) the control will go to Case-I, where size=10.
When next time stkFunc (0,5) is called then, inside Switch(opcode), the control will go to Case-0, where A[0]=5 and stkTop = 0+1 =1.
When next time stkFunc (0,10) is called then, inside Switch (opcode), the control will go to Case '0', where A[1]=10 and stkTop=1+1=2.
When next time stkFunc(1,0) is called from inside the printf statement, then inside Switch(opcode), the control will go to default and stkTop = 2-1 = 1 and value of A[1] will get returned, i.e., 10.
When next time stkFunc(1,0) is called from inside the printf statement, then inside Switch(opcode), the control will go to default and stkTop = 1-1 = 0 and value of A[0] will get returned, i.e., 5.
Finally the two values 10 & 5 will be added and printed.
 Question 35
Consider the following C program segment.
 `# include ` `int` `main( )` `{` `    ``char` `s1[7] = ``"1234"``, *p;` `    ``p = s1 + 2;` `    ``*p = ``'0'` `;` `    ``printf` `(``"%s"``, s1);` `}`
What will be printed by the program?
 A 12 B 120400 C 1204 D 1034
Programming       Programming       GATE 2015(Set-03)
Question 35 Explanation:
p = s1+2;
p now points to third element in s1, i.e., '3'.
*p = '0', will make value of '3' as '0' in s1. And finally s1 will become 1204.
 Question 36
Consider the following recursive C function. If get(6) function is being called in main() then how many times will the get() function be invoked before returning to the main()?
`void` `get (``int` `n)`
`{`
`   ``if` `(n < 1) ``return``;`
`   ``get(n-1);`
`   ``get(n-3);`
`   ``printf``(``"%d"``, n);`
`}`
 A 15 B 25 C 35 D 45
Programming       Programming       GATE 2015(Set-03)
Question 36 Explanation:
 Question 37
Consider the following C program.
`# include `
`int` `main( )`
`{`
`  ``static` `int` `a[] = {10, 20, 30, 40, 50};`
`  ``static` `int` `*p[] = {a, a+3, a+4, a+1, a+2};`
`  ``int` `**ptr = p;`
`  ``ptr++;`
`  ``printf``(``"%d%d"``, ptr - p, **ptr};`
`}`
The output of the program is _________

 A 140 B 150 C 160 D 170
Programming       Programming       GATE 2015(Set-03)
Question 37 Explanation:

**ptr = 40
∴ printf (“%d%d”, p + r – p, p + r) will print 140.
 Question 38
Consider the following C program:
 `# include ` `int` `main( )` `{` `   ``int` `i, j, k = 0;` `   ``j = 2 * 3 / 4 + 2.0 / 5 + 8 / 5;` `   ``k  -= --j;` `   ``for` `(i = 0; i < 5; i++)` `   ``{` `      ``switch``(i + k)` `      ``{` `         ``case` `1:` `         ``case` `2: ``printf``(``"n%d"``, i + k);` `         ``case` `3: ``printf``(``"n%d"``, i + k);` `         ``default``: ``printf``(``"n%d"``, i + k);` `      ``}` `   ``}` `   ``return` `0;` `}`
 A 10 B 11 C 12 D 13
Programming       Programming       GATE 2015(Set-03)
Question 38 Explanation:
j = 2*3 / 4+2.0 / 5+8 / 5;
= 6 / 4+2.0 / 5+1;
= 1 + 0.4 + 1
= 2.4
But since j is integer,
j=2
Now,
k = k - (--j)
k = 0 - (1) = -1
When i=0, i+k = -1,
printf executed 1 time
When i=1, i+k = 0,
printf executed 1 time
When i=2, i+k = 1,
printf executed 3 times
When i=3, i+k = 2,
printf executed 3 times
When i=4, i+k = 3,
printf executed 2 times
∴ Total no. of times printf executed is,
1 + 1 + 3 + 3 + 2 = 10
 Question 39
Consider the following C program. The output of the program is __________.
 `# include ` `int` `f1(``void``);` `int` `f2(``void``);` `int` `f3(``void``);` `int` `x = 10;` `int` `main()` `{` `    ``int` `x = 1;` `    ``x += f1() + f2() + f3() + f2();` `    ``pirntf(``"%d"``, x);` `    ``return` `0;` `}` `int` `f1()` `{` `    ``int` `x = 25;` `    ``x++;` `    ``return` `x;` `}` `int` `f2( )` `{` `    ``static` `int` `x = 50;` `    ``x++;` `    ``return` `x;` `}` `int` `f3( )` `{` `    ``x *= 10;` `    ``return` `x;` `}`
 A 230 B 240 C 250 D 260
Programming       Programming       GATE 2015(Set-03)
Question 39 Explanation:
x = x + f1( ) + f2( ) + f3( ) + f4( )
f1( ) = 25 + 1 = 26
f2( ) = 50 + 1 = 51
f3( ) = 10 × 10 = 100
f2( ) = 51 × 1 = 52 (Since here x is static variable so old value retains)
∴ x = 1+26+51+100+52 = 230
 Question 40
Consider the following program in C language:
 `#include ` `main()` `{` `    ``int` `i;` `    ``int` `*pi = &i;` `    ``scanf``(``"%d"``, pi);` `    ``printf``(``"%dn"``, i+5);` `}`
Which one of the following statements is TRUE?
 A Compilation fails. B Execution results in a run-time error. C On execution, the value printed is 5 more than the address of variable i. D On execution, the value printed is 5 more than the integer value entered.
Programming       Programming       GATE 2014(Set-01)
Question 40 Explanation:
int i; // Initially i takes the Garbage value
int *pi = &i; // pi is a pointer which stores the address of i.
scanf (pi); // pi = &i (we rewrite the garbage value with our values) say x = 2
printf (i+5); // i+5 = x+5 = 2+5 = 7
Hence on execution, the value printed is 5 more than the integer value entered.
 Question 41
 A 9 B 10 C 11 D 12
Programming       Programming       Gate 2014 Set -02
Question 41 Explanation:
Shift right of 1, which means the number gets half.
Shift left of 1, which means the number gets doubled.
In program, shift right of 1 is given, means every time we enter the loop the number will get halved, and the value of count will get incremented by 1. And when the value of num will become zero then the while loop will get terminated. So,
num = 435/2 = 217/2 = 108/2 = 54/2 = 27/2= 13/2 = 6/2 = 3/2 = 1/2 = 0
Count = 9
So, the value count that will get returned is 9.
 Question 42
Suppose n and p are unsigned int variables in a C program. We wish to set p to nC3.  If n is large, which one of the following statements is most likely to set p  correctly?
 A p = n * (n-1) * (n-2) / 6; B p = n * (n-1) / 2 * (n-2) / 3; C p = n * (n-1) / 3 * (n-2) / 2; D p = n * (n-1) * (n-2) / 6.0;
Programming       Programming       Gate 2014 Set -02
Question 42 Explanation:
n & p are unsigned int variable.
From the options n*(n-1)*(n-2) will go out of range. So eliminate A & D.
n*(n-1) is always an even number. So subexpression n(n-1)/2 also an even number.
n*(n-1)/ 2*(n-2), gives a number which is a multiple of 3. So dividing with 3 will not have any loss. Hence B is option.
 Question 43
Consider the following function
 `double` `f(``double` `x){` `  ``if` `(``abs``(x*x - 3) < 0.01) ``return` `x;` `  ``else` `return` `f(x/2 + 1.5/x);` `}`
Give a value q (to 2 decimals) such that f(q) will return q:_____.
 A 1.73 B 1.74 C 1.75 D 1.76
Programming       Programming       Gate 2014 Set -02
Question 43 Explanation:
f(q) will return q, if
x2 - 3 < 0.01 will become True.
So, x2 - 3 < 0.01
x2 - 3 < 0.01
x2 < 3.01
x < 1.732
Hence, x = 1.73.
 Question 44
Consider the C function given below.
 `int` `f(``int` `j)` `{` `  ``static` `int` `i = 50;` `  ``int` `k;` `  ``if` `(i == j)` `  ``{` `    ``printf``(“something”);` `    ``k = f(i);` `    ``return` `0;` `  ``}` `  ``else` `return` `0;` `}`
Which one of the following is TRUE?
 A The function returns 0 for all values of j. B The function prints the string something for all values of j. C The function returns 0 when j = 50. D The function will exhaust the runtime stack or run into an infinite loop when j = 50.
Programming       Programming       Gate 2014 Set -02
Question 44 Explanation:
Let's say that value of j given inside the function is 50.
int f(int j)
{
static int i = 50;
int k;
if (i == j) // This will be True.
{
printf ("Something");
k = f(i); // Again called f(i) with value of i as 50. So, the function will run into infinite loop.
return 0;
}
else return 0;
}
 Question 45
Let A be a squ are matrix of size n ×n  . Consider t he following pseudocod e. What is t he expected output   C = 1 00; for i = 1 to n  do for j = 1 to  n do { Temp = A[ i][j] + C; A[i][j]= A[j][i]; A[j][i] =  Temp – C;
 for i = 1 to n do for j = 1 to n do
 output (A [i][j]);

 A The matrix A itself B Transpose of the matrix A C Adding 100 to the upper diagonal elements and subtracting 100 from lower diagonal elements of A D None of the above
Programming       Programming       Gate 2014 Set -03
Question 45 Explanation:
Let be a small matrix.
For first row iteration, it get swapped and becomes
For second row iteration, it comes to the original position
=A
So, it is the same matrix A.
 Question 46
The minimum number of arithmetic operations required to evaluate the polynomial P(X) = X+ 4X+ 6X + 5 for a given value of X, using only one temporary variable is ________.
 A 7 B 8 C 9 D 10
Programming       Arithmetic-Expressions       Gate 2014 Set -03
Question 46 Explanation:
The minimum number of arithmetic operations required to evaluate
P(X)=x5+4x3+6x+5
=x(x4+4x2+6)+5
=x(x(x3+4x)+6)+5
=x(x(x(x2+4))+6)+5
=x(x(x(x(x)+4))+6)+5
4 multiplications & 3 additions.
4 + 3 = 7
 Question 47
Consider the following function:
 `int` `unknown(``int` `n) {` `    ``int` `i, j, k = 0;` `    ``for` `(i  = n/2; i <= n; i++)` `        ``for` `(j = 2; j <= n; j = j * 2)` `            ``k = k + n/2;` `    ``return` `k;` ` ``}`
 A Θ(n2) B Θ(n2 log n) C Θ(n3) D Θ(n3 logn)
Programming       Programming       Gate 2013
Question 47 Explanation:
Outer loop runs for (n/2) times and inner loop runs for (logn) times.
So, the total number of times loop runs is (n/2 logn).
So, the final k value will be n/2*(n/2 logn) = O(n2logn)
= (n/2+1).n/2 ∙log n
= (n2log n)
 Question 48
Consider the following languages. Which one of the following statements is FALSE?
 A L2 is context-free. B L1∩ L2 is context-free. C Complement of L2 is recursive. D Complement of L1 is context-free but not regular.
Programming       CFL&PDA       Gate 2013
Question 48 Explanation:
L1 = 0*1*0* which is regular language and in L2 we have one comparison (i.e. p ≠ r) so it is CFL.
Intersection of a regular language with a context free language is context free language (by closure properties of regular language) So L1∩ L2 is context-free.
L2 is CFL and CFL is not closed under complementation so we have to assume L2 as CSL (since every CFL is CSL) and CSL is closed under complement so Complement of L2 must be CSL and every CSL is recursive so Complement of L2 is recursive.
Since L1 is regular and regular language is closed under complement so complement of L1 must be regular and hence the statement Complement of L1 is context-free but not regular is a false statement.
 Question 49

The procedure given below is required to find and replace certain characters inside an input character string supplied in array A. The characters to be replaced are supplied in array oldc, while their respective replacement characters are supplied in array newc. Array A has a fixed length of five characters, while arrays oldc and newc contain three characters each. However, the procedure is flawed

```void find_and_replace(char *A, char *oldc, char *newc) {
for (int i = 0; i < 5; i++)
for (int j = 0; j < 3; j++)
if (A[i] == oldc[j]) A[i] = newc[j];
}```

The procedure is tested with the following four test cases (1) oldc = "abc", newc = "dab" (2) oldc = "cde", newc = "bcd" (3) oldc = "bca", newc = "cda" (4) oldc = "abc", newc = "bac" The tester now tests the program on all input strings of length five consisting of characters ‘a’, ‘b’, ‘c’, ‘d’ and ‘e’ with duplicates allowed. If the tester carries out this testing with the four test cases given above, how many test cases will be able to capture the flaw?

 A None B 2 only C 3 and 4 only D 4 only
Programming       Programming       Gate 2013
Question 49 Explanation:
The test cases 3 & 4 captures the flaw. The code does not works fine when an old character is replaced by a new character & new character is again replaced by another new character.
1, 2 works fine, 3, 4 carries flaw.
 Question 50
What will be the output of the following C program segment?
 `char` `inchar = ``'A'``;` `switch` `(inchar)` `{` `case` `'A'` `:` `    ``printf` `(``"choice A n"``) ;` `case` `'B'` `:` `    ``printf` `(``"choice B "``) ;` `case` `'C'` `:` `case` `'D'` `:` `case` `'E'` `:` `default``:` `    ``printf` `(``"No Choice"``) ;` `}`
 A No Choice B Choice A C D Program gives no output as it is erroneous
Programming       C-Programming       Gate 2012
Question 50 Explanation:
Everything in the switch will be executed, because there is no break; statement after case ‘A’. So it executes all the subsequent statements until it find a break;
So,
→ Choice A
→ Choice B. No choice. Is the output.
 Question 51
 A B C D
Programming       C-Programming       Gate 2012
Question 51 Explanation:

Hence
4 2
6 2
2 0
 Question 52
Consider the following C program
 `int` `a, b, c = 0;` `void` `prtFun (``void``);` `int` `main ()` `{` `    ``static` `int` `a = 1; ``/* line 1 */` `    ``prtFun();` `    ``a += 1;` `    ``prtFun();` `    ``printf` `( ``"n %d %d "` `, a, b) ;` `}` ` ` `void` `prtFun (``void``)` `{` `    ``static` `int` `a = 2; ``/* line 2 */` `    ``int` `b = 1;` `    ``a += ++b;` `    ``printf` `(``" n %d %d "` `, a, b);` `}` What output will be generated by the given code segment?
 A B C D
Programming       C-Programming       Gate 2012
Question 52 Explanation:
Line 1 replaced by auto int a=1;
Line 2 replaced by register int a=2;
In main there will be no change if it is static or auto because of a+=1 the auto variable a is updated to 2 from 1.
In prtfun ( ), register makes a difference.
For first print statement a is updated to 4 & prints 4, 2.
But now it is not a static variable to retain the value of a to 4. So it becomes 2, when second function call takes place & prints 4, 2 again. There is no change in b, it acts like a local variable.
Hence,
4 2
4 2
2 0.
 Question 53
What does the following fragment of C-program print?
 `char` `c[] = ``"GATE2011"``;` `char` `*p =c;` `printf``(``"%s"``, p + p[3] - p[1]) ;`
 A GATE2011 B E2011 C 2011 D 011
Programming       C-Programming       Gate 2011
Question 53 Explanation:
p is the starting address of array.
p[3] - p[1] = 4, and p+4 will be pointing to the fifth position in the array 'c'. So printf starts printing from 2 and prints 2011.
 Question 54
Consider the following recursive C function that takes two arguments.
 A 9 B 8 C 5 D 2
Programming       C-Programming       Gate 2011
Question 54 Explanation:

∴ 1+0+0+0+0+0+0+0+0+1+0 = 2
 Question 55
Consider the following recursive C function that takes two arguments
 `unsigned ``int` `foo(unsigned ``int` `n, unsigned ``int` `r) {` `  ``if` `(n  > 0) ``return` `(n%r +  foo (n/r, r ));` `  ``else` `return` `0;` `}`
What is the return value of the function foo when it is called as foo(345, 10) ?

 A 345 B 12 C 5 D 3
Programming       C-Programming       Gate 2011
Question 55 Explanation:

∴ 5+4+3+0 = 12
 Question 56
What does the following program print?
 `#include` `void` `f(``int` `*p, ``int` `*q)` `{` `  ``p = q;` ` ``*p = 2;` `}` `int` `i = 0, j = 1;` `int` `main()` `{` `  ``f(&i, &j);` `  ``printf``(``"%d %d n"``, i, j);` `  ``getchar``();` `  ``return` `0;` `}`
 A 2 2 B 2 1 C 0 1 D 0 2
Programming       C-Programming       2010
Question 56 Explanation:

Both pointers points to j = 1
now *p = 2
where j is updated with value 2.
printf (i, j) i = 0, j = 2
 Question 57
What is the value printed by the foloowing c program
`#include<stdio.h>`
`int` `f(``int` `*a, ``int` `n)`
`{`
`  ``if``(n <= 0) ``return` `0;`
`  ``else` `if``(*a % 2 == 0) ``return` `*a + f(a+1, n-1);`
`  ``else` `return` `*a - f(a+1, n-1);`
`}`
` `
`int` `main()`
`{`
`  ``int` `a[] = {12, 7, 13, 4, 11, 6};`
`  ``printf``(``"%d"``, f(a, 6));`
`  ``getchar``();`
`  ``return` `0;`
`}`
 A -9 B 5 C 15 D 19
Programming       C-Programming       2010
Question 57 Explanation:
int a[ ] = {12, 7, 13, 4, 11, 6}
if (n <= 0)
return 0;
else if (*a % 2 = = 0)
return *a + f(a+1, n-1);
else
return *a – f(a+1, n-1);

⇒12+(7-(13-(4+(11-(6)))))
⇒12+(7-(13-(4+5)))
⇒12+7-(4)
⇒12+3
⇒15
 Question 58
Consider the program below: # include < stdio .h > int fun(int n, int * f_p) { int t, f; if (n <= 1) { * f_p = 1; return 1; } t = fun (n- 1, f_p); f = t+ * f_p; * f_p = t; return f; } int main() { int x = 15; printf (" % d\ n", fun(5, & x)); return 0; } The value printed is
 A 6 B 8 C 14 D 15
Programming       C-Programming       2009
Question 58 Explanation:
int x=15;
printf(fun(5,&x));
The code is implemented using Tail Recursion.
fun(5,15)

fun(4,15)

fun(3,15)

fun(2,15)

fun(1,15)
→ First we will trace fun(1,15) which returns 1.
→ Then trace fun(2,15) using fun(1,15) value, it returns 2.
→ Then fun(3,15), it returns 3≃(1+2)
→ Then fun(4,15), it returns 5=(2+3)
→ Then fun(5,15), it returns 8=(3+5)
If you call fun(6,15) then it will return 13=(5+8)
Here fun(n,*x)≃fun(n-1,&x)+fun(n-2,&x), where fun(n-1,&x) is storing in variable ‘t’ & fun(n-2,&x) is storing in variable x(*f-p).
∴ The program is nth Fibonacci number.
 Question 59
Which combination of the integer variables x, y and z makes the variable a get the value 4 in the following expression? a = (x > y)? ((x > z)? x : z): ((y > z)? y : z)
 A x = 3, y = 4, z = 2 B x = 6, y = 5, z = 3 C x = 6, y = 3, z = 5 D x = 5, y = 4, z = 5
Programming       C-Programming       Gate-2008
Question 59 Explanation:
Required final output value of a=4.
→ We can directly eliminate the options B & C, because none of the variable can assign a value 4.
→ Given explanation is
a=(x>y)?((x>z)?x:z):((y>z)?y:z)
Option A:
x=3; y=4; z=2
a=(3>4)?⇒No
Then evaluate second expression⇒(4>2)?Yes
⇒a=y
a=4 (True)
Option D:
x=5; y=4; z=5
a=(5>4)⇒Yes
Then evaluate first expression ⇒ (5>5)? No
⇒ a=z ⇒ a=5 (Not true)
⇒Answer is Option A.
 Question 60
What is printed by the following C program? int f (int x, int * py, int * *ppz) void main ( )   {                                                               { int y,    z;                                                          int   c,   * b,      * *a; * *ppz  +  = 1;  z = *ppz;                                   c = 4;     b = &c;  a = &b; * py  + = 2;   y = *py;                                       pr int f (" %d", f (c, b, a)); x  + = 3;                                                         } return x + y + z; }
 A 18 B 19 C 21 D 22
Programming       C-Programming       Gate-2008
Question 60 Explanation:
f(c,b,a)
f(c,&c,&(&c))=f(4,4,4)
c is 4, b is a pointer pointing address of a, a is a pointer to pointer of c. Hence both b and c are pointing to same memory address i.e., a.
Hence whatever increment operation happens in f, it happens/ reflects on same value i.e., a.
**ppz+=1;
z=**ppz; //z=5
These steps update it to 5 and stored in z.
*py+=2; //changes c to 7, x is unchanged.
y=*py; //y=7
It updates to 7 and stored in y.
x+=3 //x is incremented by 3.
returns x+y+z=7+7+5=19
 Question 61
Choose the correct option to fill ? 1 and ? 2 so that the program below prints an input string in reverse order. Assume that the input string is terminated by a newline void recerse (void){ int c; if (?1)reverse ( ); ? 2 } main ( ) { pr int f ("Enter Text "); pr int f ("\ n "); reverse ( );pr int f ("\ n "); }
 A ?1 is (getchar( ) != ’\n’) ?2 is getchar(c); B ?1 is (c = getchar( ) ) != ’\n’) ?2 is getchar(c); C ?1 is (c != ’\n’) ?2 is putchar(c); D ?1 is ((c = getchar()) != ’\n’) ?2 is putchar(c);
Programming       C-Programming       Gate-2008
Question 61 Explanation:
void reverse(void)
{
int c;
if(?1) reverse( );
?2
}
main( )
{
printf(“Enter Text”);
printf(“\n”);
reverse( );
printf(“\n”);
}
We can simply eliminate A & B for ?2.
& Hence
?1 is ((c=getchar( )) != ‘\n’)
?2 is putchar(c);
 Question 62
 A 1661 and 1640 B 59 and 59 C 1640 and 1640 D 1640 and 1661
Programming       C-Programming       Gate-2008
Question 62 Explanation:
Both functions perform same operation, so output is same, means either (B) or (C) is correct.
f1(2) = 2*f1(1) + 3*f1(0) = 2
f1(3) = 2*f1(2) + 3*f1(1) = 2*2 + 3*1 = 7
f1(4) = 2*f1(3) + 3*f1(2) = 2*7 + 3*2 = 20
f1(5) = 2*f1(4) + 3*f1(3) = 2*20 + 3*7 = 40 + 21 = 61
We can skip after this as the only remaining choice is (C).
f1(6) = 2*f1(5) + 3*f1(4) = 2*61 + 3*20 = 122 + 60 = 182
f1(7) = 2*f1(6) + 3*f1(5) = 2*182 + 3*61 = 364 + 183 = 547
f1(8) = 2*f1(7) + 3*f1(6) = 2*547 + 3*182 = 1094 + 546 = 1640
 Question 63
Match the programming paradigms and languages given in the following table.
 A I-c, II-d, III-b, IV-a B I-a, II-d, III-c, IV-b C I-d, II-c, III-b, IV-a D I-c, II-d, III-a, IV-b
Programming       Match-the-Following       Gate 2008-IT
Question 63 Explanation:
Note: Out of syllabus.
 Question 64
What is the output printed by the following C code?
 `# include ` `int` `main ()` `{` `    ``char` `a [6] = ``"world"``;` `    ``int` `i, j;` `    ``for` `(i = 0, j = 5; i < j; a [i++] = a [j--]);` `    ``printf` `(``"%sn"``, a);` `}` ` ``/* Add code here. Remove these lines if not writing code */`
 A dlrow B Null String C dlrld D worow
Programming       C-Programming       Gate 2008-IT
Question 64 Explanation:
As the base address or starting of the string "Null" is placed. So while reading array if Null comes it assumes that this is the end of array. So, it terminates here only.
 Question 65
Consider the C program below. What does it print?
 `# include ` `# define swapl (a, b) tmp = a; a = b; b = tmp` `void` `swap2 ( ``int` `a, ``int` `b)` `{` `        ``int` `tmp;` `        ``tmp = a; a = b; b = tmp;` ` ``}` `void` `swap3 (``int``*a, ``int``*b)` `{` `        ``int` `tmp;` `        ``tmp = *a; *a = *b; *b = tmp;` `}` `int` `main ()` `{` `        ``int` `num1 = 5, num2 = 4, tmp;` `        ``if` `(num1 < num2) {swap1 (num1, num2);}` `        ``if` `(num1 < num2) {swap2 (num1 + 1, num2);}` `        ``if` `(num1 >= num2) {swap3 (&num1, &num2);}` `        ``printf` `(``"%d, %d"``, num1, num2);` `}` ` ``/* Add code here. Remove these lines if not writing code */`
 A 5, 5 B 5, 4 C 4, 5 D 4, 4
Programming       C-Programming       Gate 2008-IT
Question 65 Explanation:
"If (num1 ≥ num2)
{Swap3 (&num1, &num2) ; }"
Statement is true, so call by reference will be performed and the value of num1 and num2 will get exchanged.
 Question 66
Consider the C program given below. What does it print?
 `#include ` `int` `main ()` `{` `        ``int` `i, j;` `        ``int` `a [8] = {1, 2, 3, 4, 5, 6, 7, 8};` `        ``for``(i = 0; i < 3; i++) {` `             ``a[i] = a[i] + 1;` `             ``i++;` `        ``}` `        ``i--;` `        ``for` `(j = 7; j > 4; j--) {` `              ``int` `i = j/2;` `              ``a[i] = a[i] - 1;` `        ``}` `        ``printf` `(``"%d, %d"``, i, a[i]);` `}` ` ``/* Add code here. Remove these lines if not writing code */`
 A 2, 3 B 2, 4 C 3, 2 D 3, 3
Programming       C-Programming       Gate 2008-IT
Question 66 Explanation:
Note that there are two variables named 'i', with different scope.
First for loop will run for i = 0, 2 and 4 as i is incremented twice and resultant array will be 'a' = 2, 2, 4, 4, 5, 6, 7, 8. Loop will terminate at i = 4.
After that value of 'i' will become '3' as there is a decrement operation after for loop.
Next for loop is running for j = 7, 6, 5 and corresponding 'i' values which is a local variable inside for loop will be
3(7/2), 3(6/2), 2(5/2)
Array after this for loop will be
a = 2, 2, 3, 2, 5, 6, 2, 8.
After the loop, current 'i' value is 3 and elements at a[3] = 2.
 Question 67
C program is given below:
 `# include ` `int` `main ()` `{` `        ``int` `i, j;` `        ``char` `a [2] [3] = {{``'a'``, ``'b'``, ``'c'``}, {``'d'``, ``'e'``, ``'f'``}};` `        ``char` `b [3] [2];` `        ``char` `*p = *b;` `        ``for` `(i = 0; i < 2; i++) {` `              ``for` `(j = 0; j < 3; j++) {` `              ``*(p + 2*j + i) = a [i] [j];` `              ``}` `        ``}` `}` ` ``/* Add code here. Remove these lines if not writing code */`
What should be the contents of the array b at the end of the program?
 A B C D
Programming       C-Programming       Gate 2008-IT
Question 67 Explanation:
*p = a[0][0] = a
*(p+2) = a[0][1] = b
*(p+4) = a[0][2] = c
*(p+1) = a[1][0] = d
*(p+3) = a[1][1] = e
*(p+5) = a[1][2] = f
 Question 68
Consider the code fragment written in C below :
 `void` `f (``int` `n)` `{ ` `  ``if` `(n <=1)  {` `   ``printf` `(``"%d"``, n);` `  ``}` `  ``else` `{` `   ``f (n/2);` `   ``printf` `(``"%d"``, n%2);` `  ``}` `}`
What does f(173) print?
 A 010110101 B 010101101 C 10110101 D 10101101
Programming       C-Programming       Gate 2008-IT
Question 68 Explanation:

So, after traversing the tree we get:
10101101
 Question 69
Consider the code fragment written in C below :
 `void` `f (``int` `n)` `{` `    ``if` `(n <= 1)  {` `        ``printf` `(``"%d"``, n);` `    ``}` `    ``else` `{` `        ``f (n/2);` `        ``printf` `(``"%d"``, n%2);` `    ``}` `}`
Which of the following implementations will produce the same output for f(173) as the above code? P1
 `void` `f (``int` `n)` `{` `    ``if` `(n/2)  {` `        ``f(n/2);` `    ``}` `    ``printf` `(``"%d"``, n%2);` `}`
P2
 `void` `f (``int` `n)` `{` `    ``if` `(n <=1)  {` `        ``printf` `(``"%d"``, n);` `    ``}` `    ``else` `{` `        ``printf` `(``"%d"``, n%2);` `        ``f (n/2);` `    ``}` `}`
 A Both P1 and P2 B P2 only C P1 only D Neither P1 nor P2
Programming       C-Programming       Gate 2008-IT
Question 69 Explanation:
P1 prints same as the original program.
But P2 prints the reverse of original sequence printed by original program.
 Question 70
Consider the following C function, what is the output?
 `#include ` `int` `f(``int` `n)` `{` `    ``static` `int` `r = 0;` `    ``if` `(n <= 0) ``return` `1;` `    ``if` `(n > 3)` `    ``{` `        ``r = n;` `        ``return` `f(n-2)+2;` `    ``}` `    ``return` `f(n-1)+r;` `}` `int` `main()` `{` `    ``printf``(``"%d"``, f(5));` `}`
 A 5 B 7 C 9 D 18
Programming       C-Programming       Gate-2007
Question 70 Explanation:
We need to evaluate f(5)
f(5) = f(3) + 2
f(3) = f(2) + 5 (where r is static and value of r=5)
f(2) = f(1) + 5
f(1) = f(0) + 5
f(0) = 1
⟹ f(5) = 1+5+5+5+2 = 18
 Question 71
The function f is defined as follows:
```int f (int n) {
if (n <= 1) return 1;
else if (n % 2  ==  0) return f(n/2);
else return f(3n - 1);
}
```
Assuming that arbitrarily large integers can be passed as a parameter to the function, consider the following statements. 1. The function f terminates for finitely many different values of n ≥ 1. ii. The function f terminates for infinitely many different values of n ≥ 1. iii. The function f does not terminate for finitely many different values of n ≥ 1. iv. The function f does not terminate for infinitely many different values of n ≥ 1. Which one of the following options is true of the above?
 A (i) and (iii) B (i) and (iv) C (ii) and (iii) D (ii) and (iv)
Programming       Programming       Gate 2007-IT
Question 71 Explanation:
The function can be terminated for all the values which can have factor of 2{(2-x)2 == 0}, so (i) is false and (ii) is true.
→ Let n=3, then it is terminated in 2nd iteration.
→ Let n=5, then sequence is 5→14→7→20→10 and it will repeat.
→ Any number with factor 5 and 2 leads to infinite recursion.
So, (iv) is True and (iii) is False.
 Question 72

```#include <stdio.h>
int main ()    {
int sum = 0, maxsum = 0,  i,  n = 6;
int a [] = {2, -2, -1, 3, 4, 2};
for (i = 0; i < n; i++)    {
if (i == 0 || a [i]  < 0  || a [i] < a [i - 1])  {
if (sum > maxsum) maxsum = sum;
sum = (a [i] > 0) ? a [i] : 0;
}
else sum += a [i];
}
if (sum > maxsum) maxsum = sum ;
printf ("%dn", maxsum);

}```

 A 9 B 8 C 7 D 6
Programming       C-Programming       Gate 2007-IT
Question 72 Explanation:
The algorithm is for finding the maximum sum of the monotonically increasing continuous sequence of positive numbers in the array. So, output will be 3+4 = 7.
 Question 73
Consider the program below in a hypothetical language which allows global variable and a choice of call by reference or call by value methods of parameter passing.
``` int i ;
program main ()
{
int j = 60;
i = 50;
call f (i, j);
print i, j;
}
procedure f (x, y)
{
i = 100;
x = 10;
y = y + i ;
}
```
Which one of the following options represents the correct output of the program for the two parameter passing mechanisms?
 A Call by value : i = 70, j = 10; Call by reference : i = 60, j = 70 B Call by value : i = 50, j = 60; Call by reference : i = 50, j = 70 C Call by value : i = 10, j = 70; Call by reference : i = 100, j = 60 D Call by value : i = 100, j = 60; Call by reference : i = 10, j = 70
Programming       Parameter-Passing       Gate 2007-IT
Question 73 Explanation:
Call by value:
'i' is a global variable. Then in main( ) a local variable 'j' as integer declared, i.e., j=60 and global varible 'i' is initialized to 50 by i=50.
Now procedure f called and values of 'i' and 'j' are passed to it, i.e., in f(i, j)→f(x, y).
Content of memory location of 'i' (here 50) is copied to memory location of x (which is different from i) and content of memory location of 'j' (here 60) is copied to memory location of y. Then in f(x, y) i=100 changes the global i to 100, x=10 changes the local x from 50 to 10 and y=y+i means y=60+100=160. Now, when return back to main, i & j will be 100 & 60 respectively.
Call by reference:
Now procedure f called and passed reference of i and j to it, i.e., in f(i,j)→f(x,y). x and y are pointing to same memory location of i and j respectively. So i=100 changes the global i to 100 and x=10 means as well as global i=10 (as the i being passed is the global variable and x and i share the same address).
y=y+i means y=60+10=70 and this changes the value of j also to as j and y have the same addresses. Now when return to main, i and j will be 10 and 70.
 Question 74
Consider the program below in a hypothetical programming language which allows global variables and a choice of static or dynamic scoping.
``` int i ;
program main ()
{
i = 10;
call f();
}

procedure f()
{
int i = 20;
call g ();
}
procedure g ()
{
print i;
}
```
Let x be the value printed under static scoping and y be the value printed under dynamic scoping. Then, x and y are
 A x = 10, y = 10 B x = 20, y = 10 C x = 10, y = 20 D x = 20, y = 20
Programming       Variable Binding       Gate 2007-IT
Question 74 Explanation:
Since the value of x is based on static scoping, in the procedure g( ), print i will directly look into the global scope and find i=10 which was previously set by main( ) and since the value of y is based on dynamic scope, procedure g( ) will first look into the function whicg called it, i.e., procedure f( ) which has a local i=20, which will be taken and 20 will be printed.
 Question 75
Early binding refers to a binding performed at compile time and late binding refers to a binding performed at execution time. Consider the following statements: i. Static scope facilitates w1 bindings. ii. Dynamic scope requires w2 bindings. iii. Early bindings w3 execution efficiency. iv. Late bindings w4 execution efficiency. The right choices of wl, w2, w3 and w4 (in that order) are
 A Early, late, decrease, increase B Late, early, increase, decrease C Late, early, decrease, increase D Early, late, increase, decrease
Programming       Variable Binding       Gate 2007-IT
Question 75 Explanation:
Static scoping can do early binding (during compile time). Early binding increases efficiency.
Dynamic scoping requires late binding (during execution time).
Late binding decreases efficiency as this binding needs to be done at run time.
 Question 76
Consider this C code to swap two integers and these five statements after it:
 `void` `swap(``int` `*px, ``int` `*py) ` `{ ` `   ``*px = *px - *py; ` `   ``*py = *px + *py; ` `   ``*px = *py - *px; ` `}`
S1: will generate a compilation error S2: may generate a segmentation fault at runtime depending on the arguments passed S3: correctly implements the swap procedure for all input pointers referring to integers stored in memory locations accessible to the process S4: implements the swap procedure correctly for some but not all valid input pointers S5: may add or subtract integers and pointers.

 A S1 B S2 and S3 C S2 and S4 D S2 and S5
Programming       C-Programming       Gate-2006
Question 76 Explanation:
S2:
We may get the segmentation fault if the pointer values are constant (i.e., px or py) (or) (px or py) are points to a memory location is invalid.
S4:
Swap procedure can be implemented correctly but not for all input pointers because arithmetic overflow may occur based on input values.
 Question 77
Consider the following code written in a pass-by-reference language like FORTRAN and these statements about the code.
```subroutine swap(ix,iy)
it = ix
L1 : ix = iy
L2 : iy = it
end
ia = 3
ib = 8
call swap (ia, 1b+5)
print *, ia, ib
end```
S1: The compiler will generate code to allocate a temporary nameless cell, initialize it to 13, and pass the address of the cell swap S2: On execution the code will generate a runtime error on line L1 S3: On execution the code will generate a runtime error on line L2 S4: The program will print 13 and 8 S5: The program will print 13 and -2 Exactly the following set of statement(s) is correct:
 A S1 and S2 B S1 and S4 C S3 D S1 and S5
Programming       FORTRAN       Gate-2006
Question 77 Explanation:
Swap operation perform between the ia and temporary nameless cell, therefore the value of ib is remains unchanged.
Swap (8, 13)
⇒ ia will returns value with 13.
⇒ ib is unchanged, because here we using pass by reference value.
➝ Temporary nameless is initialized to 13.
➝ There is No runtime error.
 Question 78
Which one of the choices given below would be printed when the following program is executed ?
``` #include <stdio.h>
struct test {
int i;
char *c;
}st[] = {5, "become", 4, "better", 6, "jungle", 8, "ancestor", 7, "brother"};
main ()
{
struct test *p = st;
p += 1;
++p -> c;
printf("%s,", p++ -> c);
printf("%c,", *++p -> c);
printf("%d,", p[0].i);
printf("%s n", p -> c);
}```

 A jungle, n, 8, ncestor B etter, u, 6, ungle C cetter, k, 6, jungle D etter, u, 8, ncestor
Programming       Programming       Gate 2006-IT
Question 78 Explanation:
Lets take the part of program,
Line 1 - main ( )
Line 2 - {
Line 3 - struct test *p = st;
Line 4 - p += 1;
Line 5 - ++p → c;
Line 6 - printf("%s", p++→ c);
Line 7 - printf("%c", +++p → c);
Line 8 - printf("%d", p[0].i);
Line 9 - printf("%s\n", p → c);
Line 10 - }
Now,
Line 3: Initially p is pointing to st, i.e., first element of st which is {5, "become"}
Line 4: Now p is pointing to {4, "better"}
Line 5: ++(p → c), since → has higher precedence, so p → c points to 'e' of "better".
Line 6: prints 'enter' and p now points to {6, "jungle"}
Line 7: ***(p → c), since → has higher precedence. So, prints 'u'.
Line 8: p → i, which is 6 so prints '6'.
Line 9: prints 'ungle' since p is pointing to 'u'.
So, output is "enter, u, 6, ungle".
 Question 79
Which one of the choices given below would be printed when the following program is executed?
```#include
void swap (int *x, int *y)
{
static int *temp;
temp = x;
x = y;
y = temp;
}
void printab ()
{
static int i, a = -3, b = -6;
i = 0;
while (i <= 4)
{
if ((i++)%2 == 1) continue;
a = a + i;
b = b + i;
}
swap (&a, &b);
printf("a =  %d, b = %dn", a, b);
}
main()
{
printab();
printab();
}```

 A a = 0, b = 3 a = 0, b = 3 B a = 3, b = 0 a = 12, b = 9 C a = 3, b = 6 a = 3, b = 6 D a = 6, b = 3 a = 15, b = 12
Programming       Programming       Gate 2006-IT
Question 79 Explanation:
First of all, the swap function just swaps the pointers inside the function and has no effect on the variable being passed.
Inside print 'a' and 'b' are added to odd integers from 1 to 5, i.e., 1+3+5=9. So, in first call to print ab,
a = -3+9 = 6
b = -6+9 = 3
Static variable have one memory throughout the program run (initialized during program start) and they keep their values across function calls. So during second call to print ab,
a = 6+9 = 15
b = 3+9 = 12
 Question 80
Which one of the choices given below would be printed when the following program is executed?
``` #include
int a1[] = {6, 7, 8, 18, 34, 67};
int a2[] = {23, 56, 28, 29};
int a3[] = {-12, 27, -31};
int *x[] = {a1, a2, a3};
void print(int *a[])
{
printf("%d,", a[0][2]);
printf("%d,", *a[2]);
printf("%d,", *++a[0]);
printf("%d,", *(++a)[0]);
printf("%dn", a[-1][+1]);
}
main()
{
print(x);
}```

 A 8, -12, 7, 23, 8 B 8, 8, 7, 23, 7 C -12, -12, 27, -31, 23 D -12, -12, 27, -31, 56
Programming       Programming       Gate 2006-IT
Question 80 Explanation:
1) a[0][2] = *(*(a+0)+2)
It returns the value of 3rd element in a1.
First printf print 8.
2) *a[2] = *(*(a+2))
It returns the value of 1st element in a3.
Second printf print -12.
3) *++a[0] = *(++(*(a+0)))
a[0] is pointing to 1st element in a1.
++a[0] - after preincrement performed, now a[0] is pointing to 2nd element in a1.
*++a[0] return the value of 2nd element in a1.
Third printf print 7.
4) *(++a)[0]
++a - after preincrement is performed 'a' is pointing to a2.
(++a)[0] is pointing to 1st element in a2.
*(++a)[0] returns the value of 1st element in a2.
Fourth printf print 23.
5) a[-1][+1] = *(*(a-1)+1)
(a-1) is pointing to a1.
*(a-1) is pointing to the 2nd element in a1, because in 3rd printf already a1 was incremented by 1.
*(a-1)+1 is pointing 3rd element in a1.
*(*(a-1)+1) returns the value of 3rd element in a1, i.e., 8.
 Question 81
The following function computes the value of mCn correctly for all legal values m and n (m≥1,n≥0 and m>n)
``` int func(int m, int n)
{
if (E) return 1;
else return(func(m -1, n) + func(m - 1, n - 1));
}
```
In the above function, which of the following is the correct expression for E?
 A (n == 0) || (m == 1) B (n == 0) && (m == 1) C (n == 0) || (m == n) D (n == 0) && (m == n)
Programming       Programming       Gate 2006-IT
Question 81 Explanation:
We know that,
mC0 = 1
nCn = 1
 Question 82
Match the following concepts and their best possible descriptions. Concepts (i)overloading (ii)friend (iii)constructor (iv)protected (v)this (vi)inheritance Descriptions A. allows to define a class to have a properties of another class B. defining a set of similar functions C.used in dereferncing D.Used to given a non - member function access to the private parts of body E. a function which is automically called when object is created F.allows a derived class to have access to the private parts of the base G. a pointer to the object associated with the current functions H. used to obtain persistence
 A (i) - B, (ii) - D, (iii) - E, (iv) - F, (v) - G, (vi) - A B (i) - C, (ii) - A, (iii) - E, (iv) - D, (v) - H, (vi) - F C (i) - C, (ii) - F, (iii) - H, (iv) - A, (v) - G, (vi) - D D (i) - B, (ii) - E, (iii) - C, (iv) - F, (v) - G, (vi) - H
Programming       Match-the-Following       Gate 2006-IT
Question 82 Explanation:
Note: Out of syllabus.
 Question 83
What does the following C-statement declare? `int` `( * f) (``int` `* ) ;`
 A A function that takes an integer pointer as argument and returns an integer. B A function that takes an integer as argument and returns an integer pointer. C A pointer to a function that takes an integer pointer as argument and returns an integer. D A function that takes an integer pointer as argument and returns a function pointer.
Programming       C-Programming       Gate-2005
Question 83 Explanation:
int ( * f) (int * )
→ A pointer to a function which takes integer as a pointer and return an integer value.
 Question 84
A common property of logic programming languages and functional languages is:
 A both are procedural languages B both are based on λ-calculus C both are declarative D both use Horn-clauses
Question 84 Explanation:
Functional and logic programming languages are also called declarative languages; programs in these languages are said to describe (declaratively) what to do and not (operationally) how to do it.
 Question 85
Which one of the following are essential features of an object-oriented programming language? (GATE CS 2005) (i) Abstraction and encapsulation (ii) Strictly-typedness (iii) Type-safe property coupled with sub-type rule (iv) Polymorphism in the presence of inheritance Answer (b) Abstraction, Encapsulation, Polymorphism and Inheritance are the essential features of a OOP Language (See the Wiki page for OOP).
 A (i) and (ii) only B (i) and (iv) only C (i), (ii) and (iv) only D (i), (iii) and (iv) only
Question 85 Explanation:
Abstraction, encapsulation and inheritance are three main features of OOP language.
 Question 86
Consider the following C-program:
 `double` `foo (``double``); ``/* Line 1 */` `int` `main()` `{` `    ``double` `da, db;` `    ``// input da` `    ``db = foo(da);` `}` `double` `foo(``double` `a)` `{` `    ``return` `a;` `}`
The above code compiled without any error or warning. If Line 1 is deleted, the above code will show:
 A no compile warning or error B some compiler-warnings not leading to unintended results C some compiler-warnings due to type-mismatch eventually leading to unintended results D compiler errors
Programming       C-Programming       Gate-2005
Question 86 Explanation:
When a function is called before its declaration then it leads to compiler error.
 Question 87
Consider the following C-program:
 `double` `foo (``double``); ``/* Line 1 */` `int` `main()` `{` `    ``double` `da, db;` `    ``// input da` `    ``db = foo(da);` `}` `double` `foo(``double` `a)` `{` `    ``return` `a;` `}`
The above code compiled without any error or warning. If Line 1 is deleted, the above code will show:
 A 8, 4, 0, 2, 14 B 8, 4, 0, 2, 0 C 2, 0, 4, 8, 14 D 2, 0, 4, 8, 0
Programming       C-Programming       Gate-2005
Question 87 Explanation:
Int a=2048, Sum=0
⇒ foo (a, sum) = foo (2048,0)
⇒ n == 2048
⇒ k = n%10 = 2048%10 = 8
⇒ j = n/10 = 2048/10 = 204
Sum = Sum+k = 0+8 = 8
foo(j, sum) = foo(204, 8)
⇒ n=204
k = n%10 = 204%10 = 4
j = n/10 = 204/10 = 20
sum = sum+k = 12+0 = 12
foo(j, sum) =foo(2,12)
⇒ n=2
k = n%10 = 2%10 = 2
j = n/10 = 2/10 = 0
sum = 14
foo(0,14) ⇒ n==0
printf("%d", k) ⇒ k = 2, 0, 4, 8
After foo( ) statement one more printf statement is there then if print 0 after all digits of n.
2, 0, 4, 8, 0.
 Question 88
The following C function takes two ASCII strings and determines whether one is an anagram of the other. An anagram of a string s is a string obtained by permuting the letters in s.
```int anagram (char *a, char *b) {
int count [128], j;
for (j = 0;  j < 128; j++) count[j] = 0;
j = 0;
while (a[j] && b[j]) {
A;
B;
}
for (j = 0; j < 128; j++) if (count [j]) return 0;
return 1;
}
```
Choose the correct alternative for statements A and B.
 A A : count [a[j]]++ and B : count[b[j]]– B A : count [a[j]]++ and B : count[b[j]]++ C A : count [a[j++]]++ and B : count[b[j]]– D A : count [a[j]]++and B : count[b[j++]]–
Programming       Programming       Gate 2005-IT
Question 88 Explanation:
A: Increments the count by 1 at each index that is equal to the ASCII value of the alphabet, it is pointing at.
B: Decrements the count by 1 at each index that is equal to the ASCII value of the alphabet it is pointing at. Also it increments the loop counter for next iteration.
If one string is permutation of other, there would have been equal increments and decrements at each index of array, and so count should contain zero at each index, that is what the loop checks at last and if any non-zero elements is found, it returns 0 indicating that strings are not anagram to each other.
 Question 89
The following C function takes a singly-linked list of integers as a parameter and rearranges the elements of the list. The list is represented as pointer to a structure. The function is called with the list containing the integers 1, 2, 3, 4, 5, 6, 7 in the given order. What will be the contents of the list after the function completes execution?
 `struct` `node {` `    ``int` `value; ` `    ``struct` `node *next;` `);` `void` `rearrange (``struct` `node *list) ` `{` `    ``struct` `node *p, *q;` `    ``int` `temp;` `    ``if` `(!list || !list -> next) ` `        ``return``;` `    ``p = list; ` `    ``q = list -> next;` `    ``while` `(q) ` `    ``{` `        ``temp = p -> value;` `        ``p -> value = q -> value;` `        ``q -> value = temp;` `        ``p = q -> next;` `        ``q = p ? p -> next : 0;` `    ``}` `}`
 A 1, 2, 3, 4, 5, 6, 7 B 2, 1, 4, 3, 6, 5, 7 C 1, 3, 2, 5, 4, 7, 6 D 2, 3, 4, 5, 6, 7, 1
Programming       Programming       Gate 2005-IT
Question 89 Explanation:
It is nothing but a pairwise swapping of the linked list.
 Question 90
Let a be an array containing n integers in increasing order. The following algorithm determines whether there are two distinct numbers in the array whose difference is a specified number S > 0.
 `i = 0;` `j = 1;` `while` `(j < n )` `{` `    ``if` `(E) j++;` `    ``else` `if` `(a[j] - a[i] == S) ``break``;` `    ``else` `i++;` `}` `if` `(j < n)` `    ``printf``(``"yes"``)` `else` `   ``printf` `(``"no"``);`

Choose the correct expression for E.

 A a[j] – a[i] > S B a[j] – a[i] < S C a[i] – a[j] < S D a[i] – a[j] > S
Programming       Programming       Gate 2005-IT
Question 90 Explanation:
For some 'i' if we find that difference of (A[j] - A[i] < S) we increment 'j' to make this difference wider so that it becomes equal to S.
If at times difference becomes greater than S we know that it won't reduce further for same 'i' and so we increment the 'i'.
 Question 91
Let a and b be two sorted arrays containing n integers each, in non-decreasing order. Let c be a sorted array containing 2n integers obtained by merging the two arrays a and b. Assuming the arrays are indexed starting from 0, consider the following four statements
1. a[i] ≥ b [i] => c[2i] ≥ a [i]
2. a[i] ≥ b [i] => c[2i] ≥ b [i]
3. a[i] ≥ b [i] => c[2i] ≤ a [i]
4. a[i] ≥ b [i] => c[2i] ≤ b [i]
Which of the following is TRUE?
 A only I and II B only I and IV C only II and III D only III and IV
Programming       Sorting       Gate 2005-IT
Question 91 Explanation:
a[i] ≥ b[i]
Since both 'a' and 'b' are sorted in the beginning, there are 'i' elements than or equal to a[i] and similarly 'i' elements smaller than or equal to b[i]. So, a[i] ≥ b[i] means there are 2i elements smaller than or equal to a[i] and hence in the merged array, a[i] will come after these 2i elements. So, c[2i] ≤ a[i].
Similarly, a[i] ≥ b[i] says for b that, there are not more than 2i elements smaller than b[i] in the sorted array. So, b[i] ≤ c[2i].
So, option (C) is correct.
 Question 92
What is the output printed by the following program?
 `#include` `int` `f(``int` `n, ``int` `k)` `{` `    ``if` `(n == 0)` `        ``return` `0;` `    ``else` `if` `(n % 2)` `        ``return` `f(n/2, 2*k) + k;` `    ``else` `return` `f(n/2, 2*k) - k;` `}` `int` `main ()` `{` `    ``printf``(``"%d"``, f(20, 1));` `    ``return` `0;` `}`
 A 5 B 8 C 9 D 20
Programming       Programming       Gate 2005-IT
Question 92 Explanation:

Hence, 9 is the answer.
 Question 93

 A call swap (x, y) B call swap (&x, &y) C swap (x,y) cannot be used as it does not return any value D swap (x,y) cannot be used as the parameters are passed by value
Programming       C-Programming       Gate-2004
Question 93 Explanation:
Option A:
Here parameters passed by value in C then there is no change in the values.
Option B:
Here values are not swap.
Here parameters are passed by address in C.
Option C:
It is false. Return value is not valid for exchanging the variables.
Option D:
It is correct.
We cannot use swap(x,y) because parameters are passed by value.
Only exchanging the values (or) variables are passing their address and then modify the content with the help of dereferencing operator(*).
 Question 94
The goal of structured programming is to
 A have well indented programs B be able to infer the flow of control from the compiled code C be able to infer the flow of control from the program text D avoid the use of GOTO statements
Question 94 Explanation:
Structured programming: Which is aimed at improving the clarity, quality and development time of a computer programming by making extensive use of the structured control flow constructs of selection and repetition of block structures and subroutines in contrast to using simple tests and jumps such as goto statements.
 Question 95

 A 5 B 6 C 7 D 8
Programming       C-Programming       Gate-2004
Question 95 Explanation:

The value return by f(1) = 7
 Question 96

 A n = d1d2…dm-i and rev = dmdm-1…dm-i+1 B n = dm-i+1…dm-1dm or rev = dm-i…d2d1 C n ≠ rev D n = d1d2…dm and rev = dm…d2d1
Programming       Loop-Invariants       Gate-2004
Question 96 Explanation:
In each iteration the right most digit of n is going to make to the right end of the reverse.
 Question 97

 A gnirts B string C gnirt D no output is printed
Programming       C-Programming       Gate-2004
Question 97 Explanation:
Let us consider below line inside the for loop p[i] = s[length — i]; For i = 0, p[i] will be s[6 — 0] and s[6] is ‘\0’ So p[0] becomes ‘\0’. It doesn’t matter what comes in p[1], p[2]….. as P[0] will not change for i >0. Nothing is printed if we print a string with first character ‘\0’
 Question 98

 A (i), (iv), (vi), (viii) B (i), (iv), (vii) C (i), (iii), (v), (vi), (viii) D (ii), (v), (viii)
Programming       OOPS       Gate-2004
Question 98 Explanation:
Name and id are a property of every employee and independent of their category. So these should be implemented in superclass. Every employee has a salary but this is determined by their category. So getsalary must be abstract function in superclass and implemented in subclass.
 Question 99

 A x + y using repeated subtraction B x mod y using repeated subtraction C the greatest common divisor of x and y D the least common multiple of x and y
Programming       C-Programming       Gate-2004
Question 99 Explanation:
Given code is same as Euclid's Algorithm for finding Greatest Common Divisor(GCD).
 Question 100

 A P - 2, Q - 3, R - 4, S - 1 B P - 4, Q - 3, R - 2, S - 1 C P - 3, Q - 4, R - 1, S - 2 D P - 3, Q - 4, R - 2, S - 1
Programming       Match-the-Following       Gate-2004
Question 100 Explanation:
P) Functional programming is declarative in nature, involves expression evaluation and side effect free.
Q) Logic is also declarative but involves theorem proving.
R) Object oriented is imperative statement based and have abstract data types.
S) Imperative programs are made giving commands and follow definite procedure.
 Question 101
Let x be an integer which can take a value of 0 or 1. The statement if(x = =0) x = 1; else x = 0; is equivalent to which one of the following?
 A x = 1 + x; B x = 1 - x; C x = x - 1; D x = 1 % x;
Programming       Programming       Gate 2004-IT
Question 101 Explanation:
x = 1 - x
For x = 0, it gives 1.
For x = 1, it gives 0.
 Question 102

A program attempts to generate as many permutations as possible of the string, 'abcd' by pushing the characters a, b, c, d in the same order onto a stack, but it may pop off the top character at any time. Which one of the following strings CANNOT be generated using this program?

 A abcd B dcba C abad D cabd
Programming       Programming       Gate 2004-IT
Question 102 Explanation:
A) push 'a' and pop 'a', push 'b' and pop 'b', push 'c' and pop 'c', and finally push 'd' and pop 'd'. Sequence of popped elements will come to abcd.
B) First push abcd, and after that pop one by one. Sequence of popped elements will come to dcba.
C) push abc, and after that pop one by one. Sequence of popped elements will come to cba. Now push 'd' and pop 'd', final sequence comes to cbad.
D) This sequence is not possible because 'a' cannot be popped before 'b' anyhow.
 Question 103
Consider the following C program which is supposed to compute the transpose of a given 4 x 4 matrix M. Note that, there is an X in the program which indicates some missing statements. Choose the correct option to replace X in the program.
```#include<stdio.h>
#define ROW 4
#define COL 4
int M[ROW][COL] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
main()
{
int i, j, t;
for (i = 0; i < 4; ++i)
{
X
}
for (1 = 0; i < 4; ++i)
for (j = 0; j < 4; ++j)
printf ("%d", M[i][j]);
}```
 A B C D
Programming       Programming       Gate 2004-IT
Question 103 Explanation:
To compute transpose 'j' needs to be started with 'i'. So, A and B are wrong.
In (D) , given statements is wrong as temporary variable needs to be assigned some value and not vice-versa.
 Question 104
What is the output of the following program?
```#include <stdio.h>
int funcf (int x);
int funcg (int y);

main()
{
int x = 5, y = 10, count;
for (count = 1; count <= 2; ++count)
{
y += funcf(x) + funcg(x);
printf ("%d ", y);
}
}

funcf(int x)
{
int y;
y = funcg(x);
return (y);
}

funcg(int x)
{
static int y = 10;
y += 1;
return (y+x);
}```
 A 43 80 B 42 74 C 33 37 D 32 32
Programming       Programming       Gate 2004-IT
Question 104 Explanation:
In first iteration:
In first case of funcf, which in turn calls funcg, y becomes 11 and it returns 5+11=16.
In second call of funcg, y becomes 12 and it returns 5+12=17.
So, in main y is incremented by 16+17=33 to become 10+33 =43.
In second iteration:
y will be incremented by 18+19=37 to give 43+37=80.
 Question 105
Choose the correct option to fill the ?1 and ?2 so that the program prints an input string in reverse order. Assume that the input string is terminated by a new line character.
```#include <stdio.h>
void wrt_it (void);
int main (void)
{
printf("Enter Text");
printf ("n");
wrt_ it();
printf ("n");
return 0;
}
void wrt_it (void)
{
int c;
if (?1)
wrt_it();
?2
}```
 A ?1 is getchar() ! = ‘\n’ ?2 is getchar(c); B ?1 is (c = getchar()); ! = ‘\n’ ?2 is getchar(c); C ?1 is c! = ‘\n’ ?2 is putchar(c); D ?1 is (c = getchar()) ! = ‘\n’ ?2 is putchar(c);
Programming       Programming       Gate 2004-IT
Question 105 Explanation:
getchar( ) = reads a single character at a time from the stdin.
putchar( ) = writes a character specified by the argument to stdout.
As getchar( ) and putchar( ), both are needed to read the string and prints its reverse and only option (D) contains both the function. (D) is the answer.
Now coming to the code, wrt_id(void) is calling itself recursively. When \n is encountered, putchat( ) gets executed and prints the last character and then the function returns to its previous call and prints last 2nd character and so on.
 Question 106
Consider the following C program:
```#include <stdio.h>
typedef struct
{
char *a;
char *b;
} t;
void f1(t s);
void f2(t *p);
main()
{
static t s = {"A", "B"};
printf ("%s %sn", s.a, s.b);
f1(s);
printf ("%s %sn", s.a, s.b);
f2(&s);
}
void f1(t s)
{
s.a = "U";
s.b = "V";
printf ("%s %sn", s.a, s.b);
return;
}
void f2(t *p)
{
p -> a  = "V";
p -> b = "W";
printf("%s %sn", p -> a, p -> b);
return;
}
```
What is the output generated by the program ?
 A AB UV VW VW B AB UV AB VW C AB UV UV VW D AB UV VW UV
Programming       Programming       Gate 2004-IT
Question 106 Explanation:
→ First print AB.
→ f1 is call by value. The changes applicable only for local from f1. UV is printed.
→ Back in main( ), AB is printed.
→ Then in f2, VW is printed.
Hence, answer is (B).
 Question 107
Consider the following logic program P A(x) <- B(x, y), C(y) <- B(x,x) Which of the following first order sentences is equivalent to P?
 A (∀x) [(∃y) [B(x,y) ∧ C(y)] ⇒ A(x)] ∧ ¬(∃x)[B(x,x)] B (∀x) [(∀y) [B(x,y) ∧ C(y)] ⇒ A(x)] ∧ ¬(∃x)[B(x,x)] C (∀x) [(∃y) [B(x,y) ∧ C(y)] ⇒ A(x)] ∨ ¬(∃x)[B(x,x)] D (∀x) [(∀y) [B(x,y) ∧ C(y)] ⇒ A(x)] ∧ (∃x)[B(x,x)]
Programming       Logic-Programming       Gate-2003
Question 107 Explanation:
Note: This is not in gate syllabus. Please ignore this question.
 Question 108
The following program fragment is written in a programming language that allows variables and does not allow nested declarations of functions.
 `global ``int` `i = 100, j = 5;` `void` `P(x)` `{` `    ``int` `i = 10;` `    ``print(x + 10);` `    ``i = 200;` `    ``j = 20;` `    ``print(x);` `}` `main()` `{` `    ``P(i + j);` `}`
If the programming language uses static scoping and call by need parameter passing mechanism, the values printed by the above program are
 A 115, 220 B 25, 220 C 25, 15 D 115, 105
Programming       Parameter-Passing       Gate-2003
Question 108 Explanation:
P(i+j)
P(100+5) = P(105)
→void P(105)
{
int i=10;
print (x+10);  ⇒ 105+10=115 prints
i=200;
j = 20;
print (x);  ⇒ x=105 prints
}
115, 105 prints
 Question 109
The following program fragment is written in a programming language that allows variables and does not allow nested declarations of functions.
 `global ``int` `i = 100, j = 5;` `void` `P(x)` `{` `    ``int` `i = 10;` `    ``print(x + 10);` `    ``i = 200;` `    ``j = 20;` `    ``print(x);` `}` `main()` `{` `    ``P(i + j);` `}`
If the programming language uses dynamic scoping and call by name parameter passing mechanism, the values printed by the above program are :
 A 115, 220 B 25, 220 C 25, 15 D 115, 105
Programming       Parameter-Passing       Gate-2003
Question 109 Explanation:
In dynamic,
In void P(x)
{  int i = 10;
print(x + 10);   ⇒ 105+10=115 prints

print (x);   ⇒ print x=220;
 Question 110
Consider the following class definitions in a hypothetical Object Oriented language that supports inheritance and uses dynamic binding. The language should not be assumed to be either Java or C++, though the syntax is similar.
```Class P
{
void f(int i)
{
print(i);
}
}

Class Q subclass of P
{
void f(int i)
{
print(2*i);
}
}
```
Now consider the following program fragment:
```P x = new Q();
Q y = new Q();
P z = new Q();
x.f(1); ((P)y).f(1); z.f(1);```
Here ((P)y) denotes a typecast of y to P. The output produced by executing the above program fragment will be
 A 1 2 1 B 2 1 1 C 2 1 2 D 2 2 2
Programming       Variable Binding       Gate-2003
Question 110 Explanation:
Because of using dynamic binding it results a values such as 2 2 2.
Note: The given question is not in the present syllabus
 Question 111
In the following C program fragment, j, k n and TwoLog_n are interger variables, and A is an array of integers. The variable n is initialized to an integer ≥ 3, and TwoLog_n is initialized to the value of 2*⌈log2(n)⌉
 `for` `(k = 3; k < = n; k++)` `    ``A[k] = 0;` `for` `(k = 2; k < = TwoLog_n; k++)` `    ``for` `(j = k + 1; j < = n; j++)` `        ``A[j] = A[j] || (j % k);` `for` `(j = 3; j < = n; j++)` `    ``if` `(!A[j]) ``printf``(``"%d"``, j);`
The set of numbers printed by this program fragment is
 A {m|m ≤ n, (∃i)[m=i!]} B {m|m ≤ n, (∃i)[m=i2]} C {m|m ≤ n, m is prime} D { }
Programming       C-Programming       Gate-2003
Question 111 Explanation:
Take n=4, so Two log_n=4
Now Trace the code,
for (k=3; k<=n; k++)
A[k]=0; // A[3]=0
A[4]=0
for (k=2; k<=Two log_n; k++)
for(j=k+1; j<=n; j++)
A[j] = A[j] // (j%k); // A[3] = 0 // I=1
A[4] = 0 // I=1
for (j=3; j<=n; j++)
if (!A[j]) printf("%d", j);
// if (!1) means if (0), so printf will never execute
Hence, Option (D) is the answer.
 Question 112
`Consider the C program shown below.`
 `#include ` `#define print(x) printf("%d ", x)` `int` `x;` `void` `Q(``int` `z)` `{` `    ``z += x;` `    ``print(z);` `}` `void` `P(``int` `*y)` `{` `    ``int` `x = *y + 2;` `    ``Q(x);` `    ``*y = x - 1;` `    ``print(x);` `}` `main(``void``)` `{` `    ``x = 5;` `    ``P(&x);` `    ``print(x);` `}`
The output of this program is
 A 12 7 6 B 22 12 11 C 14 6 6 D 7 6 6
Programming       C-Programming       Gate-2003
Question 112 Explanation:
In main function x=5; it is global array
p(&x) it goes to P( ) function
y=5
x=5+2=7;
Q(x)
z=7
z=7+5=12(Print+z→I)
comes to P( )
*y=7-1=6
x=7(Print x→II)
comes to main ( ),
print x=*y=6 (print x→III)
Output: 12 7 6
 Question 113
In the C language
 A At most one activation record exists between the current activation record and the activation record for the main B The number of activation records between the current activation record and the activation record for the main depends on the actual function calling sequence. C The visibility of global variables depends on the actual function calling sequence. D Recursion requires the activation record for the recursive function to be saved on a different stack before the recursive fraction can be called.
Programming       C-Programming       Gate-2002
Question 113 Explanation:
In C Language a function can create activation record from the created function stack.
 Question 114

 A An array, each element of which is a pointer to a structure of type node B A structure of 2 fields, each field being a pointer to an array of 10 elements C A structure of 3 fields: an integer, a float, and an array of 10 elements D An array, each element of which is a structure of type node
Programming       C-Programming       Gate-2000
Question 114 Explanation:
The given code represents an array of s[ ], in this each element is a pointer to structure of type node.
 Question 115

 A X – 1 Y – 3 Z – 2 B X – 2 Y – 1 Z – 3 C X – 3 Y – 2 Z – 1 D X – 3 Y – 1 Z – 2
Programming       Match-the-Following       Gate-2000
Question 115 Explanation:
X → m = NULL will results the loss of memory.
Y → n is pointer to invalid memory, a making it as a dangling pointer.
Z → p is not initialized.
p = malloc (size of(char))p = malloc (size of(char)); should have been used before assigning 'aa' to ∗p.
 Question 116
Aliasing in the context of programming languages refers to
 A multiple variables having the same memory location B multiple variables having the same value C multiple variables having the same identifier D multiple uses of the same variable
Programming       Aliasing       Gate-2000
Question 116 Explanation:
In computer programming, aliasing refers to the situation where the same memory location can be accessed using different names.
 Question 117

 A 22 bytes B 14 bytes C 18 bytes D 10 bytes
Programming       C-Programming       Gate-2000
Question 117 Explanation:
short [5] = 5×2 = 10
max[float, long] = max [4, 8] = 8
Total = short[5] + max[float,long] = 10 + 8 = 18
 Question 118

 A 10 B 4 C 6 D 7
Programming       C-Programming       Gate-2000
Question 118 Explanation:
At i=0; count=0
i=1; count=1
i=2; count=3
i=3; count=6
i=4; count=10
It return count value is 10.
 Question 119

 A Theory Explanation is given below.
Programming       Descriptive       Gate-2000
Question 119 Explanation:
Note: Out of syllabus.
 Question 120

Given the programming constructs (i) assignment (ii) for loops where the loop parameter cannot be changed within the loop (iii) if-then-else (iv) forward go to (v) arbitrary go to (vi) non-recursive procedure call (vii) recursive procedure/function call (viii) repeat loop, which constructs will you not include in a  programming  language  such  that  it  should  be  possible  to  program  the terminates (i.e., halting) function in the same programming language.

 A (ii), (iii), (iv) B (v), (vii), (viii) C (vi), (vii), (viii) D (iii), (vii), (viii)
Programming       Programming-Constructs       Gate-1999
Question 120 Explanation:
Arbitrary goto, recursive call and repeat loop may enter infinite loop and the program might never terminate.
 Question 121

 A Finds the maximum of a, b, and c B Finds the minimum of a, b and c C Finds the middle number of a, b, c D None of the above
Programming       C-Programming       Gate-1999
Question 121 Explanation:
Try for (3,2,2), it will go for infinite loop.
 Question 122

 A 89 B 90 C 91 D 92
Programming       Programming       Gate-1998
Question 122 Explanation:
Value returned by
fun(95) = fun(fun(106))
= fun(96)
= fun(fun(107))
= fun(97)
= fun(fun(108))
= fun(98)
= fun(fun(109))
= fun(99)
= fun(110)
= fun(100)
= fun(fun(111))
= fun(101)
= 91
 Question 123

 A 5 B 25 C 36 D 42
Programming       Programming       Gate-1998
Question 123 Explanation:
If it is call by reference then answer is 42.
If it is call by value then answer is 36.
 Question 124

 A x or A, y, x of B and z in S1 and x of B, y and i in S2 B x or B, y and z in S1 and x of B, i and z in S2 C x or B, z and y in S1 and x of A, i and y in S2 D None of the above
Programming       PASCAL-Programming       Gate-1997
Question 124 Explanation:
Note: Out of syllabus.
 Question 125

 A 10 B -20 C -10 D None
Programming       PASCAL-Programming       Gate-1995
Question 125 Explanation:
X is remains unchanged. As the if condition is becomes false.
X = -10
 Question 126

 A I B II C III D All of the above
Programming       Pascal Programming       Gate-1995
Question 126 Explanation:
Note: Out of syllabus.
 Question 127

 A Computes the LCM of two numbers B Divides the larger number by the smaller number C Computes the GCD of two numbers D None of the above
Programming       PASCAL-Programming       Gate-1995
Question 127 Explanation:
Let X=3 and Y=5
1st pass : X=3 and Y=2
2nd pass : X=1 and Y=2
3rd pass : X=1 and Y=1
Write(X), which writes 1. Which is nothing but GCD of 3 & 5.
 Question 128

 A 2 B C Run time error D None of the above
Programming       Programming       Gate-1995
Question 128 Explanation:
Since nothing is said in question. So we will assume by default call by value.
X in the procedure FIND is a local variable. No change will be reflected in global variable X.
 Question 129

 A 2800 B 2400 C 2000 D 1200
Programming       PASCAL-Programming       Gate-1995
Question 129 Explanation:
Note: Out of syllabus.
 Question 130

 A 1, because m is a local variable in P B 0, because m is the actual parameter that corresponds to the formal parameter in p C 0, because both x and y are just reference to m, and y has the value 0 D 1, because both x and y are just references to m which gets modified in procedure P E none of the above
Programming       Programming       Gate-1993
Question 130 Explanation:
0, because global m is not modified, m is just passed to formal argument of P.
 Question 131

 A 0, because n is the actual parameter corresponding to x in procedure Q. B 0, because n is the actual parameter to y in procedure Q. C 1, because n is the actual parameter corresponding to x in procedure Q. D 1, because n is the actual parameter corresponding to y in procedure Q. E none of the above
Programming       Programming       Gate-1993
Question 131 Explanation:
0, because n is just passed to formal parameters of Q and no modification in global n.
 Question 132

 A PARAM, P, Q B PARAM, P C PARAM, Q D P, Q E none of the above
Programming       Programming       Gate-1993
Question 132 Explanation:
Since m is defined global it is visible inside all the procedures.
 Question 133

 A exchanges a and b B doubles a and stores in b C doubles b and stores in a D leaves a and b unchanged E none of the above
Programming       Programming       Gate-1993
Question 133 Explanation:
Exchanges a and b.
Let us consider a=5; b=2
a := a+b = 5+2 = 7
b := a-b = 7-2 = 5
a := a-b = 7-5 = 2
O/P: a=2; b=5
 Question 134

 A 10 B 11 C 3 D None of the above
Programming       Programming       Gate-2001
Question 134 Explanation:
n=3
W(n)=W(3)
Procedure W(var x; int)
begin
x = x+1 = 3+1 = 4
Print x → Print x=4
end
 Question 135

 A 10, 3 B 31, 3 C 27, 7 D None of the above
Programming       Parameter-Passing       Gate-2001
Question 135 Explanation:
Here, variable x of func1 points to address of variable y.
And variable y and z of func1 points to address of variable x.
Therefore, y = y+4 ⇒ y = 10+4 = 14
and z = x+y+z ⇒ z = 14+14+3 = 31
z will be stored back in k.
Hence, x=31 and y will remain as it is (y=3).
Hence, answer is (B).
 Question 136

 A Theory Explanation is given below.
Programming       C-Programming       Gate-2001
 Question 137

 A PASCAL is out of syllabus.
Programming       PASCAL-Programming       Gate-1991
 Question 138

 A 41
Programming       Recursion       Gate-1991
Question 138 Explanation:
The recurrence relation for the no. of calls is
T(n) = T(n-1) + T(n-2) + 2
T(0) = T(1) = 0 (for fib(0) and fib(1), there are no extra recursive calls)
T(2) = 2
T(3) = 4
T(4) = 8
T(5) = 14
T(6) = 24
T(7) = 40
Counting the initial call, we get
40+1 = 41
 Question 139

 A B C D E None of the above
Programming       PASCAL-Programming       Gate-1991
Question 139 Explanation:
Note: Out of syllabus.
 Question 140

 A (a) - (s), (b) - (r), (c) - (p), (d) - (q)
Programming       Match-the-Following       Gate-1990
Question 140 Explanation:
Note: Out of syllabus.
 Question 141
In which of the following case(s) is it possible to obtain different results for call-by-reference and call-by-name parameter passing?
 A Passing an expression as a parameter B Passing an array as a parameter C Passing a pointer as a parameter D Passing as array element as a parameter E Both A and D
Programming       Parameter-Passing       Gate-1989
Question 141 Explanation:
Option D:
Passing array element as a parameter.
Consider an example:
{
.......
a[ ] = {1, 2, 3, 4, 5}
fun (a[i]);
print a[0];
}
fun (int x)
{
int i=1;
}
O/P:
Call-by-reference: 6
Call-by-name: 1
Result is different.
Option A:
While we passing an expression as a parameter due to precedence (higher (or) lower), the output may changes.
If we pass 1+2 to the below function
int foo (int x)
{
return x*x;
}
O/P:
Call by reference = 3*3 = 9
Call by name = 1+2*1+2 (* has higher precedenc e)
= 1+2+2
= 5
Output differs.
 Question 142
An unrestricted use of the "go to" statement is harmful because of which of the following reason (s):
 A It makes it more difficult to verify programs. B It makes programs more inefficient. C It makes it more difficult to modify existing programs. D It results in the compiler generating longer machine code.
Programming       Programming       Gate-1989
Question 142 Explanation:
Dijkstra's argued that unrestricted goto statements should abolished from the higher-level languages because they complicated the task of analyzing and verifying the correctness of programs.
 Question 143

 A 3, 6 B 6, 7 C 3, 7 D None of the above.
Programming       Programming       GATE-1987
Question 143 Explanation:
First procedure Q is called from the main procedure. Q has local variables x and y with values 3 and 4 respectively. This local variable y (value 4) is being parsed to procedure P during call, and received in local variable n inside procedure P. Now as P does not have any local definition for variable x, it will assign the evaluated value of (n+2)/(n-3), i.e., (4+2)/(4-3)=6 to the global variable x, which was previously 7. After the call of procedure P, procedure Q writes the value of local variable x which is still 3. Lastly, the main procedure writes the value of global variable x, which has been changed to 6 inside procedure P. So, the output will be 3, 6.
 Question 144
For the program given below what will be printed by the write statement marked (1) and (2) uin the program if the variablle are dybamically scoped?\
```Var x,y :integer;
begin
x:=(n+2)/(n-3)
end;
procedure Q
Var x,y :integer;
begin
x:=3;
y:=4;
P(y);
write (x)--------(1)
end;
begin
x:=7;
y:=8;
Q:
Write (x);------------(2)
end. ```
 A 3, 6 B 6, 7 C 3, 7 D None of the above
Programming       Programming       GATE-1987
Question 144 Explanation:
The same sequence of statements will be executed using dynamic scoping. However, as there is no local definition of variable x in procedure P, it will consider the recent definition in the calling sequence, as P is being called from procedure Q, definition of x from Q will be changed to 6 from 3. Now, when Q writes local variables x, 6 will be printed. The write global variable x from main procedure will print 7 (as value of the global variable x has not been changed). So, the output will be 6, 7.
There are 144 questions to complete.
PHP Code Snippets Powered By : XYZScripts.com