GATE Questions - C Programming

Labels: C Programming, GATE, Gate questions on C programming

Previous GATE questions with solutions on C Programming - CS/IT

GATE-2000

1. The number of tokens in the following C statement. 

printf("i = %d, &i = %x", i, &i);

is

(a) 3   (b) 26   (c) 10    (d) 21

Ans: option (c)

Explanation:

The smallest individual units are known as C Tokens. The keywords, identifiers, constants, string

literals, and operators described in this section are examples of tokens. Punctuation characters such

as brackets ([ ]), braces ({ }), parentheses ( ( ) ), and commas (,) are also tokens.

Example:

printf("Hello, World! \n");

The tokens for the above statement are:

1) printf

2) (

3) "Hello, World! \n"

4) )
5) ;

So there are 5 tokens

printf("i = %d, &i = %x", i, &i);

10 Tokens are:

1) printf

2) (

3) "i = %d, &i = %x"

4) ,

5) i

6) ,

7) &

8) i

9) )

10);

GATE-2012

2. 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) Choice A

    Choice B No choice

(d) Program gives no output as it is erroneous

Ans: Option (c)

Explanation:

In switch statement if a case is executed and if the case doesn't contain break, then all the subsequent 'case'

statements are executed until a break statement is found. If I modify the above code as below:

char inchar = 'B';

switch (inchar)

case 'A' :

printf ("choice A \n") ;

case 'B' :

printf ("choice B ") ;

case 'C' :

case 'D' :

case 'E' :

default:
 printf ("No Choice") ;

The output of the above program will be: Choice B No Choice

GATE-1999

3. Consider the following C function definition:

int Trial (int a, int b, int c)

if ((a > = b) && (c < b)) return b;

else if (a > = b) return Trial (a,c,b);

else return Trial (b,a,c);

The function Trial:  

(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  

Ans: (c)

Explanation:

The first condition, (a > = b) && (c < b), if true will return the middle number, i.e. b. Again on calling

the Trial function, it will return the middle number.

GATE CS 2000

4. The value of j at the end of the execution of the following C program. 

int incr (int i)

static int count = 0;

count = count + i;

return (count);

main ()

int i,j;

for (i = 0; i <=4; i++)

j = incr(i);

(a) 10    (b) 4    (c) 6    (d) 7

Ans: option (a)

Explanation:

count variable is declared as static in incr function. Therefore, static int count = 0;, will assign zero to

the count variable in the first call only. When the incr function is called for 2nd, 3rd or 4th times,

count variable will hold its previous value, and will not be re-initialized to zero again.

Static variables hold their previous values, and they do not re-initialized when the function is called

again. The lifetime of a static variable is in the entire program.

For 1st iteration when i=0, incr(0) => count= 0 + 0 = 0

For 2nd iteration when i=1, incr(1) => count= 0 + 1 = 1

For 3rd iteration when i=2, incr(2) => count= 1 + 2 = 3

For 4th iteration when i=3, incr(3) => count= 3 + 3 = 6

For 5th iteration when i=4, incr(4) => count= 6 + 4 = 10

GATE CS 2002

5. Consider the following declaration of a ‘two-dimensional array in C:

char a[100][100];

Assuming that the main memory is byte-addressable and that the array is stored starting from memory address

0, the address of a[40][50] is

(a) 4040       (b) 4050       (c) 5040        (d) 5050

Ans: option (b)

Explanation:

Address of a[40][50] = Starting Address + 40 x 100 x memorySize + 50 x memorySize

                              = 0 + 40 x 100 x 1 + 50 x 1 = 4050

Note: Since byte addressable, memorySize = 1

GATE CS 2005

6. Consider the following C-program:

void foo(int n, int sum)

int k = 0, j = 0;

if (n == 0) return;

k = n % 10; j = n / 10;

sum = sum + k;

foo (j, sum);

 printf ("%d,", k);

int main ()

int a = 2048, sum = 0;

foo (a, sum);

printf ("%d\n", sum);

getchar();

What does the above program print?

(a) 8, 4, 0, 2, 14 

(b) 8, 4, 0, 2, 0 

(c) 2, 0, 4, 8, 14 

(d) 2, 0, 4, 8, 0

Ans: option (d)

going through each code, you will find that foo  function prints all the digits of a number stored in variable a. 

Note:

i) k= n % 10  => modulus operator will return the remainder. for example, if n=2048, then 2048 %10 will store

the value 8 in k.

ii) j is declared as integer datatype in foo  function. Therefore after division if the result contains decimal part,

it will be truncated and only the integer part will be stored in j. For example if j=2048/10, (actual result =

204.8) then 204 will be stored in j.

iii) The sum variable declared in the main  function will not be used by the foo function. 

GATE CS 2004

7. Consider the following C function:

int f(int n)

static int i = 1;

if (n >= 5)

return n;

n = n+i;

i++;

return f(n);

The value returned by f(1) is

a) 5   b) 6   c) 7   d) 8

Ans: option (c)

Explanation:

Note that i is declared as static variable, first line of the function, static int i = 1;, will be executed only once.

Static variables hold their previous values, and they do not re-initialized when the function is called again. The

lifetime of a static variable is in the entire program. 

GATE CS 2004

8. Consider the following C program

main()

{
 int x, y, m, n;

scanf ("%d %d", &x, &y);

/* x > 0 and y > 0 */

m = x; n = y;

while (m != n)

if(m>n)

m = m - n;

else

n = n - m;

printf("%d", n);

The program computes

(a) x + y using repeated subtraction

(b) x mod y using repeated subtraction

(c) the greatest common divisor of x & y

(d) the least common multiple of x & y

Ans: option (c)

Explanation:

Give some values to x and y and work out the code step by step. The program code is an implementation

of Euclid's algorithm which is an efficient method for computing the greatest common divisor (GCD) of two

integers. 

For more details: http://en.wikipedia.org/wiki/Euclidean_algorithm

GATE-2005

9. 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

Ans: option (d)

Error:

Function 'foo' should have a prototype in function main()

GATE-2005

10. Consider line number 3 of the following C-program. 

int main ( ) { /* Line 1 */

int i, n; /* Line 2 */

fro (i =0, i<n, i++); /* Line 3 */

Identify the compiler’s response about this line while creating the object-module: 

(a) No compilation error    (b) Only a lexical error

(c) Only syntactic errors    (d) Both lexical and syntactic errors

Ans: option(c)

Error: Function 'fro' should have a prototype in function main()

GATE-2006

11. Consider these two functions and two statements S1 and S2 about them.
int work1(int *a, int i, int j) int work2(int *a, int i, int j)
{ {
  int x = a[i+2];     int t1 = i+2;
  a[j] = x+1;   int t2 = a[t1];
  return a[i+2] – 3;   a[j] = t2+1;
}   return t2 – 3;
}

S1: The transformation from work1 to work2 is valid, i.e., for any program state  and input arguments, work2

will compute the same output and have the same  effect on program state as work1

S2: All the transformations applied to work1 to get work2 will always improve the  performance (i.e reduce

CPU time) of work2 compared to work1

(a) S1 is false and S2 is false

(b) S1 is false and S2 is true

(c) S1 is true and S2 is false

(d) S1 is true and S2 is true

Ans: option (d)

Explanation:

Both functions work1  & work2  performs the same task, therefore S1 is true.

In S2 it is asking about improvement in performance i.e. reduction in CPU time. When compared  work2 will

reduce the CPU time, because in work1 a[i+2] is computed twice but in work2 a[i+2] is computed once and

stored in t2, and then t2 is used. When we consider the performance in terms of reduction in CPU time, S2 is

correct.

GATE - 2007

12. Consider the following C function:

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;

What is the value of f(5) ?

(a) 5    (b) 7    (c) 9    (d) 18

Ans: option (d)

Explanation:

As explained before, Static variables retain their values throughout the life of the program. The steps involved

in the execution is shown below.

Since f(3) returns value 16, the final step is 16+2 = 18. Therefore f(5) will return value 18.

GATE-2011

Common data Questions (13 & 14)

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;

13. 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

Ans: option (b)

Explanation:

foo(345,10) = 5 + [ foo(34,10) ]

                 = 5 + [ 4 + { foo(3,10) } ]

                 = 5 + [ 4 + { 3 + foo(0,10) } ] = 5 + 4 + 3 + 0 = 12

Therefore, foo function returns sum of digits in the number n, because r = 10.

14. What is the return value of the function foo when it is called as foo(513, 2)?

(a) 9   (b) 8   (c) 5   (d) 2

Ans: option (d)

Explanation:

Executing as above we get the value returned as 2. Here, foo function returns sum of bits of a number n,

because r = 2.

GATE-2008

15. 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 character. 

void reverse(void)

{
 int c;

if (?1) reverse() ;

?2

main()

printf ("Enter Text ") ; printf ("\n") ;

reverse(); printf ("\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);

Ans: option (d)

Explanation:

getchar() is used to get the input character.

putchar() is used to print the character.

The reverse function should read the character you type until you press the "enter" key. Hence before

printing, reverse function is called again and again until "enter" key is pressed. Once the "enter" key is
pressed; the functions from the function stack run putchar(c) statements one by one. Therefore, last entered

character is printed first.

GATE-2000

16. The following C declaration

struct node

int i;

float j;

};

struct node *s[10] ;

define s to be 

(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.

Ans: option (a)

GATE-2000

17. The most appropriate matching for the following pairs

X: m=malloc(5); m= NULL;        1: using dangling pointers

Y: free(n); n->value=5;         2: using uninitialized pointers

Z: char *p; *p = ’a’;           3: lost memory 

is:

(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

Ans: option (d)

Explanation:

malloc(size) - malloc function allocates a block of size bytes from the free data area (heap). On success, malloc

returns a pointer to the newly allocated block of memory.

Therefore after execution of m=malloc(5);,m contains a pointer to the newly allocated memory. But m=NULL;

statement will store the NULL value to m, without freeing the memory. Since the allocated memory is not yet

freed, it is a lost memory.

free - deallocates a memory block allocated previously by malloc, calloc, or realloc. Here, "free(n); n-

>value=5;", n is trying to retrieve a value after the memory has freed, hence dangling pointer.

A dangling pointer is a pointer to storage that is no longer allocated.

GATE CS 2000

18. Consider the following C declaration

struct {
short s [5]
 union {
float y;
long z;
}u;
} t; 

Assume that objects of the type short, float and long occupy 2 bytes, 4 bytes and 8 bytes, respectively. The

memory requirement for variable t, ignoring alignment considerations, is 

(a) 22 bytes  (b) 14 bytes  (c) 18 bytes  (d) 10 bytes

Ans: option (c)

Explanation:

The amount of memory required to store a structure variable is the sum of the sizes of all its

members. But in the case of union, the amount of memory required is the amount required by its

largest member.

Therefore u, which is a union member of the struct, occupies only 8 bytes of memory, because the

largest memory is 8 bytes consumed by long z;. Another member in the struct is short s [5], this will

occupy 10 bytes of memory ( 2 bytes x 5).

Hence total 10 + 8 =18 bytes.

GATE CS 2003

19. Assume the following C variable declaration

int *A [10], B[10][10];

Of the following expressions

I.   A[2]

II.  A[2][3]

III. B[1]
IV.  B[2][3]

which will not give compile-time errors if used as left hand sides of assignment statements in a C program?

(a) I, II, and IV only 

(b) II, III, and IV only

(c) II and IV only

(d) IV only

Ans: option (a)

Explanation:

A is an array of pointers, and A[2] can be used as left hand sides of assignment statements.

Suppose we have another array of integers i.e. int marks[]={10,20,30,40}. Then we can assign A[2] =

marks; Because marks represents the starting address of the array marks[], and on execution, the

address is stored in the 3rd element of array A.

Considering the assignment A[2] = marks;, A[2][3] represents the element 40 (i.e. 4th element in the

marks array). Therefore, A[2][3] also can be used as left hand sides of assignment statements. i.e.

A[2][3] = 45; will make the contents of marks array as {10,20,30,45}.

B[2][3] =12; represents a simple assignment to an element of a two-dimensional array. So B[2][3]

can also be used as left hand sides of assignment statements.

B[1] cannot be used as left hand sides of assignment statements, because, since it is a two-

dimensional array B[1] represents an address and we cannot write it.

GATE CS 2004

20. Consider the following C function

void swap (int a, int b)

{
 int temp;

temp = a;

a = b;

b = temp;

In order to exchange the values of two variables x and y. 

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

Ans: option (d)

Explanation:

call swap (x, y) - will swap only the formal parameters (i.e. a and b). The value actual parameters

(i.e. x and y) will remain the same, because the value are passed by  CALL BY VALUE.

call swap (&x, &y) - will not work because, swap function accepts VALUES as parameters, but we

are passing addresses of x and y.

option (c): swap (x,y) cannot be used, it is  correct, but reason is not correct.

GATE-2005

21. 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

Ans: option (c)

Explanation:

Syntax to declare pointer to a function => datatype (*pointer_variable)(list of arguments)

To make a pointer to a function => pointer_variable = function_name   

Note: don't use parenthesis of the function.

 To call (invoke) the function => pointer_variable(list of arguments)

GATE-2010

22. What does the following program print?

#include<stdio.h>

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

Ans: option (d)

Explanation:

Initially i=0 and j=0

f(&i, &j); on execution p pointer points to i, and q pointer points to j.

p = q; means p now contains the address of j, therefore p also now points to j.

*p = 2; 2 value is saved in the location where the p is pointing. Since p points to j, value of j is changed to 2

now.

Now returns to main function and prints i and j.Hence i=0 and j=2 

GATE-2011

23. 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

Ans: option (c)

Explanation:

p has the base address of character array c.

p[3] is E and p[1] is A

p[3] - p[1] = ASCII value of E - ASCII value of A

            = 69 - 65 =4

p = base address of C

Therefore, p + p[3] - p[1] = base_address + 4

(base_address + 4) is the base address of the string 2011.

GATE CS 2004

24. Consider the following C program segment:

char p[20];

char *s = "string";

int length = strlen(s);

int i;

for (i = 0; i < length; i++)

p[i] = s[length — i];

printf("%s",p);

The output of the program is 

(a) gnirts 

(b) gnirt

(c) string 

(d) no output is printed

Ans: option (d)

Explanation:

string is stored in the character array s.

We know that s[0]='s',s[1]='t',s[2]='r',...,s[5]='g',s[6]='\0'

During first iteration of the for loop, i=0, then p[0] = s[6-0]

Therefore p[0]='\0'

Hence during the execution of the printf  statement since the very first character is the null character, it assumes

that it is the end of the string and no output is printed.

GATE-2012

Common Data Question for 25 & 26

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);
}

25. What output will be generated by the given code segment?

(a)    (b)   (c)   (d)

3 1    4 2   4 2   3 1

4 1    6 1   6 2   5 2

4 2    6 1   2 0   5 2

Ans: option (c)

Explanation:

When a function encounters a variable, it will first check for its local variable. If local variable not found then

it will go for global variable.  In the above program we can see that there are 3 global variable a,b, & c. But in

prtFun() we have local variable a & b.  Therefore it will not go for the global variable a & b. But in the main

function we have only a as the local variable, therefore the print statement in main() will take the value of

global variable b and the value of local variable a, while printing. 

26. What output will be generated by the given code segment if:

Line 1 is replaced by “auto int a = 1;

Line 2 is replaced by “register int a = 2;

(a)   (b)   (c)   (d)

31 42 42 42

41 61 62 42

42 61 20 20

Ans: option (d)

Explanation:

static variable are now made as non-static, therefore each time when the function is called the variables are

again initialized. 

Note that the register variables are same as auto variables, the only difference is that the register variables are

allocated iin the registers, instead of main memory, for faster access.

GATE-2008

27. What is printed by the following C program?

int f(int x, int *py, int **ppz)

{
int y, z;
**ppz += 1;
z = **ppz;
*py += 2;
y = *py;
x += 3;
return x + y + z;
}

void main()
{
int c, *b, **a;
c = 4;
b = &c;
a = &b;
printf( "%d", f(c,b,a));
getchar();
}

(a) 18   (b) 19   (c) 21   (d) 22

Ans: option(b)
Hint: pointer b and py is pointing to c

Initially c = 4

ppz contains the address of b, therefore **ppz refers to the value to which b is pointing. Since b is

pointing towards c, the value of c increments when **ppz += 1; statement executes. Therefore c now

becomes 5.

z=**ppz; means z = 5

py pointer is pointing towards c, therefore on execution of *py += 2;, value of c becomes 7.

y=*py; means y = 7

x contains value 4, therefore on execution of  x+=3;  x becomes 7.

GATE - 2015

28. The output of the following C program is __________.

#include <stdio.h>

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);

Ans: -5

Explanation:

You can see that the f1 function is calls its parameters by value. Hence the modifications are made

inside the scope of f1 functions does not effect any of the variables of main function. But in f2, the

parameters are called by reference.

In f2, we can see that pointer a points to variable b and pointer b points to variable c.

c = *a; // means that c = 5;

*a = *b; // means that *a = 6; that is b= 6;

*b = c; // means *b = 5; that is c = 5;

Refer question number 22 for the basics of pointer.

GATE - 2015

29. 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.

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

Ans: option (a)

Explanation:

Here x is a two-dimensional array. Also it is given that the base address of x = 2000. And the integer

requires 4 bytes of memory. x[4][3] means that x has 4 rows and each row has 3 integers.

x + 3 means address of the 4th row (i.e. row with integers 10,11,12)

 = Base address of x + 3 * (size of memory required by a row)

 = 2000 + 3 * (3 * 4)

 = 2036

*(x + 3) => Since x is a two-dimensional array one reference operator (*) will only return the starting

address of the one-dimensional array. i.e. *(x + 3) will return the starting address of the 4th-row,

which equals 2036.

*(x + 2) + 3 means the address of 4th-integer of 3rd-row [ *(x + 2) means address of 3rd-row ]

=> address of second row + 3 * (size of memory required by an integer)

=> address of second row + 3 * 4

=> 2024 + 12

=> 2036
GATE - 2015

30. 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;

Which one of the following most closely approximates the return value of the function fun1?

(a) n3                      (b) n(logn)2

(c) nlogn                (d) nlog(logn)

Ans: option (d)

Explanation:

We can see that the first(outer) 'for' loop [i.e. for (i = 1; i<n; ++i)] runs for O(n) times.

Inner loop has two 'for' loops (j & k). 'j' loop runs for O(log n) times. 'k' loop runs for O(log p) times.

Since the 'j' loop runs for O(log n) times, p = log n.

Therefore total running of fun1:

T(n) = n(log n + log(log n))

     = n(log n) //dominant is log n

But if we iterate through the question again, we need to find the approximate value that is returned

by the function fun1 (i.e. value of q). As we saw above, value of q depends on p. On each iteration of

'i' loop, value of q increases by O(log p). And since p = log n, the value of q on each iteration of i

increases by Θ(log(log n)). Hence nlog(log n) most closely approximates the return value of the

function fun1.

Refer: How to find Time Complexity of an Algorithm

GATE - 2015

31. Consider the following C program segment.

#include <stdio.h>

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

Ans: option (c)

Explanation:

We know that p is a pointer.

p = s1 + 2; means that p holds the address of character 3. [s1 gives the address of character 1,

s1+1 gives the address of character 2, s1+2 gives the address of character 3, so on ...]

*p = '0'; Here we set the character '0' to the address pointed by p.

Hence the character array will be updated as 1204.

GATE - 2015

32. Consider the following C program.

#include<stdio.h>

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 _________.

Ans: 140
Explanation:

a is the array of integers and p is the array of pointers.

Initially ptr points to the first cell of p.

When we increment a pointer (like ptr++; in our question) it adds the size of the data type. Hence, it

moves to the next cell of p, which in turn points to the 4th cell of a. Hence **ptr gives us the value 40.

According to Pointer Subtraction, we can subtract two pointers of the same type. The result is the

distance (in array elements) between the two elements.

For example if p1 and p2 are two  pointers of type T, then

    ( p2 - p1 ) == ( addr( p2 ) - addr( p1 ) ) / sizeof( T )

Refer: https://www.cs.umd.edu/class/sum2003/cmsc311/Notes/BitOp/pointer.html

Hence applying it to our question:

    ptr - p = 1
GATE-2015

33. Consider the following recursive C function.

void get (int n)

   if (n < 1) return;

   get (n–1);

   get (n–3);

   printf (“%d”, n);

If get(6) function is being called in main( ) then how many times will the get() function be invoked

before returning to the main( )?

(a) 15

(b) 25

(c) 35

(d) 45

Ans: option (b)

Explanation:
GATE - 2015

34. Consider the following C program:

# include <stdio.h>

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;

The number of times printf statement is executed is __________.

Ans: 10

Explanation:

According to the precendence of operators we know that * & / has same precedence. Hence we

need to evaluate them in left to right associativity. Also we know that, * & / has higher precedence

than +, and higher precedence operators will be evaluated first.

j = 2 * 3 / 4 + 2.0 / 5 + 8 / 5;

  = 1 + 0.4 + 1

  = 2.4

 =2

Note1: 8/5 = 1 rather than 1.6 because both are integers. Hence result also remains integer by

implicit type conversion.

Note2: 2.0/5 = 0.4 because since 2.0 is of type double 5 is implicitly typecast to double.

Note3: j = 2.4 = 2 since j is of integer type implicit typecast takes place. Hence 2.4 becomes 2.
So after evaluation, we get j = 2 and k = -1

Evaluation of For Loop:

i = 0; Hence switch (-1) => Since no case is defined for the value of -1, we go to the default case.

Hence printf will be excuted once when i =0.

i = 1; switch (0) => printf will be executed only once since its the default case again.

i = 2; switch (1) => Now since case 1 is defined it moves to the case 1 block but since break is not

specified in any case, case1, case2, case3, and default case is executed. Hence printf statement is

executed 3 times when i = 2.

i = 3; switch (2) => Now since case-2 is defined it moves to the case2 block but since break is not

specified case2, case3, and default case is executed. Hence printf statement is executed 3 times

when i = 3.

i = 4; switch (3) => Now since case-3 is defined it moves to the case3 block but since break is not

specified case3, and default case is executed. Hence printf statement is executed 2 times when i =

4.

Hence in total printf is executed 10 times.

GATE - 2015

35. Consider the following C program.

#include<stdio.h>

int f1(void);

int f2(void);

int f3(void);

int x = 10;
int main( )

   int x = 1;

   x +=f1() + f2() + f3() + f2();

   printf(“%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; }

The output of the program is __________.

Ans: 230

Explanation:

x +=f1() + f2() + f3() + f2();

   = x + f1() + f2() + f3() + f2();

   = 1 + f1() + f2() + f3() + f2(); //x=1 since there is a local declaration of x in main function.

   = 1 + 26 + 51 + 100 + 52

   = 230

Note that in f2() x is declared as static, which means that x will be initialized only once and will retain

its value between invocations. Hence first call of f2() returns 51 and second call of f2() returns 52.

In f3(), x = x * 10; Since there is no local declaration of x in f3(), we get the value of x as 10, from the

global declaration.
GATE - 2015

36. Consider the C program below.

#include<stdio.h>

int *A, stkTop;

int stkFunc (int opcode, int val)

   static int size=0, stkTop=0;

   switch (opcode)

   {

      case -1: size = val; break;

      case 0: if (stkTop < size) A[stkTop++] = val; break;

      default: if (stkTop) < return A[--stkTop];

   }

   return –1;

int main()

   int B[20]; A=B; stkTop = –1

   stkFunc(–1, 10);

   stkFunc(0, 5);

   stkFunc(0, 10);

   printf(“%d\n”, stkFunc (1, 0) + stkFunc (0, 0));

Ans: 15

Explanation:

stkFun(-1, 10); // case -1 executes. initializes size =  10

stkFun(0, 5); // case 0 executes. Now stkTop = 0 and size = 10 (since static variable. check

explanation of question 35 to know more on static variable). Hence A[0] = 5, and stkTop = 1.

stkFunc(0, 10); // again  case 0. Now stkTop = 1 and size = 10. Hence A[1]=10 and stkTop = 2;

printf(“%d\n”, stkFunc (1, 0) + stkFunc (0, 0)); // prints 15. Since stkFun(1,0) and

stkFun(0,0) returns 10 and 5 respectively.

GATE-2015

37. Consider the following C function.

int fun(int n)

   int x=1, k;

   if (n==1) return x;

   for (k=1; k<n; ++k)

      x = x + fun (k) * fun (n – k);

   return x;

The return value of fun (5) is __________.

Ans: 51

Explanation:

Recurrence Relation
fun(5) = 1 + fun(1) * fun(4) + fun(2) * fun(3) + fun(3) * fun(2) + fun(4) * fun(1)

           = 1 + 15 + 10 + 10 + 15

           = 51

GATE - 2015

38. Consider the following function written in the C programming language.

void foo (char *a)

   if (*a && *a != ` `)

   {

      foo (a+1);

      putchar (*a);

   }

The output of the above function on input “ABCD EFGH” is

(a) ABCD EFGH

(b) ABCD

(c) HGFE DCBA

(d) DCBA

Ans: option (d)

Explanation:

Note that there is a space after ABCD, in the input. Therefore input is ABCD<space>EFGH.

The program prints all characters before the space or ‘\0′ (whichever comes first) in reverse order.
GATE-1991

Question is mentioned here to get the idea of loop-invariant in programming.

39. Consider the following PASCAL program segment:

if i mod 2 = 0 then

    while i >= 0 do

    begin

        i := i div 2;

        if i mod 2 < > 0  then i := i - 1;

        else i := i – 2;

    end;
An appropriate loop-invariant for the while-loop is ________

Ans: i mod 2 = 0

Explanation:

 A loop invariant is a formal statement about the relationship between variables in our program which

holds true just before the loop is ever run and is true again at the bottom of the loop, each time

through the loop.

Here is the general pattern of the use of Loop Invariant in your code:

   ...

   // the Loop Invariant must be true here

   while ( TEST CONDITION ) {

      // top of the loop

      ...

      // bottom of the loop

      // the Loop Invariant must be true here

   }

   // Termination + Loop Invariant = Goal

   ...

Ref: http://www.cs.miami.edu/home/burt/learning/Math120.1/Notes/LoopInvar.html