C-DAC Coding Round Questions 2026 with Solutions

Introduction

The Centre for Development of Advanced Computing (C-DAC) is India's premier government R&D organization in advanced computing, operating under the Ministry of Electronics and Information Technology. C-DAC recruits software engineers, project engineers, and research associates through a structured selection process that includes an aptitude test followed by a dedicated coding/programming round. Unlike private sector companies that often use off-the-shelf assessments, C-DAC's coding round reflects its core identity as a systems programming organization, problems lean toward foundational data structures, algorithmic thinking, and low-level programming concepts.

C-DAC's recruitment is conducted across multiple centers: Pune (headquarters), Bengaluru, Chennai, Hyderabad, Thiruvananthapuram, Kolkata, Noida, and Mumbai. The organization recruits for roles in supercomputing, cybersecurity, embedded systems, software development, and AI/ML research. Depending on the specific division and role, the coding test may be administered through HackerEarth, HackerRank, or a C-DAC-internal assessment portal. The experience is consistent: 60–90 minutes, 2–3 coding problems, Easy to Medium difficulty (LeetCode equivalent), with emphasis on correctness over optimization.

What makes C-DAC's coding round distinctive is its strong preference for C and C++ solutions. The organization's roots are in high-performance computing and systems software, PARAM supercomputers, BOSS Linux, CDOT's telecom software, and its interviewers genuinely value candidates who are comfortable with pointer-based memory manipulation, manual memory management, and low-level data structure implementations. A correct Python solution gets full marks, but a clean pointer-based C implementation earns admiration and makes the subsequent technical interview significantly easier. This guide focuses on C/C++ solutions with full explanations.

C-DAC Exam Pattern 2026

C-DAC's selection process typically spans three stages: an online aptitude test, a coding test, and a technical interview. Depending on the role type (Project Engineer vs. Research Associate), the weightage of each component changes. The coding round described here applies primarily to Project Engineer and Software Developer roles.

Scoring is typically all-or-nothing per test case, partial credit varies by platform. HackerEarth tests usually award partial marks for test cases passed. C-DAC does not publish official cutoffs, but candidate reports suggest clearing 2 of 3 problems with correct output is sufficient to advance to the technical interview.

Quantitative Aptitude Questions

C-DAC's aptitude test (separate from the coding round) covers standard areas. These questions appear in the written test that precedes the coding round.

Q1. If a train 240 meters long passes a pole in 12 seconds, what is its speed in km/h?

Explanation: Speed = Distance / Time = 240 / 12 = 20 m/s. Convert to km/h: 20 × (18/5) = 72 km/h. Standard speed-distance-time conversion, appears frequently in C-DAC aptitude sections.

Q2. A pipe fills a tank in 6 hours. Another pipe drains it in 9 hours. If both are open simultaneously, how long to fill the tank?

Explanation: Fill rate = 1/6 per hour. Drain rate = 1/9 per hour. Net rate = 1/6 – 1/9 = 3/18 – 2/18 = 1/18 per hour. Time to fill = 18 hours.

Q3. What is 15% of 25% of 400?

Explanation: 25% of 400 = 100. 15% of 100 = 15.

Q4. In a class of 50 students, 30 play cricket, 25 play football, and 10 play both. How many play neither?

Explanation: Play at least one sport = 30 + 25 – 10 = 45. Neither = 50 – 45 = 5. Set theory union formula.

Q5. A number when divided by 6 gives remainder 3. What is the remainder when the square of the number is divided by 6?

Explanation: Number = 6k + 3. Squared: (6k+3)² = 36k² + 36k + 9. Divided by 6: remainder from 9/6 = 3. Algebraic remainder property.

Verbal Ability Questions

Q1. Choose the correct sentence: (a) "The team have won the match" (b) "The team has won the match"

Q2. Antonym of "Meticulous": (a) Careless (b) Detailed (c) Precise (d) Thorough

Q3. Fill in the blank: "The project was completed _____ schedule." (a) on (b) in (c) at (d) by

Q4. Identify the error: "Neither the manager nor the employees was present at the meeting."

Technical Questions (Computer Science Fundamentals)

These questions appear in the technical interview following the coding round and are directly connected to the type of code C-DAC evaluates.

Q1. What is the difference between malloc and calloc in C?

Q2. What is a dangling pointer? Give an example in C.

int *p = (int *)malloc(sizeof(int));
*p = 42;
free(p);
// p is now a dangling pointer, dereferencing it is undefined behavior
printf("%d", *p); // WRONG, undefined behavior
p = NULL; // Fix: set to NULL after freeing

Q3. Explain the difference between a stack and a queue. Where does the OS use each?

Q4. What is the time complexity of binary search and why?

Q5. What is the difference between a process and a thread in operating systems?

Coding Round Questions, Fully Solved in C/C++

Problem 1: Array Reversal (Easy)

Reverse an array of n integers in-place without using extra memory.

#include <stdio.h>

void reverseArray(int arr[], int n) {
    int left = 0, right = n - 1;
    while (left < right) {
        // Swap using XOR, avoids temp variable (pointer-friendly trick)
        arr[left] ^= arr[right];
        arr[right] ^= arr[left];
        arr[left] ^= arr[right];
        left++;
        right--;
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = 5;
    
    printf("Original: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    
    reverseArray(arr, n);
    
    printf("\nReversed: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
    
    return 0;
}

Output: Original: 1 2 3 4 5 | Reversed: 5 4 3 2 1

Time Complexity: O(n), single pass with two pointers converging Space Complexity: O(1), in-place, no extra array needed

C-DAC Note: Using XOR swap instead of a temp variable is a common pointer/bit manipulation technique that C-DAC interviewers appreciate. It demonstrates familiarity with low-level programming idioms.

Problem 2: Palindrome Check for String (Easy-Medium)

Check whether a given string is a palindrome, ignoring case and non-alphanumeric characters.

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdbool.h>

bool isPalindrome(char *s) {
    int left = 0;
    int right = strlen(s) - 1;
    
    while (left < right) {
        // Skip non-alphanumeric characters from both ends
        while (left < right && !isalnum(s[left])) left++;
        while (left < right && !isalnum(s[right])) right--;
        
        // Compare case-insensitively
        if (tolower(s[left]) != tolower(s[right])) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

int main() {
    char s1[] = "A man a plan a canal Panama";
    char s2[] = "race a car";
    char s3[] = "MadaM";
    
    printf("\"%s\" -> %s\n", s1, isPalindrome(s1) ? "Palindrome" : "Not Palindrome");
    printf("\"%s\" -> %s\n", s2, isPalindrome(s2) ? "Palindrome" : "Not Palindrome");
    printf("\"%s\" -> %s\n", s3, isPalindrome(s3) ? "Palindrome" : "Not Palindrome");
    
    return 0;
}

Output: "A man a plan a canal Panama" -> Palindrome "race a car" -> Not Palindrome "MadaM" -> Palindrome

Time Complexity: O(n), single pass through the string Space Complexity: O(1), operates on the input string directly

C-DAC Note: Using the standard library functions isalnum() and tolower() from ctype.h demonstrates knowledge of C's standard library, a sign of practical C experience that C-DAC values.

Problem 3: Linked List Cycle Detection (Medium)

Detect whether a singly linked list contains a cycle using Floyd's Tortoise and Hare algorithm.

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

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

// Create a new node
struct Node* newNode(int val) {
    struct Node *node = (struct Node *)malloc(sizeof(struct Node));
    node->data = val;
    node->next = NULL;
    return node;
}

// Floyd's cycle detection algorithm
bool hasCycle(struct Node *head) {
    if (head == NULL || head->next == NULL) return false;
    
    struct Node *slow = head;  // moves 1 step at a time
    struct Node *fast = head;  // moves 2 steps at a time
    
    while (fast != NULL && fast->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        
        if (slow == fast) return true;  // cycle detected
    }
    return false;
}

int main() {
    // Build list: 1 -> 2 -> 3 -> 4 -> 5
    struct Node *head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->next->next->next = newNode(5);
    
    printf("No cycle: %s\n", hasCycle(head) ? "Cycle found" : "No cycle");
    
    // Create cycle: node 5 points back to node 3
    head->next->next->next->next->next = head->next->next;
    
    printf("With cycle: %s\n", hasCycle(head) ? "Cycle found" : "No cycle");
    
    // Note: free() skipped here since cycle makes traversal infinite
    return 0;
}

Output: No cycle: No cycle With cycle: Cycle found

Time Complexity: O(n), in the worst case, fast pointer traverses at most 2n steps before meeting slow pointer Space Complexity: O(1), only two pointer variables, no extra data structure

Algorithm Explanation: The slow pointer moves one node per step; the fast pointer moves two. If a cycle exists, the fast pointer will eventually lap the slow pointer inside the cycle. If no cycle, the fast pointer reaches NULL. This is significantly more memory-efficient than the HashSet approach (O(n) space) which stores visited nodes.

C-DAC Note: Floyd's algorithm is a pointer-manipulation technique that exemplifies low-level algorithmic elegance. This is exactly the type of solution C-DAC interviewers ask candidates to implement from memory and then explain.

Problem 4: Bubble Sort with Optimization (Medium)

Implement an optimized bubble sort that stops early if the array becomes sorted before all passes complete.

#include <stdio.h>
#include <stdbool.h>

void bubbleSort(int arr[], int n) {
    bool swapped;
    
    for (int i = 0; i < n - 1; i++) {
        swapped = false;
        
        // Last i elements are already in place
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // Swap
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swapped = true;
            }
        }
        
        // If no swap occurred in this pass, array is sorted
        if (!swapped) {
            printf("Early termination at pass %d\n", i + 1);
            break;
        }
    }
}

void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    printf("\n");
}

int main() {
    int arr1[] = {64, 34, 25, 12, 22, 11, 90};
    int n1 = 7;
    printf("Before sort: "); printArray(arr1, n1);
    bubbleSort(arr1, n1);
    printf("After sort:  "); printArray(arr1, n1);
    
    printf("\n");
    
    // Nearly sorted array, shows early termination benefit
    int arr2[] = {1, 2, 3, 5, 4};
    int n2 = 5;
    printf("Before sort: "); printArray(arr2, n2);
    bubbleSort(arr2, n2);
    printf("After sort:  "); printArray(arr2, n2);
    
    return 0;
}

Output: Before sort: 64 34 25 12 22 11 90 After sort: 11 12 22 25 34 64 90

Before sort: 1 2 3 5 4 Early termination at pass 2 After sort: 1 2 3 4 5

Time Complexity: O(n²) worst case, O(n) best case (already sorted, only one pass needed with optimization) Space Complexity: O(1), in-place sort

C-DAC Note: The naive bubble sort without early termination is O(n²) even for sorted arrays. The swapped flag optimization makes it O(n) for best case. C-DAC interviewers consistently ask about best/worst/average case complexity, knowing these for all common sorts is essential.

Problem 5: Fibonacci with Memoization (Dynamic Programming, Medium)

Compute the nth Fibonacci number using top-down dynamic programming (memoization). Compare with naive recursion to show the improvement.

#include <stdio.h>
#include <string.h>

#define MAX_N 100
long long memo[MAX_N];  // memoization table

// Initialize memo table to -1 (uncomputed)
void initMemo() {
    memset(memo, -1, sizeof(memo));
}

// Memoized Fibonacci, O(n) time, O(n) space
long long fib_memo(int n) {
    if (n <= 1) return n;
    if (memo[n] != -1) return memo[n];  // return cached result
    
    memo[n] = fib_memo(n - 1) + fib_memo(n - 2);
    return memo[n];
}

// Iterative Fibonacci, O(n) time, O(1) space (most efficient)
long long fib_iterative(int n) {
    if (n <= 1) return n;
    
    long long prev2 = 0, prev1 = 1, current;
    for (int i = 2; i <= n; i++) {
        current = prev1 + prev2;
        prev2 = prev1;
        prev1 = current;
    }
    return prev1;
}

// Naive recursive Fibonacci, DO NOT USE for large n (exponential)
long long fib_naive(int n) {
    if (n <= 1) return n;
    return fib_naive(n - 1) + fib_naive(n - 2);
}

int main() {
    initMemo();
    
    printf("Fibonacci numbers (memoized):\n");
    for (int i = 0; i <= 15; i++) {
        printf("fib(%2d) = %lld\n", i, fib_memo(i));
    }
    
    printf("\nLarge values (iterative):\n");
    printf("fib(40) = %lld\n", fib_iterative(40));
    printf("fib(50) = %lld\n", fib_iterative(50));
    printf("fib(60) = %lld\n", fib_iterative(60));
    
    return 0;
}

Output: fib(0) = 0, fib(1) = 1, fib(2) = 1, fib(3) = 2, ..., fib(15) = 610 fib(40) = 102334155 fib(50) = 12586269025 fib(60) = 1548008755920

Complexity Comparison:

C-DAC Note: C-DAC interviewers specifically ask candidates to demonstrate understanding of DP optimization. The progression naive → memoized → iterative shows algorithmic maturity. Being able to explain why memoization eliminates redundant computation (overlapping subproblems) is as important as writing the code.

Interview Process at C-DAC

• Online Application: C-DAC posts recruitment drives on its official website (cdac.in) and on the National Career Service Portal. Applications are role-specific, apply to the center and domain of interest.
• Written Aptitude Test: 90-minute multiple-choice test covering quantitative reasoning, logical reasoning, English language, and domain-specific questions (CS/IT fundamentals for software roles). Typically 100 questions.
• Coding Test: 60–90 minutes, 2–3 problems on HackerEarth or similar. Focus on correctness, all test cases must pass. Partial credit where available.
• Technical Interview (Round 1): 30–45 minutes. Deep dive into C/C++ programming, data structures (linked lists, trees, stacks), OS concepts (process management, memory), and the candidate's coding test solutions. Expect to explain your code line by line.
• Technical Interview (Round 2, for senior roles): System design, advanced algorithms, domain-specific questions (embedded systems, networking, security depending on the C-DAC division).
• HR Interview: Standard background, motivation, and compensation discussion. C-DAC being a government-funded organization has structured pay bands, negotiation is limited compared to private sector.
• Document Verification and Offer: C-DAC verifies educational credentials carefully. Joining timelines are typically 4–8 weeks after offer.

Tips to Crack C-DAC Interview

• Master C before Python for this recruitment: C-DAC's culture is deeply rooted in systems programming. Even if you solve problems in Python during the test, implement them in C during interviews. Comfort with pointers, structs, and manual memory management signals the right profile.
• Know the standard C library deeply: <string.h>, <stdlib.h>, <ctype.h>, <math.h>, know what's in each and when to use it. C-DAC interviewers ask about memset, strcpy, strcat, strtok and their edge cases.
• Practice implementing data structures from scratch: Linked lists with insert/delete/search, stacks using arrays and linked lists, queues, binary trees with traversals. C-DAC interviewers frequently ask for pointer-based implementations, not STL.
• Review OS concepts thoroughly: Process states, scheduling algorithms (FCFS, SJF, Round Robin), memory management (paging, segmentation, virtual memory), deadlock conditions (Coffman conditions). These appear in C-DAC technical interviews more often than algorithm-heavy questions.
• Time management in the coding test is critical: Read all problems first, solve the easiest one completely, then tackle harder ones. A complete solution to one medium problem is worth more than partial solutions to all three.
• Understand C-DAC's work context: C-DAC builds PARAM supercomputers, BOSS (GNU/Linux distribution), GIST (language technology), and works on national cybersecurity. If you can reference their projects in your interview, it signals genuine interest.
• Practice HackerEarth's platform specifically: C-DAC frequently uses HackerEarth. Familiarize yourself with its input/output format, scanf/printf in C, and handling multiple test cases in a loop from stdin.
• Government sector interview etiquette matters: C-DAC interviews are formal. Dress professionally, address interviewers as "Sir/Ma'am," and be prepared to explain your academic and project background in detail.
• Debug code on paper: C-DAC interviewers may ask you to trace code on a whiteboard without a compiler. Practice dry-running your C programs manually, tracking variable values, pointer addresses, and loop iterations step by step.

Common HR Interview Questions

Q1. Why C-DAC over private sector IT companies?

Sample Answer: C-DAC works on problems that most private companies don't, building a supercomputer that enables Indian scientific research, developing indigenous language technology, securing critical national infrastructure. The scale of societal impact is unique. I also want deep technical expertise in systems software, and C-DAC's environment offers that better than service-oriented roles at large IT firms.

Q2. Tell us about a project you are most proud of.

Sample Answer: I built a real-time file system monitoring tool in C as my final year project. It used inotify (Linux kernel API) to watch directory changes and log them with timestamps. The challenge was handling race conditions when multiple processes wrote to the same directory simultaneously. I learned to use mutex locks and designed a producer-consumer architecture with a circular buffer. The tool successfully monitored 50+ concurrent directory paths with under 2ms latency.

Q3. What is your understanding of C-DAC's role in India's technology ecosystem?

Sample Answer: C-DAC is India's answer to the question of technological sovereignty. PARAM supercomputers put India in the global HPC map. BOSS Linux provides a secure, government-controlled OS alternative. The Language Technology group enables computing in 22 scheduled languages, that's digital inclusion at a scale no private company has an incentive to pursue. C-DAC essentially does what the market won't.

Q4. How comfortable are you with relocation to a C-DAC center city?

Sample Answer: Fully comfortable. I researched C-DAC's center locations and I'm particularly interested in the Pune center's Advanced Computing Training School (ACTS) environment and the Bengaluru center's embedded systems work. Relocation is not a constraint for me.

Q5. What are your salary expectations?

Sample Answer: I'm aware that C-DAC follows government pay scales (typically 7th Pay Commission for regular employees or a fixed consolidated salary for contract/project-based roles). My expectation is within the standard band for this position, I'm more focused on the technical depth and mission alignment of the role than on maximizing immediate compensation.

Salary Package Information

The figures below are candidate-reported and indicative only. C-DAC roles follow government pay structures (7th Pay Commission bands for regular posts, consolidated pay for project and contract posts), which change by recruitment cycle. Always confirm the exact pay against the specific role's official C-DAC recruitment notification.

Additional Benefits: Government holiday calendar, job security for permanent positions, access to C-DAC's Advanced Computing Training School (ACTS) certifications, opportunity to work on nationally significant projects, exposure to HPC/supercomputing environments not available in private sector.

Preparation Strategy

Weeks 1–2, C Programming Deep Dive If you've been primarily coding in Python or Java, dedicate these weeks to C. Implement: array operations, string manipulation, pointer arithmetic, linked list (singly and doubly), stack and queue using arrays and pointers. Every implementation should be in pure C without STL. Use GeeksforGeeks' C programming section and K&R "The C Programming Language" as references.

Weeks 3–4, Data Structures and Algorithms in C Implement binary search, bubble/insertion/selection/merge sort, binary tree traversals (all four), hash table with chaining (using linked lists). Practice on HackerEarth with C as your selected language. Time yourself, aim for 20 minutes per Easy problem, 35 minutes per Medium problem.

Weeks 5–6, Operating Systems and Computer Networks Review OS: process scheduling (FCFS, SJF, Priority, Round Robin), memory management, file systems, deadlock. Review networks: OSI model, TCP/IP, DNS, HTTP, socket programming basics in C. C-DAC technical interviews draw heavily from these topics.

Week 7, Aptitude Test Preparation Use Arun Sharma or R.S. Aggarwal for quantitative aptitude. Practice verbal ability with previous year C-DAC question papers (available on Testbook, IndiaBIX). C-DAC's aptitude test is similar in difficulty to IBPS PO, thorough but not exceptionally difficult with 2–3 weeks of focused practice.

Week 8, Mock Tests and Interview Simulation Attempt 3 full-length mock coding tests on HackerEarth in C. Practice explaining your code solutions verbally, C-DAC interviewers will ask you to walk through your logic. Review C-DAC's published research and product portfolio to prepare genuine answers for motivation questions.

Conclusion

C-DAC's coding round is an accessible but meaningful filter. It is not designed to stump candidates with algorithmic wizardry, it is designed to identify engineers who can write correct, clean, efficient code in systems-level languages and explain their reasoning clearly. The organization values craft over cleverness, reliability over novelty.

The candidates who perform best in C-DAC's technical process are those with a genuine command of C fundamentals, not just the ability to write code that runs, but the understanding of why it runs, what happens at the memory level, and how to debug it when it doesn't. That depth of understanding is what C-DAC builds into its products, and it is what the organization looks for in the people who will build them.

For candidates motivated by working on systems that matter, supercomputers that enable cancer research, language tools that bring computing to rural India, cybersecurity infrastructure that protects national digital assets, C-DAC is a uniquely rewarding technical career path. The preparation investment is well worth it.

This article is part of PapersAdda's comprehensive placement preparation series. For more government tech sector placement guides, coding round solutions, and aptitude test resources, explore PapersAdda's public sector technology section.