Programming | PSU Subject-Wise Solved Questions

for loop starts from 0 to 20 and in each iteration k is incremented by 2

k = 0 % 3 = 0
k = 2 % 3 = 2
k = 4 % 3 = 1    // prints 4
k = 6 % 3 = 0
k = 8 % 3 = 2
k = 10 % 3 = 1   // prints 10
k = 12 % 3 = 0
k = 14 % 3 = 2
k = 16 % 3 = 1   // prints 16
k = 18 % 3 = 0

Therefore, Output for above code segment is 4 10 16

As per the above code snippet
f(0) = 0
f(1) = 1
f(2) = 2

f(K) = F(k-1)*F(k-2)+F(k-3)
f(4) = f(3)*f(2)+f(1)
f(3) = f(2)*f(1)+f(0) 
     = 2*1+0
     = 2
So, We know that  
f(1) = 1
f(2) = 2
f(3) = 2
f(4) = f(3) * f(2) + f(1)
f(4) =  2   * 2    + 1
f(4) = 5

To left justify, we use a negative number in the field width

Statement 1 : True
1b+5 is an expression, which can be evaluated to a value 13, compiler itself will generate code to define and declare an unnamed temporary cell with value 13 and pass it to swap subroutine.

Statement 2 : Flase
There won't be any runtime error for the given code using pass by reference.

Statement 3 : False
There won't be any runtime error for the given code using pass by reference.

Statement 4 : True
Swap operation perform between the ia and temporary nameless cell, therefore the value of ib i.e. 8 is remains unchanged.   Due to the pass by reference nature of the language, the cell bound to variable 'ia' will get value 13 and the temporary unnamed cell which was allocated and passed to the swap subroutine will get value 3  and cell bound to variable 'ib' is unchanged, therefore printing 13 and 8 at the end of this routine.

Statement 5 : False
The program will print 13 and 8

In java, floor function works as usual it will give the lower limit value of any number.

Example :

• Floor of -7.4 will return the lower limit, i.e. -8.
• Floor of 94.69 will return the lower limit, i.e. 94.
• Floor of -39.28; will return the lower limit, i.e.40.

In every iteration we are incrementing the i value by 1 and x value by 2^x

In Iteration 1: x = 2 and i = 2
In iteration 2: x = 4 and i = 3
In iteration 3: x = 16 and i = 4
In iteration 4: x = 16,536 and i = 5
In iteration 5: Condition fails as x value > 500.

Therefore, i value = 5 option(B) is the correct answer.

Continue statement is used inside loops. When a continue statement is encountered inside a loop, the code inside the loop following the continue statement will be skipped and next iteration of the loop will begin.

In this code, continue statement encounter at last line. so there would be no effect on the execution of the program. Hence, the code will print 12345 as output.

Therefore, Option(B) is the correct answer.

P = get node () ; means allocating a space for a new node that we want to create and sets p as its address

• i = 0 : a = cos(pi * 0/2) = cos(0) = 1 ; Condition True. So, It print 1.
• i = 1 : a = cos (pi/2) = 0 ; Condition False. So else part print 0.
• i = 2 : a = cos(pi) = -1 ;  Condition True. So, It print 1.

Therefore, 101 will be printed as output.

So, Option(C) is the correct answer

Note : Other then 0 all values consider it as True  in if-condition.

Short-circuit :
The evaluation of a logical expression exit in between before complete evaluation, then it is known as Short-circuit. A short circuit happens because the result is clear even before the complete evaluation of the expression, and the result is returned. Short circuit evaluation avoids unnecessary work and leads to efficient processing.

By using short circuit technique

• z = 0: x = 1, y = 1, if condition false
• z = 1: x = 2, y = 2, if condition false
• z = 2: x = 3, if condition true and due to short circuiting ++y is not evaluated and y value still 2.
  x++ // x = 4
• z = 3: x = 5, if condition is true and due to short circuiting ++y is not evaluated and y value still 2.
  x++ // x = 6
• z = 4: x = 7, if condition true and due to short circuiting ++y is not evaluated and y value still 2.
  x++ // x = 8
• z = 5 ; for loop condition fails and terminate hear

Code will print 8 2 as results.

Therefore, option (A) is the correct answer.

int * f [ ] ( ) // function f  is an array of functions returning pointers to integers.

Declaring integer pointer
int * ptr_integer;  // ptr_integer is a pointer to integer

Declare a function
int f(int);  // f is a function that returns int and takes one argument of int type

int * f(int);

• function f with one argument of int type and return value of int * i.e. integer pointer.
• According to operator precedence operator () will take priority over operator *.
• function f with one argument of int type and return value of int * i.e. integer pointer.

int (*f) (int * )

• A pointer to a function that takes an integer pointer as argument and returns an integer.

Given data,
i = 0,
j = 1,
k = –1,
x = 0.5,
y = 0.0,

We need to caluculate :
x * y < i + j || k

According to operator precedence

• "*"   Has higher precedence among all the operators and associativity is from "left to right"
• "+"  Has next higher precedence among all the operators and associativity is from "left to right"
• "<"  Has next higher precedence among all the operators.
• "||"  Has low precedence among all the operators.

According to precedence and associativity then lets parenthesize it

x * y < i + j || k = (  (  (x*y) <  ( i + j) ) || k )
= (  (  ( 0.5 * 0.0 ) <  ( 0 + 1) ) || -1 )
= (  (   0  <   1 ) || -1 )
= (  1 || -1 )
= 1

Base condition: n == 0  then execution stops and return n value

int f(100) 
———————————   
100 + f(98)
    —————  
     98 + f(96)
         —————
         96 + f(94)
             —————
             94 + f(92)
                 —————
                 92 + f(90)
                     —————
                       '
                        '
                         '
                         2 + f(0)

So, The above series is in Arithmetic Progression(A.P)
= 2+4+6+8+ ........... +98+100
= n(n+1)  // It is nothing but sum of even numbers upto 'n'
= 50 × 51
= 2550

Intially : term=1, sum=0;

i=1 :
term = term * x / i = 1 * x / 1 = x.
sum = sum + term = 0+x= x.

i = 2 :
term = term * x / i = x * x / 2 = x² / 2.
sum = sum + term = x + x² / 2.

i = 3 :
term = term * x / i = x² / 2 * x / 3 = x³ / 3! .
sum = sum + term = x + x² / 2 + x³ / 3! .

and so on . . . . . . . . .

Which is equl to x + x²/2! + x³/3! + x⁴/4! +........

Therefore, option(B) is the right answer.

In this program we used post-increment.  Post increment operator is used to increment the value of the variable after executing printf statement

printf (“\n%d”, 1 + x++); // hear x value still 128
Hear, x value incremented by 1 now x = 129

printf (“\n%d”, 1 + 128)
output : 129

Given expression,
char *(*(*a[N]) ( )) ( );

a
Indicates name

a[N]
It is an N-element array

*a[N]
It is an N-element array of pointers

(*a[N])()
It is an N-element array of pointers to functions

*(*a[N])()
It is an N-element array of pointers to functions returning pointers

(*(*a[N])())()
It is an N-element array of pointers to functions returning pointers to functions

*(*(*a[N])())()
It is an N-element array of pointers to functions returning pointers to functions returning pointers

char *(*(*a[N])())()
It is an N-element array of pointers to functions returning pointers to functions returning pointers to char.

∴ An array of n pointers to function returning pointers to functions returning pointers to characters.

Therefore, option(D) is the correct answer

Loop invariant definition
A loop invariant is a statement about program variables that is true before and after each iteration of a loop. A good loop invariant should satisfy three properties:

• Initialization: The loop invariant must be true before the first execution of the loop.
• Maintenance: If the invariant is true before an iteration of the loop, it should be true also after the iteration.
• Termination: When the loop is terminated the invariant should tell us something useful, something that helps us understand the algorithm.

Initially k = 0 and p = 0

After First iteration:
For k = 0, p = p + 2k = 0 + 2⁰ = 1

After Second iteration:
For k =1, p  = p + 2k = 1 + 2¹ = 3

After Third iteration:
For k = 2, p = p + 2k = 3 + 2² = 7

After Fourth iteration:
For k = 3, p = p + 2k = 7 + 2³ = 15

Now , check all the option which gives same value of p when k = 0, 1 ,2 ,3

• k=0, P=1
• k=1, P=3
• k=2, P=7
• k=3, P=15

Option(A): incorrect
p = 2^k - 1 and 0≤k < m
When k = 0, p = 2⁰ - 1 = 0

Option(B): correct
p = 2^k+1 - 1 and 0≤k < m
When k = 0, p = 2⁰⁺¹ – 1 = 1
When k = 1, p = 2¹⁺¹ – 1 = 3
When k = 2, p = 2²⁺¹ – 1 = 7
When k = 3, p = 2³⁺¹ – 1 = 15

Option(C): incorrect
P = 2 ^{k − 1} and 0≤k≤m
When k = 0, p = 2^0-1 = 0.5

Option(D): incorrect
This option also giving the same values, but it is not true in the case as k<=m in that, which should be k < m

**Given key is option(C) but option(B) is correct*** Let us know in the discussion form if we miss anything.

Let us take an example
String w = “Era”
Length of the string = 3
int x = strlen(w);       // x= 3

• w[0]= E,
• w[1] = R,
• w[2] = A,
• w[3] = \0,

In iteration 1:

For ( int i = 0; i < x; i++)  // Condition true as, 0< 3
c = w[i];                    // c = w[0] = E
w[i] = w[x - i - 1];         // w[0] = w[3-0-1]= w[2] = A
w[x - i - 1] = c;            // w[3- 0 -1 ] = w[2] = E

In iteration 2:

For (int i = 0; i < x; i++)  // condition true as, 1< 3
c = w[i];                    // c = w[1] = R
w[i] = w[x - i - 1];         // w[1] = w[3-1-1]= w[1] = R
w[x - i - 1] = c;           // w[3- 1 -1 ] = w[1] = C

In iteration 3:

For (int i = 0; i < x; i++)   // condition true as, 2< 3
c = w[i];                     // c = w[2] = E
w[i] = w[x - i - 1];          // w[2] = w[3-2-1]= w[0] = A
w[x - i - 1] = c;             // w[3- 2 -1 ] = w[0] = E

Finally, The array will be :

• w[0]= E,
• w[1] = R,
• w[2] = A,
• w[3] = null character

Therefore, it outputs the content of the array in the original order

Option(C) is the correct answer.

Points to Remember :

• Shifting all of a number's bits to the left by 1 bit is equivalent to multiplying the number by 2.
• All of a number's bits to the left by n bits is equivalent to multiplying that number by 2ⁿ.
• Logical right shifts are denoted by >>>. They shift all bits to the right and fill in vacated places with 0's
• When performing AND on two integers, the AND operation is calculated on each pair of bits (the two bits at the same index in each number).
  Example : 5 & 6 =4  which gives 4 as result

Now  Let's track The execution :

Initially b = 0
Consider a = 5

Iteration i= 0 :

for(int i=0; i<32; i++)  //condition true
b = b<<1;              // (0 × 2 = 0) ; b=0
b= b | (a & 1);       // 0 | (5 & 1);[(101)&(001)=001]; b=1 
a = a >>> 1;         // logical right shift; a = 101 >>> 1 =010
                        So, a=2

Iteration i= 1 :

for(int i=0; i<32; i++)   // 1<32, condition true
b = b<<1;               // (1 * 2) ; b=2
b= b | (a & 1);       // 2 |(2 & 1) ; b=2
a = a >>> 1;        // This is a logical right shift; So,a=1

Iteration i= 2 :

for(int i=0; i<32; i++)  // 2<32, condition true
b = b<<1;              // (2*2=4) ; b=4
b= b | (a & 1);      // 4|(1 & 1) ; 100|(001&001)=100|001=101; b=5
a = a >>> 1;        // This is a logical shift; So, a=0

Iteration i= 3 :

for(int i=0; i<32; i++)   // 3<32, condition true
b = b<<1;               // b=10
b= b | (a & 1);    // 10|(0 & 1) ; b=10
a = a >>> 1;     // this is a logical shift; So, a=0

Hear, value of b will multiply by 2 on every iteration up to i value became 31
when i = 4, b = 20
when i = 5, b = 40
when i = 6, b = 80 = 2³ × 10
when i = 7, b = 160 = 2⁴ × 10
'
'
'
'
when i = 29, b = 160 = 2²⁶ × 10
when i = 30, b =   2²⁷ × 10
but Size of int is 4 byte in java: Range - 2³¹ to 2³¹ – 1
when i = 30, b =   2²⁷ × 10 ≡ -1610612736
when i = 31, b =   2²⁸ × 10 ≡ -1610612736

a = 5 = (0000 0000 ….... 0101)₂
Reverse of a = (1010 0000 0000 …. 0000)₂ = -2³¹ + 2²⁹ = -1610612736

Hence, the Given code snippet return the int that has the reversed binary representation of integer a.

Function call: f(2, 3)
Where, m = 2 and n = 3

STEP 1:

• float result = (float) m / (float) n;  // result = 2.0/ 3.0 = 0. 66
• if (m < 0 || n < 0)                 // false, else part will execute
• result += f(m*2, n*3);        // result = 0.66 + f (4, 9)

STEP 2:

• float result = (float) m / (float) n;   // result = 4.0/ 9.0 = 0. 44
• if (m < 0 || n < 0)           // false, else part will execute
• result += f(m*2, n*3);     // result = 0.66 + 0.44 + f (8, 27)

STEP 3:

• float result = (float) m / (float) n;  // result = 8.0/ 27.0 = 0. 296
• if (m < 0 || n < 0)           // false, else part will execute
• result += f(m*2, n*3);   // result = 0.66+ 0.44 + 0.296 + f (16, , 81)

STEP 4:

• float result = (float) m / (float) n;   // result = 16.0/ 81.0 = 0. 197
• if (m < 0 || n < 0)               // false, else part will execute
• result += f(m*2, n*3);        // result = 0.66+ 0.44 + 0.296 + 0.197 + f (32, 243)

STEP 5:

• float result = (float) m / (float) n;   // result = 32.0/ 243.0 = 0. 131
• if (m < 0 || n < 0)            // false, else part will execute
• result += f(m*2, n*3);     // result = 0.66+ 0.44 + 0.296 + 0.197 + 0.131 + f (64, 729)

STEP 6:

• float result = (float) m / (float) n;   // result = 64.0/ 729.0 = 0. 087
• if (m < 0 || n < 0)         // false, else part will execute
• result += f(m*2, n*3);   // result = 0.66+ 0.44 + 0.296 + 0.197 + 0.131 + 0.087 + f (128, 2187)

STEP 7:

• float result = (float) m / (float) n;   // result =128.0/2187.0= 0.058
• if (m < 0 || n < 0)         // false, else part will execute
• result += f(m*2, n*3);    // result = 1.813 + 0.058 + f (256, 6561)

STEP 8:

• float result = (float) m / (float) n;  // result = 256/6561 = 0.039
• if (m < 0 || n < 0)           // false, else part will execute
• result += f(m*2, n*3);   // result = 1.871 + 0.039 + f (512, 19683)

STEP 9:

• float result = (float) m / (float) n; // result = 512/19683 = 0.0260
• if (m < 0 || n < 0)        // false, else part will execute
• result += f(m*2, n*3);   // result = 1.871 + 0.039  + 0.0260 = 1.91 + f (1024, 59049)

STEP 10:

• result = 1.91 + 0.017 + f(2048, 177,147)

Therefore the best approximate value is the sum of all the function call result values which is equal 2.

Statement coverage is said to make sure that every statement in the code is executed at least once.

Decision/branch coverage is said to ensure that each one of the possible branch from each decision point is executed at least once and thereby ensuring that all reachable code is executed. That is, every branch taken each way, true and false. It helps in validating all the branches in the code making sure that no branch leads to abnormal behavior of the application.

Note :

• If there is 100% branch coverage then there is 100% statement coverage
• If there is 100% statement coverage then it does not imply 100% branch coverage

The reason is in branch coverage apart from executing all the statements, we should also verify if the tests executes all branches, which can be interpreted as covering all edges in the control flow branch

Comming to the question : 

P : Minimum number of tests to achieve full statement coverage for f() = 3

Total 4 conditions. If any one condition is TRUE remaining automatically will get False except if in else- if i.e. Condition 3

Condition 1
if(m<0) 
   { 
      res=n-m;
   }
Condition 2
  else if(x || y) 
   {
     res= -1;
Condition 3
     if( n==m) 
        { 
           res =1; 
        }
   }
Condition 4
  else 
   { 
     res=n; 
   }

Condition-1	Condition-2	Condition-3	Condition-4
True	False	False	False
False	True	True	False
False	False	False	True

Therefore, the Minimum number of tests to achieve full statement coverage P = 3

Q : Minimum number of tests to achieve full branch coverage for f()

Condition-1	Condition-2	Condition-3	Condition-4
True	False	False	False
False	True	False	False
False	True	True	False
False	False	False	True

Therefore, Minimum number of tests to achieve full Branch coverage Q = 4

Hence, option(A) is the correct answer.