C Coding Interview Questions and Answers (2025)

C might be one of the oldest programming languages still in use, but it continues to hold a central place in the world of coding interview prep. Why? Because C forces you to think about what’s really happening under the hood. Unlike higher-level languages, it doesn’t hide the details of memory management, pointers, or system-level operations. That’s exactly why companies rely on C interview questions to separate candidates who just “know how to code” from those who understand how computers actually work.

If you’re preparing for a C interview, the right preparation will help you stand out. Employers aren’t only interested in whether you can write working code. They want to see if you can reason through low-level problems, manage memory safely, and use C to solve practical challenges efficiently. That’s what makes C coding interview questions such an effective measure of skill.

So, let’s dive deep into the core C coding interview questions and build the foundation that will help you shine in any technical interview.

Why C Is a Popular Choice in Coding Interviews

When it comes to coding interviews, C is still one of the most frequently tested languages. While newer languages like Python and JavaScript dominate in application development, C continues to play a critical role in systems programming, embedded systems, operating systems, and performance-critical applications.

One reason is low-level control. C gives you direct access to memory through pointers. You can manipulate data at the byte level, allocate memory dynamically, and optimize code to run with maximum efficiency. Another reason is that C provides the foundation for other languages. If you understand C, it’s much easier to pick up C++, Java, or even understand what’s happening under the hood in Python. That’s why interviewers use C questions to test whether you’ve built strong fundamentals.

Finally, many companies still prefer C coding interview questions because they reveal how you think. High-level languages often do too much for you. In C, you’re forced to write out the details, whether it’s handling arrays, pointers, or recursion. That makes it clear whether you truly understand problem-solving at the system level.

Basic C Coding Interview Questions

Before tackling advanced problems, you need to demonstrate that you’ve mastered the basics. Many C coding interview questions begin with these fundamental concepts before advancing to memory and pointers. Let’s look at some common examples.

1. What are the key data types in C?

Explanation:

C provides several built-in data types:

int – for integers.
float and double – for floating-point values.
char – for single characters.
void – for functions that don’t return a value.

Sample Answer:

“In C, the core data types include int, float, double, char, and void. These can be modified with keywords like short, long, signed, or unsigned depending on the required range.”

2. Difference between ++i and i++.

Explanation:

++i (pre-increment) increases the value before it’s used.
i++ (post-increment) increases the value after it’s used.

Sample Answer:

“If i = 5, then ++i makes i = 6 immediately, while i++ uses i = 5 first, then increases it to 6.”

3. Explain typedef and its uses.

Explanation:

The typedef keyword creates an alias for data types. This improves readability, especially for complex declarations.

typedef unsigned int uint;

uint age = 25;

Sample Answer:

“Typedef allows me to create aliases for data types. For example, instead of writing unsigned int, I can use uint as a shorthand.”

4. What is the difference between printf and sprintf?

Explanation:

printf prints output to the console.
sprintf writes output to a string buffer.

char buffer[50];

sprintf(buffer, “Value: %d”, 42); // stores “Value: 42” in buffer

Sample Answer:

“printf displays data on the screen, while sprintf writes the data into a string. I’d use sprintf when I need to format data without printing it directly.”

5. What is the difference between const, volatile, and static keywords?

Explanation:

const – variable value cannot be modified.
volatile – tells the compiler not to optimize the variable (value may change unexpectedly, like hardware registers).
static – preserves variable value between function calls and limits scope to a file.

Sample Answer:

“In C, const ensures immutability, volatile prevents unwanted optimizations, and static controls the scope and lifetime of variables. Each keyword is critical in system-level programming.”

Takeaway: These basics may look simple, but they reveal how well you know the language. Many C coding interview questions begin here because interviewers want to confirm you have a strong foundation before moving on to pointers, memory, and algorithms.

Pointers and Memory Management

If there’s one topic that defines C interviews, it’s pointers. They’re both powerful and tricky, which is why so many C coding interview questions focus on them. Mastering pointers shows interviewers that you understand how memory works and that you can write efficient, low-level code.

1. What is a pointer in C?

A pointer is a variable that stores the address of another variable. Instead of holding a value directly, it points to where the value is stored in memory.

int x = 10;

int *p = &x;   // p holds the address of x

printf(“%d”, *p);  // dereferencing p prints 10

This question tests whether you know how to declare, assign, and dereference pointers.

2. Pointer vs Array

Arrays and pointers are closely related, but not the same:

Array: a fixed block of memory allocated for elements of the same type.
Pointer: a variable holding the address of a memory location.

int arr[3] = {1, 2, 3};

int *p = arr;  // points to arr[0]

printf(“%d”, *(p+1)); // prints 2

Key difference: An array name points to the first element but cannot be reassigned, while a pointer can point anywhere.

3. Null pointer, dangling pointer, wild pointer

Null pointer: points to nothing (int *p = NULL;).
Dangling pointer: points to memory that has been freed.
Wild pointer: uninitialized pointer pointing to a random location.

int *p = NULL;   // safe initialization

Interviewers use these questions to test your awareness of pointer safety.

4. Pointer Arithmetic Examples

You can perform arithmetic on pointers to move between memory locations.

int arr[] = {10, 20, 30};

int *p = arr;

printf(“%d”, *(p+2)); // prints 30

Pointer arithmetic is based on the size of the data type (e.g., p+1 moves by 4 bytes for an int on most systems).

5. Dynamic Memory Allocation

C gives you functions to allocate memory at runtime:

malloc – allocates memory (uninitialized).
calloc – allocates and initializes to zero.
realloc – resizes previously allocated memory.
free – releases allocated memory.

int *arr = (int*)malloc(5 * sizeof(int));

arr = (int*)realloc(arr, 10 * sizeof(int));

free(arr);  // important to avoid leaks

6. Memory Leaks and How to Avoid Them

A memory leak occurs when allocated memory is never freed. Over time, this reduces available memory.

Best practices:

Always call free() when memory is no longer needed.
Initialize pointers to NULL after freeing.
Use tools like Valgrind (if allowed) to detect leaks.

Takeaway: Pointers are central to C because they give you direct control over memory. Many C coding interview questions in this area test your ability to use pointers safely while avoiding common pitfalls like memory leaks and dangling references.

Arrays and Strings in C Coding Interview Questions

Arrays and strings are another favorite topic in interviews. They test whether you can manipulate memory, loop efficiently, and solve problems without relying on built-in libraries.

1. Reverse an array in place

void reverse(int arr[], int n) {

    int start = 0, end = n – 1;

    while (start < end) {

        int temp = arr[start];

        arr[start] = arr[end];

        arr[end] = temp;

        start++; end--;

    }

}

This question checks if you can handle in-place operations without extra memory.

2. Find the largest element in an array

int findMax(int arr[], int n) {

    int max = arr[0];

    for (int i = 1; i < n; i++) {

        if (arr[i] > max) max = arr[i];

    }

    return max;

}

Simple but useful for testing basic looping and comparisons.

3. Matrix multiplication

void multiply(int A[2][2], int B[2][2], int C[2][2]) {

    for (int i=0; i<2; i++) {

        for (int j=0; j<2; j++) {

            C[i][j] = 0;

            for (int k=0; k<2; k++) {

                C[i][j] += A[i][k] * B[k][j];

            }

        }

    }

}

Tests nested loops and the ability to manage indices.

4. Check if a string is a palindrome

int isPalindrome(char str[]) {

    int start = 0, end = strlen(str)-1;

    while (start < end) {

        if (str[start] != str[end]) return 0;

        start++; end--;

    }

    return 1;

}

5. Implement strlen, strcpy, strcmp manually

int my_strlen(char *s) {

    int len = 0;

    while (*s++) len++;

    return len;

}

void my_strcpy(char *dest, char *src) {

    while (*src) *dest++ = *src++;

    *dest = ‘\0’;

}

int my_strcmp(char *s1, char *s2) {

    while (*s1 && (*s1 == *s2)) { s1++; s2++; }

    return *(unsigned char*)s1 – *(unsigned char*)s2;

}

These are classic C coding interview questions to test whether you understand string handling without standard libraries.

6. Find the first non-repeating character in a string

char firstNonRepeating(char *s) {

    int count[256] = {0};

    for (int i=0; s[i]; i++) count[(unsigned char)s[i]]++;

    for (int i=0; s[i]; i++) if (count[(unsigned char)s[i]] == 1) return s[i];

    return ‘\0’;

}

Takeaway: Array and string manipulation questions prove your ability to work with raw memory and loops. Interviewers use them to check problem-solving skills under constraints.

Structures, Unions, and Enums

C isn’t just about arrays and pointers. Structures, unions, and enums let you model real-world problems. Interviewers love these questions because they show how you organize and optimize data.

1. Difference between structures and unions

Structure: all members have separate memory locations.
Union: all members share the same memory, using the largest member’s size.

struct Student {

    int id;

    char name[20];

    float gpa;

};

union Data {

    int i;

    float f;

    char str[20];

};

Structures are great for records; unions are memory-efficient when you only need one member at a time.

2. When to use enums

An enum assigns names to integer constants, improving readability.

enum Days { MON, TUE, WED, THU, FRI };

enum Days today = WED;

Enums are useful for representing fixed sets of values (days, states, error codes).

3. Memory layout of structures

Interviewers may ask about padding. Compilers align structure members to memory boundaries, which can waste space.

struct Example {

    char a;   // 1 byte + 3 bytes padding

    int b;    // 4 bytes

};

This ensures faster access but may use more memory.

4. Example: Design a student record system

struct Student {

    int id;

    char name[50];

    float gpa;

};

void printStudent(struct Student s) {

    printf(“ID: %d, Name: %s, GPA: %.2f\n”, s.id, s.name, s.gpa);

}

This models real-world data and shows how to organize information with structures.

Takeaway: Understanding structures, unions, and enums helps you write C programs that are not just functional but also efficient and well-organized. These are common in C coding interview questions because they mimic how data is managed in actual applications.

Functions and Recursion

Functions in C allow you to break down programs into smaller, reusable pieces. In interviews, functions are often combined with recursion to test both your logical reasoning and understanding of scope.

Function declarations and scope

A function declaration tells the compiler about a function’s name, return type, and parameters. A function definition provides the actual implementation.

int add(int a, int b);  // declaration

int add(int a, int b) { // definition

    return a + b;

}

Scope:

Local variables: declared inside functions, destroyed when the function ends.
Global variables: declared outside functions, accessible anywhere in the file.
Static variables: preserve value between function calls.

1. Difference between call by value and call by reference

Call by value: A copy of the variable is passed. Changes don’t affect the original.
Call by reference: The variable’s address is passed using pointers. Changes affect the original.

// Call by value

void changeValue(int x) { x = 20; }

// Call by reference

void changeRef(int *x) { *x = 20; }

Interviewers love this question because it reveals whether you understand how memory is shared.

2. Implement factorial with recursion

// Call by value

void changeValue(int x) { x = 20; }

// Call by reference

void changeRef(int *x) { *x = 20; }

This checks your ability to apply recursion to mathematical problems.

3. Implement Fibonacci sequence (iterative vs recursive)

// Recursive

int fib_recursive(int n) {

    if (n <= 1) return n;

    return fib_recursive(n-1) + fib_recursive(n-2);

}

// Iterative

int fib_iterative(int n) {

    int a=0, b=1, c;

    for (int i=2; i<=n; i++) {

        c = a+b; a = b; b = c;

    }

    return b;

}

Recursive Fibonacci demonstrates understanding of recursion, but is inefficient (O(2^n)), while the iterative is O(n). Explaining this tradeoff earns you points.

4. Use function pointers for callback implementation

#include <stdio.h>

void greet() { printf(“Hello!\n”); }

void execute(void (*func)()) { func(); }

int main() {

    execute(greet);  // passes function as argument

    return 0;

}

Function pointers are commonly used in callbacks and system-level design.

Takeaway: Interviewers use these C coding interview questions to test not just whether you can write functions, but whether you understand scope, recursion, and pointers in function calls.

Algorithmic C Coding Interview Questions

Algorithm problems are central to interviews. When asked in C, they show both your algorithmic thinking and your ability to work with raw memory and data structures.

1. Two-sum problem (hashmap in C)

Problem: Find two indices whose elements add up to a target.

Solution: Use a hashmap (implemented with arrays).

#include <stdio.h>

#include <stdlib.h>

int* twoSum(int* nums, int numsSize, int target, int* returnSize){

    for(int i=0;i<numsSize;i++){

        for(int j=i+1;j<numsSize;j++){

            if(nums[i]+nums[j]==target){

                int *res = (int*)malloc(2*sizeof(int));

                res[0]=i; res[1]=j;

                *returnSize=2;

                return res;

            }

        }

    }

    *returnSize=0;

    return NULL;

}

Time complexity: \( O(n^2) \) for brute force. Optimized solutions use hash tables but require extra code.
Interview tip: explain both approaches.

2. Merge two sorted arrays

void merge(int arr1[], int n1, int arr2[], int n2, int result[]) {

    int i=0,j=0,k=0;

    while(i<n1 && j<n2){

        if(arr1[i]<arr2[j]) result[k++]=arr1[i++];

        else result[k++]=arr2[j++];

    }

    while(i<n1) result[k++]=arr1[i++];

    while(j<n2) result[k++]=arr2[j++];

}

Time complexity: \( O(n+m) \).
Tests your ability to handle sorted data efficiently.

3. Binary search implementation

int binarySearch(int arr[], int n, int target){

    int left=0,right=n-1;

    while(left<=right){

        int mid=(left+right)/2;

        if(arr[mid]==target) return mid;

        else if(arr[mid]<target) left=mid+1;

        else right=mid-1;

    }

    return -1;

}

Time complexity: \( O(log n) \).
A staple in C coding interview questions.

4. DFS and BFS using adjacency list

#include <stdio.h>

#include <stdlib.h>

#define N 5

void dfs(int graph[N][N], int visited[N], int node){

    visited[node]=1;

    printf(“%d “,node);

    for(int i=0;i<N;i++){

        if(graph[node][i] && !visited[i]) dfs(graph,visited,i);

    }

}

void bfs(int graph[N][N], int start){

    int queue[N], front=0,rear=0;

    int visited[N]={0};

    queue[rear++]=start; visited[start]=1;

    while(front<rear){

        int node=queue[front++];

        printf("%d ",node);

        for(int i=0;i<N;i++){

            if(graph[node][i] && !visited[i]){

                visited[i]=1;

                queue[rear++]=i;

            }

        }

    }

}

DFS uses recursion, and BFS uses a queue, so knowing both is essential.

5. Dynamic programming: Longest Common Subsequence (LCS)

int max(int a,int b){ return a>b?a:b; }

int lcs(char* X, char* Y, int m, int n){

    int dp[m+1][n+1];

    for(int i=0;i<=m;i++){

        for(int j=0;j<=n;j++){

            if(i==0||j==0) dp[i][j]=0;

            else if(X[i-1]==Y[j-1]) dp[i][j]=1+dp[i-1][j-1];

            else dp[i][j]=max(dp[i-1][j],dp[i][j-1]);

        }

    }

    return dp[m][n];

}

Time complexity: \( O(m \times n) \).
Demonstrates problem-solving with dynamic programming, a high-value skill in interviews.

Takeaway: Algorithm questions are the core test of problem-solving skills. By practicing these C coding interview questions, you’ll be ready to show not just your coding, but also your ability to optimize and analyze complexity.

Advanced C Coding Interview Questions

At senior levels, interviews go beyond basics. These advanced C coding interview questions are common in system programming interviews because they test your knowledge of memory, performance, and optimization.

1. Bitwise operators and applications

Check even/odd: if (x & 1) odd else even.
Swap two numbers without temp:

a = a ^ b;

b = a ^ b;

a = a ^ b;

Set, clear, toggle bits: |, &, ^ operators.

2. Memory alignment and padding

Compilers align structure members to word boundaries for efficiency.

struct Example {

    char a;   // 1 byte + 3 bytes padding

    int b;    // 4 bytes

};

Understanding this helps with system-level optimization.

3. How to detect memory leaks in C

Always free() dynamically allocated memory.
Set pointers to NULL after freeing.
Use debugging tools (like Valgrind) when available.

Interviewers test if you know not just how to allocate, but also how to clean up safely.

4. Difference between stack and heap

Stack: memory allocated automatically (local variables). Fast but limited in size.
Heap: memory allocated dynamically (malloc, calloc). Larger but requires manual management.

Sample Answer:

“The stack is faster but limited, while the heap is flexible but requires careful management to avoid leaks and fragmentation.”

Takeaway: These advanced C coding interview questions check whether you can handle low-level challenges. Mastering them shows interviewers you’re ready for system programming or embedded engineering roles.

Practice Section: Mock C Coding Interview Questions

To really prepare for interviews, you need practice with full-length problems. These examples are presented the way you’d see them in an interview: question → thought process → answer.

1. Design an LRU Cache in C

Question: Implement a Least Recently Used (LRU) cache with get and put methods.

Thought Process:

Use a doubly linked list to store elements in order of use.
Use a hash map for \( O(1) \) access to nodes.
When capacity is full, remove the least recently used node from the list.

Answer (simplified):

// Simplified approach using array + counters for interviews

#define CAPACITY 3

int cache[CAPACITY];

int usage[CAPACITY];

int get(int key) {

    for (int i=0; i<CAPACITY; i++) {

        if (cache[i]==key) { usage[i]=1; return key; }

    }

    return -1;

}

In a real interview, you’d discuss the data structures more than writing out the full implementation.

2. Implement linked list operations

Question: Write functions to insert, delete, and reverse a linked list.

Thought Process:

Linked lists test pointer manipulation.
Must handle edge cases like empty list or deleting head node.

Answer (reverse example):

struct Node { int data; struct Node* next; };

struct Node* reverse(struct Node* head) {

    struct Node *prev=NULL, *curr=head, *next=NULL;

    while(curr) {

        next=curr->next;

        curr->next=prev;

        prev=curr;

        curr=next;

    }

    return prev;

}

3. Check if a binary tree is balanced

Question: A tree is balanced if height difference between left and right subtrees is ≤1.

Thought Process:

Use recursion to check heights of subtrees.
Return -1 immediately if unbalanced.

Answer:

int height(struct Node* root) {

    if(!root) return 0;

    int lh=height(root->left), rh=height(root->right);

    if(lh==-1 || rh==-1 || abs(lh-rh)>1) return -1;

    return (lh>rh?lh:rh)+1;

}

4. Implement producer-consumer problem using semaphores

Question: Synchronize producer and consumer threads with semaphores.

Thought Process:

Use two semaphores: empty and full.
Ensure producer waits when buffer is full, consumer waits when buffer is empty.

Answer (conceptual snippet):

sem_t empty, full, mutex;

sem_init(&empty,0,N);

sem_init(&full,0,0);

Producer:

sem_wait(&empty); sem_wait(&mutex);

  // produce item

  sem_post(&mutex); sem_post(&full);

Consumer:

sem_wait(&full); sem_wait(&mutex);

  // consume item

  sem_post(&mutex); sem_post(&empty);

5. Implement string tokenizer (strtok)

Question: Break a string into tokens based on a delimiter.

Thought Process:

Maintain a static pointer to track next token.
Replace delimiters with \0.

Answer (simplified):

char* my_strtok(char* str, const char* delim) {

    static char* next;

    if(str) next = str;

    if(!next) return NULL;

    char* start = next;

    while(*next && *next!=*delim) next++;

    if(*next) *next++ = ‘\0’;

    return start;

}

Takeaway: Working through problems like these helps you simulate the real interview process. These C coding interview questions test your ability to apply fundamentals in practical ways.

Tips for Solving C Coding Interview Questions

When it comes to interviews, how you approach problems is just as important as solving them. Keep these tips in mind:

Keep code clean and readable
Use indentation and comments. Readability matters more than flashy tricks.
Explain time and space complexity
Even if the solution works, you need to say “This runs in \( O(n) \) time and \( O(1) \) space”. It shows you understand efficiency.
Use meaningful variable names
Names like count or node are clearer than x or tmp. Clarity is valued in interviews.
Avoid common pitfalls
- Watch out for buffer overflows in arrays.
- Prevent dangling pointers by setting freed pointers to NULL.
- Always free dynamically allocated memory to avoid leaks.
Practice writing code without IDEs
Many interviews don’t allow autocomplete or debugging tools. Write code in a plain editor or even on paper.
Talk through your reasoning
Interviewers want to see how you think. Explaining your logic step-by-step shows confidence and helps them follow your process.

These strategies will make solving C coding interview questions much less stressful.

Wrapping Up

C interviews can be tough, but they’re also a great opportunity to showcase your skills. By now, you’ve explored everything from basic syntax to advanced system-level problems. You’ve also worked through practice problems that mirror what you’ll see in a real interview.

Consistent practice is the secret. Don’t just read solutions—type them out, debug them, and explain them as if you’re in an interview. Build small projects in C to apply what you’ve learned. The more hands-on practice you get, the more natural these problems will feel.

Your preparation today is the foundation for tomorrow’s success. Start solving more C coding interview questions now and step confidently into your next interview.

C Coding Interview Questions and Answers (2025)

Why C Is a Popular Choice in Coding Interviews

Basic C Coding Interview Questions

1. What are the key data types in C?

2. Difference between ++i and i++.

3. Explain typedef and its uses.

4. What is the difference between printf and sprintf?

5. What is the difference between const, volatile, and static keywords?

Pointers and Memory Management

1. What is a pointer in C?

2. Pointer vs Array

3. Null pointer, dangling pointer, wild pointer

4. Pointer Arithmetic Examples

5. Dynamic Memory Allocation

6. Memory Leaks and How to Avoid Them

Arrays and Strings in C Coding Interview Questions

1. Reverse an array in place

2. Find the largest element in an array

3. Matrix multiplication

4. Check if a string is a palindrome

5. Implement strlen, strcpy, strcmp manually

6. Find the first non-repeating character in a string

Structures, Unions, and Enums

1. Difference between structures and unions

2. When to use enums

3. Memory layout of structures

4. Example: Design a student record system

Functions and Recursion

Function declarations and scope

1. Difference between call by value and call by reference

2. Implement factorial with recursion

3. Implement Fibonacci sequence (iterative vs recursive)

4. Use function pointers for callback implementation

Algorithmic C Coding Interview Questions

1. Two-sum problem (hashmap in C)

2. Merge two sorted arrays

3. Binary search implementation

4. DFS and BFS using adjacency list

5. Dynamic programming: Longest Common Subsequence (LCS)

Advanced C Coding Interview Questions

1. Bitwise operators and applications

2. Memory alignment and padding

3. How to detect memory leaks in C

4. Difference between stack and heap

Practice Section: Mock C Coding Interview Questions

1. Design an LRU Cache in C

2. Implement linked list operations

3. Check if a binary tree is balanced

4. Implement producer-consumer problem using semaphores

5. Implement string tokenizer (strtok)

Tips for Solving C Coding Interview Questions

Wrapping Up

Related Guides

Leave a Reply Cancel reply