C Programming Tricky Interview Questions Part-1

C programming forms the basis of technical interviews at many companies. Interviewers often ask tricky C questions to evaluate a candidate’s understanding of core concepts like pointers, memory management, and flow control. Mastering such questions is key to successfully clearing coding interviews of C.

Why Tricky Questions Matter in C Programming Interviews

Tricky questions in C help assess a candidate’s:

• Depth of knowledge in C
• Ability to analyze and solve problems
• Understanding of edge cases and nuances
• Experience debugging complex scenarios

This article of mostly asked interview questions of C will equip you with techniques to tackle such questions and explain the thought process behind arriving at solutions.

Tricky Question 1: Pointers and Arrays in C

The Mystery of Pointer Arithmetic

Pointers and arrays in C have an intimate relationship. Pointer arithmetic in C allows accessing array elements efficiently. But it can also lead to confusing edge cases.

Question 1.1: Swapping Two Integers Using Pointers

Problem: Write a code snippet to swap two integer variables, a and b, using pointer arithmetic.

Question 1.2: Finding the Largest Element in an Array Using Pointers

Problem: Given an integer array arr of size n, find the largest element in the array using pointer arithmetic.

Solution and Explanation

// Swapping two integers using pointers

#include <stdio.h>

void swap(int* a, int* b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

int main() {

  int a = 10, b = 20;
  
  swap(&a, &b);
  
  printf("a = %d, b = %d", a, b);

  return 0;
}

// Output
a = 20, b = 10

// Finding the largest element using pointers

#include <stdio.h>

int findLargest(int* arr, int n) {
  int max = *arr; // assume first element is largest initially
  
  for(int i=1; i<n; i++) {
    if(*(arr + i) > max) {
      max = *(arr + i); 
    }
  }
  
  return max;
}

int main() {

  int arr[] = {25, 78, 49, 45, 63};
  int n = sizeof(arr)/sizeof(arr[0]);
  
  int largest = findLargest(arr, n);
  
  printf("Largest element is: %d", largest);
  
  return 0;
}

// Output
Largest element is: 78

Tricky Question 2: Memory Allocation in C

Navigating Dynamic Memory Allocation in C

Dynamic allocation with malloc()/free() allows flexible memory management. But when used incorrectly, it can lead to bugs.

Question 2.1: Implementing a Custom Memory Allocator

Problem: Write a custom memory allocator my_malloc() to allocate requested memory dynamically.

Question 2.2: Detecting Memory Leaks in C Programs

Problem: Given a C program, identify potential memory leaks caused by incorrect memory management.

Solution and Explanation

// Custom memory allocator

#include <stdio.h>
#include <stdlib.h>

void* my_malloc(size_t size) {
  void* ptr = malloc(size);
  if(!ptr) {
    printf("Memory allocation failed\n");
    return NULL;
  }

  return ptr;
}

int main() {
  
  int* ptr = (int*)my_malloc(sizeof(int));
  
  if(ptr) {
    *ptr = 100;
    printf("Value at ptr = %d", *ptr);
  }

  return 0;
}

// Output
Value at ptr = 100

For question 2.2, examine the code for mismatches between malloc() and free() calls. Also, ensure all allocated memory is freed before program termination to prevent leaks.

Tricky Question 3: Recursion in C

The Depth of Recursion in C

Recursion allows elegant solutions but can also lead to stack overflows if not written carefully.

Question 3.1: Calculating Fibonacci Numbers Efficiently

Problem: Write a recursive C function to calculate the nth Fibonacci number efficiently.

Question 3.2: Implementing a Recursive Binary Search

Problem: Implement a recursive binary search algorithm on a sorted integer array.

Solution and Explanation

// Efficient Fibonacci using recursion

int fib(int n) {
  if (n == 0 || n == 1) {
    return n;
  }

  int a = 0, b = 1, c, i;
  for(i = 2; i <= n; i++) {
   c = a + b;
   a = b;
   b = c;
  }
  
  return b;
}

// Uses iteration to avoid exponential recursion tree of naive solution.

// Recursive binary search

int binarySearch(int arr[], int l, int r, int x) {

  if (r >= l) {
    int mid = l + (r - l) / 2;

    if (arr[mid] == x) {
      return mid;
    }

    if (arr[mid] > x) {
      return binarySearch(arr, l, mid - 1, x);
    }

    return binarySearch(arr, mid + 1, r, x); 
  }

  return -1;
}

// Recursion reduces code complexity compared to iterative solutions.

Recursion elegantly solves problems like Fibonacci and Binary Search. Care must be taken to avoid costly repeated function calls.

Tricky Question 4: Preprocessor Directives in C

Unraveling the Power of Macros

Preprocessor macros enable metaprogramming but can also lead to unexpected outcomes.

Question 4.1: Creating a Custom ASSERT Macro

Problem: Implement a C macro ASSERT() for debugging that prints an error and exits if the condition is false.

Question 4.2: Conditional Compilation with Macros

Problem: Use preprocessor directives for conditional debugging and logging.

Solution and Explanation

// Custom ASSERT macro

#include <stdio.h>

#define ASSERT(condition, err_msg) \
  if(!(condition)) { \
    fprintf(stderr, "Assertion failed: %s\n", err_msg); \
    exit(1); \
  }

int main() {
  int x = 5, y = 10;
  
  ASSERT(x == y, "x is not equal to y");
  
  printf("Code after ASSERT\n"); // Will not print

  return 0;
}

Macros replace code at the preprocessing stage. This allows the implementation of language extensions like ASSERT.

For question 4.2, use #ifdef DEBUG … #endif to conditionally execute debugging/logging code only in debug builds.

Tricky Question 5: if-else Statements in C

Question 5.1: Printing a Name Without Using a Semicolon

Problem: Print your name using if-else statements without ending the statement with a semicolon.

Question 5.2: Predicting the Output of Complex If/Else Statement

Problem: To print numbers from 1 to 100, create a C program. Print “Fizz” instead of the number for multiples of 3 and “Buzz” for multiples of 5. Print “FizzBuzz” for values that are multiples of both 3 and 5.

Solution and Explanation

// Print name without semicolon

#include <stdio.h>

int main() {
  if(1) 
    if(1)
      printf("John");
  else
    printf("Doe");

  return 0;
}

// Nested ifs allow printing without a semicolon.

#include <stdio.h>

int main() {

  for(int i=1; i<=100; i++) {
    
    if(i%3 == 0 && i%5 == 0) {
      printf("FizzBuzz\n");
    }
    else if(i%3 == 0) {
      printf("Fizz\n");
    }
    else if(i%5 == 0) {
      printf("Buzz\n");
    }
    else {
      printf("%d\n", i); 
    }
  }

  return 0;
}

//Output

1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
…
…
Buzz
97
98
Fizz
Buzz

Tricky Question 6: Increment and Decrement Operators in C

Question 6.1: Evaluating Expression x = 5; y = x++ + ++x – –x + x–

Problem: Determine the value of x and y after the given expression.

Question 6.2: Predicting the Output of Complex Increment/Decrement Sequences

Problem: Given the following code snippet, predict the final values of x and y:

int x = 5, y = 10;
x++;
y--;
++x; 
--y;
x++;
y--;

Solution and Explanation

For 6.1, x = 5 originally. Expression is evaluated as:

y = 5 + 7 - 6 + 5 = 11
x = 5

For 6.2, Let’s evaluate the code step-by-step:

Initial values: x = 5, y = 10

x++; // x = 6
y--; // y = 9

++x; // x = 7 (pre-increment)
--y; // y = 8 (pre-decrement)

x++; // x = 8 (post-increment)
y--; // y = 7 (post-decrement)

Therefore, final values after complete execution are:

x = 8
y = 7

The key things to notice are:

Difference between pre and post-increment/decrement
Order in which each statement is executed

Conclusion

Mastering tricky C programming interview questions is a vital skill for acing interviews. This article covered key problem areas like pointers, memory allocation, recursion, data structures, and increment/decrement operators. Analyzing edge cases, understanding nuances, and tracing logical flow are crucial. With rigorous preparation on such questions, you can demonstrate comprehensive C programming knowledge. Practice problems hone the analytical abilities needed for software roles. Strive to write clean, readable code. Mastering core concepts will open up exciting career opportunities.