All Programming & Data Structures questions

T                   S
I:   Inorder        L: left subtree, node, right subtree
II:  Preorder       M: node, left subtree, right subtree
III: Postorder      N: left subtree, right subtree, node

Single correct

• AI – L, II – M, III – N
• BI – M, II – L, III – N
• CI – N, II – M, III – L
• DI – L, II – N, III – M

#include <stdio.h>
int a=5;
int main(){
  int a=7;
  return(0);
}

#include <stdio.h>
int main(){
  int a=5;
  int a=7;
  return(0);
}

#include <stdio.h>
int main(){
  int a=5;
  float a=7;
  return(0);
}

Single correct

• AOnly P1 will compile without any error
• BOnly P2 will compile without any error
• COnly P3 will compile without any error
• DAll three programs P1, P2, and P3 will compile without any error

Numerical answer

One or more correct

• A$K$ cannot have any duplicates
• B$K$ will have at least one element
• CAfter inserting all keys from $K$, the height of the BST can increase at most by one
• DNumber of nodes in the BST will double after inserting all keys from $K$

One or more correct

• A$1S, 2Q, 3S, 4S, 5Q$
• B$1Q, 2Q, 3S, 4S, 5Q$
• C$1Q, 2Q, 3Q, 4S, 5S$
• D$1S, 2S, 3S, 4Q, 5Q$

#include <stdio.h>
int main(){
  int *ptr, a, b, c;
  a=5; b=11; c=20;
  ptr=&a; *ptr=c; ptr=&c;
  a=*(&b); c=*ptr-a;
  printf("%d",c);
  return(0);
}

Numerical answer

int func(int start, int end){
  int length=end+1-start;
  if((length<1)||(start<0)||(end<0)){ return(0); }
  if(length%3==0){
    return(func(start+1, end));
  } else if(length%3==1){
    return(1+func(start, end-1));
  } else {
    return(func(start+2, end));
  }
}

Numerical answer

Single correct

• A$\dfrac{n-2}{2}$
• B$\dfrac{n-1}{2}$
• C$\dfrac{n}{2}$
• D$\dfrac{n+1}{2}$

#include <stdio.h>
void stringcopy(char *, char *);
int main(){
  char a[30] = "@#Hello World!";
  stringcopy(a, a + 2);
  printf("%s\n", a);
  return 0;
}
void stringcopy(char *s, char *t) {
  while(*t)
    *s++ = *t++;
}

Single correct

• A@#Hello World!
• BHello World!
• Cello World!
• DHello World!d!

int x=126,y=105;
do {
     if(x>y) x=x-y;
     else y=y-x;
} while(x!=y);
printf("%d",x);

Numerical answer

Numerical answer

Single correct

• AP: $\Theta(1)$, Q: $\Theta(n)$, R: $\Theta(n)$
• BP: $\Theta(1)$, Q: $\Theta(n\log n)$, R: $\Theta(n)$
• CP: $\Theta(n)$, Q: $\Theta(n\log n)$, R: $\Theta(n^2)$
• DP: $\Theta(1)$, Q: $\Theta(n)$, R: $\Theta(n\log n)$

One or more correct

• AKeep with every record in the stack, a pointer to the record with the smallest key below it.
• BKeep a pointer to the record with the smallest key in the stack.
• CKeep an auxiliary array in which the key values of the records in the stack are maintained in sorted order.
• DKeep a Min-Heap in which the key values of the records in the stack are maintained.

#include <stdio.h>
int main(){
  int a;
  int arr[5] = {30,50,10};
  int *ptr;
  ptr = &arr[0] + 1;
  a = *ptr;
  (*ptr)++;
  ptr++;
  printf("%d", a + (*ptr) + arr[1]);
  return 0;
}

Numerical answer

#include <stdio.h>

int g(int n) {
    return (n+10);
}

int f(int n) {
    return g(n*2);
}

int main() {
    int sum, n;
    sum=0;
    for (n=1; n<3; n++)
        sum += g(f(n));
    printf ("%d", sum);
    return 0;
}

Numerical answer

#include <stdio.h>
int g(int p) { printf("%d", p); return p; }
int h(int q) { printf("%d", q); return q; }
void f(int x, int y) {
  g(x);
  h(y);
}
int main() {
  f(g(10),h(20));
}

Single correct

• A20101020
• B10202010
• C20102010
• D10201020

int fX(char *a){
    char *b = a;
    while(*b)
        b++;
    return b - a;}

One or more correct

• AThe function call fX("abcd") will always return a value
• BAssuming a character array c is declared as char c[] = "abcd" in main(), the function call fX(c) will always return a value
• CThe code of the function will not compile
• DAssuming a character pointer c is declared as char *c = "abcd" in main(), the function call fX(c) will always return a value

#include <stdio.h>
int main() {
    double a[2]={20.0, 25.0}, *p, *q;
    p = a;
    q = p + 1;
    printf("%d,%d", (int)(q - p), (int)(*q - *p));
    return 0;}

Single correct

• A4,8
• B1,5
• C8,5
• D1,8

Single correct

• AInorder traversal of $T$ can be determined from $V$
• BRoot node of $T$ can be determined from $V$
• CPreorder traversal of $T$ can be determined from $V$
• DPostorder traversal of $T$ can be determined from $V$

int first=0, second=0, len1=0, len2=0, maxlen=0;
for (int i=0; i < n; i++) {
  if (X[i] == first) {
    len2++; len1++;
  } else if (X[i] == second) {
    len2++;
    len1 = (P);
    second = first;
  } else {
    len2 = (Q);
    len1 = 1; second = first;
  }
  if (len2 > maxlen) {
    maxlen = len2;
  }
  first = X[i];
}

Single correct

• A(P) len1+1 (Q) len2+1
• B(P) 1 (Q) len1+1
• C(P) 1 (Q) len2+1
• D(P) len2+1 (Q) len1+1