Loading....
Coupon Accepted Successfully!

 

Question 11

Write a C program to find the GCD of two numbers.


Here is a C program ....


#include 

int gcd(int a, int b);
int gcd_recurse(int a, int b);


int main()
{
  printf("\nGCD(%2d,%2d) = [%d]", 6,4,  gcd(6,4));
  printf("\nGCD(%2d,%2d) = [%d]", 4,6,  gcd(4,6));
  printf("\nGCD(%2d,%2d) = [%d]", 3,17, gcd(3,17));
  printf("\nGCD(%2d,%2d) = [%d]", 17,3, gcd(17,3));
  printf("\nGCD(%2d,%2d) = [%d]", 1,6,  gcd(1,6));
  printf("\nGCD(%2d,%2d) = [%d]", 10,1, gcd(10,1));
  printf("\nGCD(%2d,%2d) = [%d]", 10,6, gcd(10,6));

  printf("\nGCD(%2d,%2d) = [%d]", 6,4,  gcd_recurse(6,4));
  printf("\nGCD(%2d,%2d) = [%d]", 4,6,  gcd_recurse(4,6));
  printf("\nGCD(%2d,%2d) = [%d]", 3,17, gcd_recurse(3,17));
  printf("\nGCD(%2d,%2d) = [%d]", 17,3, gcd_recurse(17,3));
  printf("\nGCD(%2d,%2d) = [%d]", 1,6,  gcd_recurse(1,6));
  printf("\nGCD(%2d,%2d) = [%d]", 10,1, gcd_recurse(10,1));
  printf("\nGCD(%2d,%2d) = [%d]", 10,6, gcd_recurse(10,6));
  

  getch();
  getch();
  return(0);
}

// Iterative algorithm
int gcd(int a, int b)
{
   int temp;
   
   while(b)
   {
      temp = a % b; 
      a = b; 
      b = temp;
   }

   return(a);
}


// Recursive algorithm
int gcd_recurse(int a, int b)
{
   int temp;

   temp = a % b;

   if (temp == 0)
   {
      return(b);
   }
   else
   {
      return(gcd_recurse(b, temp));
   }
}





And here is the output ...


Iterative
----------------
GCD( 6, 4) = [2]
GCD( 4, 6) = [2]
GCD( 3,17) = [1]
GCD(17, 3) = [1]
GCD( 1, 6) = [1]
GCD(10, 1) = [1]
GCD(10, 6) = [2]

Recursive
----------------
GCD( 6, 4) = [2]
GCD( 4, 6) = [2]
GCD( 3,17) = [1]
GCD(17, 3) = [1]
GCD( 1, 6) = [1]
GCD(10, 1) = [1]
GCD(10, 6) = [2]



Note that you should add error handling to check if someone has passed negative numbers and zero.


Question 12

Write a C program to print a square matrix helically.


Here is a C program to print a matrix helically. Printing a matrix helically means printing it in this spiral fashion



 >-----------+
             |
 +---->--+   |
 |       |   |
 |       |   |
 |   <---+   |
 |           |
 +-----------+






This is a simple program to print a matrix helically.


#include

/* HELICAL MATRIX */

int main()
{
       int arr[][4] = { {1,2,3,4},
                        {5,6,7,8},
                        {9,10,11,12},
                        {13, 14, 15, 16}
                       };
     
       int i, j, k,middle,size;
       printf("\n\n");
       size = 4;
     
       for(i=size-1, j=0; i>0; i--, j++)
       {
              for(k=j; k               for(k=j; k               for(k=i; k>j; k--) printf("%d ", arr[i][k]);
              for(k=i; k>j; k--) printf("%d ", arr[k][j]);
       }
     
       middle = (size-1)/2;
       if (size % 2 == 1) printf("%d", arr[middle][middle]);
       printf("\n\n");
       return 1;
}




Question 13

Write code to remove duplicates in a sorted array.


There are a number of ways to remove duplicates from a sorted array. Here are a few C programs...


Method1

In this simple C program, we change the original array and also send the new size of the array back to the caller.


#include 

int removeDuplicates(int a[], int array_size);

// The main function
int main()
{
  
  // Different test cases..
  int my_array1[]    = {1, 1, 2, 3, 5, 6, 6, 7, 10, 25, 100, 123, 123};
  int my_array1_size = 13;

  int my_array2[]    = {1, 2, 3, 5, 6};
  int my_array2_size = 5;

  int my_array3[]    = {1, 1, 1, 1, 1};
  int my_array3_size = 5;

  int my_array4[]    = {123, 123};
  int my_array4_size = 2;

  int my_array5[]    = {1, 123, 123};
  int my_array5_size = 3;

  int my_array6[]    = {123, 123, 166};
  int my_array6_size = 3;
  
  int my_array7[]    = {1, 2, 8, 8 , 24, 60, 60, 60, 60, 75, 100, 100, 123};
  int my_array7_size = 13;

 
  my_array1_size = removeDuplicates(my_array1, my_array1_size);
  my_array2_size = removeDuplicates(my_array2, my_array2_size);
  my_array3_size = removeDuplicates(my_array3, my_array3_size);
  my_array4_size = removeDuplicates(my_array4, my_array4_size);
  my_array5_size = removeDuplicates(my_array5, my_array5_size);
  my_array6_size = removeDuplicates(my_array6, my_array6_size);  
  my_array7_size = removeDuplicates(my_array7, my_array7_size);  
  
  return(0);
}


// Function to remove the duplicates
int removeDuplicates(int a[], int array_size) 

  int i, j;
  
  j = 0; 


  // Print old array...
  printf("\n\nOLD : ");
  for(i = 0; i    {
     printf("[%d] ", a[i]);
  }
  
  
  // Remove the duplicates ...
  for (i = 1; i    { 
    if (a[i] != a[j]) 
    { 
      j++; 
      a[j] = a[i]; // Move it to the front 
    } 
  } 

  // The new array size..
  array_size = (j + 1);


  // Print new array...
  printf("\n\nNEW : ");
  for(i = 0; i   {
     printf("[%d] ", a[i]);
  }
  printf("\n\n");



  // Return the new size...
  return(j + 1); 
}





And here is the output...


OLD : [1] [1] [2] [3] [5] [6] [6] [7] [10] [25] [100] [123] [123]
NEW : [1] [2] [3] [5] [6] [7] [10] [25] [100] [123]


OLD : [1] [2] [3] [5] [6]
NEW : [1] [2] [3] [5] [6]


OLD : [1] [1] [1] [1] [1]
NEW : [1]


OLD : [123] [123]
NEW : [123]


OLD : [1] [123] [123]
NEW : [1] [123]


OLD : [123] [123] [166]
NEW : [123] [166]


OLD : [1] [2] [8] [8] [24] [60] [60] [60] [60] [75] [100] [100] [123]
NEW : [1] [2] [8] [24] [60] [75] [100] [123]






Method2

If we dont want to change the input array and just want to print the array without any duplicates, the solution is very simple. Check out the removeDuplicatesNoModify() function in the program below. It keeps a track of the most recently seen number and does not print any duplicates of it when traversing the sorted array.



#include 

void removeDuplicatesNoModify(int my_array[], int my_array1_size);
void print_array(int array[], int array_size, int current_pos, int dup_start, int dup_end);


// The main function
int main()
{
  // Different inputs...
  int my_array1[]    = {1, 1, 2, 3, 5, 6, 6, 7, 10, 25, 100, 123, 123};
  int my_array1_size = 13;

  int my_array2[]    = {1, 2, 3, 5, 6};
  int my_array2_size = 5;

  int my_array3[]    = {1, 1, 1, 1, 1};
  int my_array3_size = 5;

  int my_array4[]    = {123, 123};
  int my_array4_size = 2;

  int my_array5[]    = {1, 123, 123};
  int my_array5_size = 3;

  int my_array6[]    = {123, 123, 166};
  int my_array6_size = 3;
  
  int my_array7[]    = {1, 2, 8, 8 , 24, 60, 60, 60, 60, 75, 100, 100, 123};
  int my_array7_size = 13;

  
  removeDuplicatesNoModify(my_array1, my_array1_size);
  removeDuplicatesNoModify(my_array2, my_array2_size);
  removeDuplicatesNoModify(my_array3, my_array3_size);
  removeDuplicatesNoModify(my_array4, my_array4_size);
  removeDuplicatesNoModify(my_array5, my_array5_size);
  removeDuplicatesNoModify(my_array6, my_array6_size);  
  removeDuplicatesNoModify(my_array7, my_array7_size);  

  return(0);
}



//  This function just prints the array without duplicates.
//  It does not modify the original array!

void removeDuplicatesNoModify(int array[], int array_size) 
{   
   int i, last_seen_unique;

   if(array_size <= 1){return;}
   
   last_seen_unique = array[0];
   
   printf("\n\nOld : ", array_size);

   for(i = 0; i     {
     printf("[%2d] ", array[i]);
   }

   printf("\nNew : ", array_size);

   printf("[%2d] ", array[0]);
   for(i=1; i     {
       if(array[i]!=last_seen_unique)
       {
          printf("[%2d] ", array[i]);
          last_seen_unique = array[i];
       }
   }
   
   printf("\n");





And here is the output..

Old : [ 1] [ 1] [ 2] [ 3] [ 5] [ 6] [ 6] [ 7] [10] [25] [100] [123] [123]
New : [ 1] [ 2] [ 3] [ 5] [ 6] [ 7] [10] [25] [100] [123]


Old : [ 1] [ 2] [ 3] [ 5] [ 6]
New : [ 1] [ 2] [ 3] [ 5] [ 6]


Old : [ 1] [ 1] [ 1] [ 1] [ 1]
New : [ 1]


Old : [123] [123]
New : [123]


Old : [ 1] [123] [123]
New : [ 1] [123]


Old : [123] [123] [166]
New : [123] [166]


Old : [ 1] [ 2] [ 8] [ 8] [24] [60] [60] [60] [60] [75] [100] [100] [123]
New : [ 1] [ 2] [ 8] [24] [60] [75] [100] [123]






Method3

Here is a slightly compilcated, but more visual version of the removeDuplicates() function. It shrinks the original array as and when it find duplicates. It is also optimized to identify continuous strings of duplicates and eliminate them at one shot.




#include 

void removeDuplicates(int array[], int *array_size) ;
void print_array(int array[], int array_size, int current_pos, int dup_start, int dup_end);


// The main function
int main()
{
  // Different inputs...
  int my_array1[]    = {1, 1, 2, 3, 5, 6, 6, 7, 10, 25, 100, 123, 123};
  int my_array1_size = 13;

  int my_array2[]    = {1, 2, 3, 5, 6};
  int my_array2_size = 5;

  int my_array3[]    = {1, 1, 1, 1, 1};
  int my_array3_size = 5;

  int my_array4[]    = {123, 123};
  int my_array4_size = 2;

  int my_array5[]    = {1, 123, 123};
  int my_array5_size = 3;

  int my_array6[]    = {123, 123, 166};
  int my_array6_size = 3;
  
  int my_array7[]    = {1, 2, 8, 8 , 24, 60, 60, 60, 60, 75, 100, 100, 123};
  int my_array7_size = 13;

  removeDuplicates(my_array1, &my_array1_size);
  removeDuplicates(my_array2, &my_array2_size);
  removeDuplicates(my_array3, &my_array3_size);
  removeDuplicates(my_array4, &my_array4_size);
  removeDuplicates(my_array5, &my_array5_size);
  removeDuplicates(my_array6, &my_array6_size);  
  removeDuplicates(my_array7, &my_array7_size);  
  
  return(0);
}




// Changes the original array and resets the size of the array if duplicates
// have been removed.

void removeDuplicates(int array[], int *array_size) 
{   
   int i, j, k, l; 
   int current_pos;
   int dup_start;
   int dup_end;

   printf("\nInitial array (size : [%d])\n\n", *array_size);
   for(i = 0; i     {
     printf("[%2d] ", array[i]);
   }
   printf("\n\n\n------------------------------------------------\n");


   if(*array_size == 1){return;}


   // Remove the dups...
   for (i = 0; (i     { 
      //Start with the next element in the array and check if its a duplicate...
      for(j = i+1; (j        {
         if(array[i]!=array[j])
         {  
            // No duplicate, just continue...
            break;
         }
         else
         {
            // The next element is a duplicate. 
            // See if there are more duplicates, as we want to optimize here. 
            //
            // That is, if we have something like 
            // 
            // Array : [1, 1, 1, 2]
            // 
            // then, we want to copy 2 directly in the second position and reduce the 
            // array to 
            // 
            // Array : [1, 2].
            // 
            // in a single iteration.
            
            current_pos = i;
            dup_start = j;
            
            j++;
            
            while((array[i]==array[j]) && (j              {
              j++;
            }
            
            dup_end = j-1;
            
            print_array(array, *array_size, current_pos, dup_start, dup_end);
            
            // Now remove elements of the array from "dup_start" to "dup_end"
            // and shrink the size of the array.
         
            for(k = (dup_end + 1), l = dup_start ; k              {
               array[l++]=array[k++];
            } 
            
            // Reduce the array size by the number of elements removed.
            *array_size = *array_size - (dup_end - dup_start + 1);
            
         }
      }
   } 
   
   printf("\n\n------------------------------------------------");
   printf("\n\nFinal array (size : [%d])\n\n", *array_size);
   for(i = 0; i     {
     printf("[%2d] ", array[i]);
   }
   printf("\n\n");
   
}




// This function prints the array with some special pointers to the numbers that
// are duplicated. 
// 
// Dont bother too much about this function, it just helps in understanding
// how and where the duplicates are being removed from.

void print_array(int array[], int array_size, int current_pos, int dup_start, int dup_end)
{
  int i;
  
  printf("\n\n");
  
  for(i = 0; i    {
    printf("[%2d] ", array[i]);
  }
  
  printf("\n");
  
  for(i = 0; i    {
    if((i == current_pos) || 
       (i == dup_start && i == dup_end) || 
       ((i == dup_start || i == dup_end) && (dup_start != dup_end)))
    {
       printf("  ^  ");
    }
    else
    {
       printf("     ");
    }
  }
  
  printf("\n");
  
  for(i = 0; i    {
    if((i == current_pos) || 
       (i == dup_start && i == dup_end) || 
       ((i == dup_start || i == dup_end) && (dup_start != dup_end)))
    {
       printf("  |  ");
    }
    else
    {
       printf("     ");
    }
  }
  
  printf("\n");
  
  for(i = 0; i    {
    if(i == current_pos)
    {
       printf("  C  ");
    }
    else if(i == dup_start && i == dup_end)
    {
       printf(" S/E ");
    }
    else if((i == dup_start || i == dup_end) && (dup_start != dup_end))
    {
       if(i == dup_start)
       {
          printf("  S--");
       }
       else
       {
          printf("--E  ");
       }
    }
    else if(i>dup_start && i     {
       printf("-----");
    }
    else
    {
       printf("     ");
    }
  }
  
}






And here is the output (for one of the inputs)...


C - Current position.
S - Start of duplicates.
E - End of duplicates.





Old : [ 1] [ 2] [ 8] [ 8] [24] [60] [60] [60] [60] [75] [100] [100] [123]

-------------------------------------------------------------------------
[ 1] [ 2] [ 8] [ 8] [24] [60] [60] [60] [60] [75] [100] [100] [123]
            ^    ^
            |    |
            C   S/E


[ 1] [ 2] [ 8] [24] [60] [60] [60] [60] [75] [100] [100] [123]
                      ^    ^         ^
                      |    |         |
                      C    S---------E


[ 1] [ 2] [ 8] [24] [60] [75] [100] [100] [123]
                                ^    ^
                                |    |
                                C   S/E

-------------------------------------------------------------------------
New : [ 1] [ 2] [ 8] [24] [60] [75] [100] [123]




If there are other elegant methods of removing duplicate numbers from an array, please let me know!.


Question 14

Find the maximum of three integers using the ternary operator.


Here is how you do it


max = ((a>b)?((a>c)?a:c):((b>c)?b:c));



Here is another way


max = ((a>b)?a:b)>c?((a>b)?a:b):c;




Here is some code to find the max of 4 numbers...

Method1


#include  
#include  

#define max2(x,y)  ((x)>(y)?(x):(y)) 
#define max4(a,b,c,d)  max2(max2((a),(b)),max2((c),(d))) 

int main ( void ) 

    printf ( "Max: %d\n", max4(10,20,30,40)); 
    printf ( "Max: %d\n", max4(10,0,3,4)); 
    return EXIT_SUCCESS; 
}




Method2


#include  
#include  

int retMax(int i1, int i2, int i3, int i4) 

   return(((i1>i2)?i1:i2) > ((i3>i4)?i3:i4)? ((i1>i2)?i1:i2):((i3>i4)?i3:i4)); 


int main() 

   int val = 0 ; 

   val = retMax(10, 200, 10, 530); 
   val = retMax(9, 2, 5, 7); 

   return 0; 
}  



Question 15

How do you initialize a pointer inside a function?


This is one of the very popular interview questions, so take a good look at it!.


myfunction(int *ptr)
{
  int myvar = 100;
  ptr = &myvar;
}

main()
{
 int *myptr;
 myfunction(myptr);

 //Use pointer myptr.

}



Do you think this works? It does not!.


Arguments in C are passed by value. The called function changed the passed copy of the pointer, and not the actual pointer.


There are two ways around this problem

Method1

Pass in the address of the pointer to the function (the function needs to accept a pointer-to-a-pointer).


calling_function()
{
  char *string;
  return_string(/* Pass the address of the pointer */&string);
  printf(?\n[%s]\n?, string);
}

boolean return_string(char **mode_string /*Pointer to a pointer! */)
{
  *string = (char *) malloc(100 * sizeof(char)); // Allocate memory to the pointer passed, not its copy.
  DISCARD strcpy((char *)*string, (char *)?Something?);
}




Method2

Make the function return the pointer.


char *myfunc()
{
  char *temp = "string";
  return temp;
}

int main()
{
  puts(myfunc());
}



Question 16

Write C code to dynamically allocate one, two and three dimensional arrays (using malloc())


Its pretty simple to do this in the C language if you know how to use C pointers. Here are some example C code snipptes....

One dimensional array

int *myarray = malloc(no_of_elements * sizeof(int));

//Access elements as myarray[i]





Two dimensional array

Method1


int **myarray = (int **)malloc(no_of_rows * sizeof(int *));
for(i = 0; i  {
 myarray[i] = malloc(no_of_columns * sizeof(int));
}

// Access elements as myarray[i][j]




Method2 (keep the array's contents contiguous)


int **myarray = (int **)malloc(no_of_rows * sizeof(int *));
myarray[0] = malloc(no_of_rows * no_of_columns * sizeof(int));

for(i = 1; i    myarray[i] = myarray[0] + (i * no_of_columns);

// Access elements as myarray[i][j]



Method3


int *myarray = malloc(no_of_rows * no_of_columns * sizeof(int));

// Access elements using myarray[i * no_of_columns + j].




Three dimensional array

#define MAXX 3
#define MAXY 4
#define MAXZ 5

main()
{
    int ***p,i,j;
    p=(int ***) malloc(MAXX * sizeof(int ***));

    for(i=0;i     {
        p[i]=(int **)malloc(MAXY * sizeof(int *));
        for(j=0;j             p[i][j]=(int *)malloc(MAXZ * sizeof(int));
    }
        
    for(k=0;k         for(i=0;i             for(j=0;j                 p[i][j][k]=;

}



Question 17

How would you find the size of structure without using sizeof()?


Try using pointers


struct MyStruct
{
  int i;
  int j;
};

int main()
{
   struct MyStruct *p=0;
   int size = ((char*)(p+1))-((char*)p);
   printf("\nSIZE : [%d]\nSIZE : [%d]\n", size);
   return 0;
}



Question 18

Write a C program to multiply two matrices.


Are you sure you know this? A lot of people think they already know this, but guess what? So take a good look at this C program. Its asked in most of the interviews as a warm up question.


// Matrix A (m*n)
// Matrix B (n*k)
// Matrix C (m*k)

for(i=0; i {
   for(j=0;j    {
      c[i][j]=0;
      for(l=0;l            c[i][j] += a[i][l] * b[l][j];
   }
}



Question 19

Write a C program to check for palindromes.


An example of a palidrome is "avon sees nova"

There a number of ways in which we can find out if a string is a palidrome or not. Here are a few sample C programs...


Method1


#include 
#include 
#include 
#include 

void isPalindrome(char *string);

int main()
{
  isPalindrome("avon sees nova");
  isPalindrome("a");
  isPalindrome("avon sies nova");
  isPalindrome("aa");
  isPalindrome("abc");
  isPalindrome("aba");
  isPalindrome("3a2");
  exit(0);
}

void isPalindrome(char *string)
{
  char *start, *end;

  if(string)
  { 
     start = string;
     end   = string + strlen(string) - 1;

     while((*start == *end) && (start!=end))
     { 
       if(start        if(end>start)end--;
     } 

     if(*start!=*end)
     {
        printf("\n[%s] - This is not a palidrome!\n", string);
     }
     else
     {
        printf("\n[%s] - This is a palidrome!\n", string);
     }
  }
  printf("\n\n");
}






Method2


#include 
#include 
#include 
#include 

int isPalindrome(char string[]);

int main()
{
  isPalindrome("avon sees nova");
  isPalindrome("a");
  isPalindrome("avon sies nova");
  isPalindrome("aa");
  isPalindrome("abc");
  isPalindrome("aba");
  isPalindrome("3a2");
  return(0);
}

int isPalindrome(char string[])
{
  int count, countback, end, N;
  
  N   = strlen(string);
  end = N-1;

  for((count=0, countback = end); count <= (end/2); ++count,--countback)
  {
    if(string[count]!=string[countback])
    {
      return(1);
    }
  }

  printf("\n[%s] is a palidrome!\n", string);
  return(0);
}




Question 20

Write a C program to convert a decimal number into a binary number.


99% of the people who attend interviews can't answer this question, believe me!. Here is a recursive C program which does this....


#include
void generatebits(int num);

void generatebits(int num)
{
  int temp;
  if(num)
  {
    temp = num % 2;
    generatebits(num >>= 1);
    printf("%d",temp); 
  }
}

int main()
{
  int num;
  printf("\nEnter a number\n");
  scanf("%d", &num);
  printf("\n\n");
  generatebits(num);
  getch();
  return(0);
}




The reason we have shown a recursive algorithm is that, because of the magic of recursion, we dont have to reverse the bits generated to produce the final output. One can always write an iterative algorithm to accomplish the same, but it would require you to first store the bits as they are generated and then reverse them before producing the final output.






Test Your Skills Now!
Take a Quiz now
Reviewer Name