Cisco C Programming with DSA Interview Questions & Answers
Curated interview practice questions with answers. These are practice scenarios, not a verified list of past interview questions.
About Cisco hiring for C Programming with DSA roles
Cisco is a networking and security company making routers, switches, security products, collaboration tools such as Webex, and observability software including Splunk. Its Bengaluru campus is one of its largest R&D centres outside the US. It hires in India for software engineers, test and validation engineers, network engineers and data analysts.
For C Programming with DSA roles, this Cisco practice set focuses most on Sorting, Searching and Dynamic Programming (6), Linked Lists (6), Arrays and Strings (4), Stacks, Queues and Hashing (4). It has 1 easy, 18 medium, 11 hard questions, so you can start easy and work up to the harder ones.
Typical pattern based on public candidate experiences. Rounds vary by role, team and year.
Solved for CiscoStart practicing
3 QUESTIONS FREESign up to unlock the full question bank and track your progress.Unlock every question and answer, then continue practising company-wise and package-wise.
✓ 3 questions free • Unlock the rest in seconds
01
What is the difference between greedy algorithms and dynamic programming?
A greedy algorithm makes the best local choice at each step and never revisits it, which works only when the greedy choice property holds, as in activity selection, Huffman coding and Dijkstra. Dynamic programming considers all relevant subproblem choices and combines them, so it works where greedy fails, such as 0/1 knapsack or coin change with arbitrary denominations. Greedy is faster when provably correct.
02
How would you detect if two linked lists intersect and find the intersection node?
Two lists intersect if they share a node by address, not just value. Compute both lengths, advance the longer list by the difference, then move both together until the pointers are equal. A neat trick is to walk pointer a through list A then B, and pointer b through B then A; they meet at the intersection or both reach NULL. Both are O(m + n) time and O(1) space.
03
Write a C program that counts lines, words and characters in a file.
Read character by character with fgetc.
FILE *fp = fopen(path, "r");
if (!fp) { perror("fopen"); return 1; }
long lines = 0, words = 0, chars = 0;
int c, inWord = 0;
while ((c = fgetc(fp)) != EOF) {
chars++;
if (c == '\n') lines++;
if (isspace(c)) inWord = 0;
else if (!inWord) { inWord = 1; words++; }
}
fclose(fp);
printf("%ld %ld %ld\n", lines, words, chars);
c is int so EOF can be distinguished from valid bytes.
04
Describe a time you had to make a trade-off between memory and speed.
Situation: a C routing service on a small server ran out of memory with an adjacency matrix for 50,000 nodes. Task: fit within 512 MB without slowing queries much. Action: I switched to compact adjacency lists stored in flat arrays, known as CSR format, and kept a small cache for frequent routes. Result: memory fell from 10 GB worth of matrix to 60 MB and queries stayed under 20 ms.
Use a slow pointer moving one step and a fast pointer moving two steps. If the list has a cycle, the fast pointer eventually meets the slow one inside the loop; if fast reaches NULL, there is no cycle. To find the cycle start, reset one pointer to head and move both one step at a time; they meet at the start. It uses O(n) time and O(1) space.
Quicksort is O(n log n) on average and very fast in practice with in-place partitioning, but O(n squared) in the worst case with poor pivots and not stable. Merge sort is always O(n log n) and stable but needs O(n) extra memory. Heap sort is O(n log n) worst case and in place but not stable and slower due to poor cache use. C's qsort is usually a tuned hybrid.
Split, sort halves, merge with a temp buffer.
void merge(int *a, int l, int m, int r, int *tmp) {
int i = l, j = m + 1, k = l;
while (i <= m && j <= r) tmp[k++] = (a[i] <= a[j]) ? a[i++] : a[j++];
while (i <= m) tmp[k++] = a[i++];
while (j <= r) tmp[k++] = a[j++];
for (k = l; k <= r; k++) a[k] = tmp[k];
}
void mergeSort(int *a, int l, int r, int *tmp) {
if (l >= r) return;
int m = l + (r - l) / 2;
mergeSort(a, l, m, tmp);
mergeSort(a, m + 1, r, tmp);
merge(a, l, m, r, tmp);
}
08
Find the majority element that appears more than n/2 times in O(n) time and O(1) space.
Boyer-Moore voting algorithm.
int majority(const int *a, int n) {
int cand = 0, count = 0;
for (int i = 0; i < n; i++) {
if (count == 0) cand = a[i];
count += (a[i] == cand) ? 1 : -1;
}
return cand;
}
If a majority is not guaranteed, make a second pass to count cand and confirm it exceeds n/2.
Dynamic programming solves problems that have overlapping subproblems and optimal substructure by storing results of subproblems instead of recomputing them. Top-down memoisation caches recursive calls, while bottom-up tabulation fills a table iteratively. Classic examples are Fibonacci, 0/1 knapsack, longest common subsequence, coin change and edit distance. Defining the state and transition clearly is the hardest part.
10
Valgrind reports invalid read of size 4 after free. How do you fix it?
This is a use-after-free: code reads memory that was already released. Valgrind shows where it was freed and where it was read. Fix the ownership logic so nothing uses the object after free, and set pointers to NULL right after freeing so accidental use fails fast. If multiple parts share the object, use reference counting or free only at one clear owner.
Alignment means placing data at addresses that are multiples of its size or required boundary, such as 4 for int. CPUs read aligned data faster, and some architectures fault on misaligned access. Compilers add padding in structs to align members. You can check alignment with _Alignof and request it with _Alignas or aligned_alloc in C11.
In expressions, types smaller than int, like char and short, are promoted to int before arithmetic. In mixed signed and unsigned comparisons, the signed value may convert to unsigned. So if (-1 < sizeof(int)) is false, because -1 becomes a huge unsigned number. These rules cause subtle bugs in embedded and systems code, so compile with -Wall -Wextra and use explicit casts carefully.
13
What is a heap and how does it implement a priority queue?
A binary heap is a complete binary tree stored in an array where every parent is smaller than its children for a min heap, or larger for a max heap. For index i, children are at 2i + 1 and 2i + 2. Insert adds at the end and sifts up, and extracting the top swaps it with the last element and sifts down, both O(log n). Building a heap from an array takes O(n).
14
How do you explain the time complexity of your solution to an interviewer?
Situation: in a technical round I solved a tree problem but the interviewer questioned its efficiency. Task: justify the complexity clearly. Action: I explained that each node is visited once and does constant work, so time is O(n), and that recursion depth equals tree height, giving O(h) space, worst case O(n) for a skewed tree. Result: the interviewer agreed and moved to a harder follow-up.
15
Solve the 0/1 knapsack problem in C with a 1D DP array.
Iterate capacity backwards so each item is used once.
int knapsack(const int *wt, const int *val, int n, int W) {
int dp[W + 1];
for (int c = 0; c <= W; c++) dp[c] = 0;
for (int i = 0; i < n; i++) {
for (int c = W; c >= wt[i]; c--) {
int take = dp[c - wt[i]] + val[i];
if (take > dp[c]) dp[c] = take;
}
}
return dp[W];
}
Time O(nW), space O(W).
16
You need the maximum of every sliding window of size k in an array. How would you solve it efficiently?
Use a deque storing indexes in decreasing order of value. For each element, remove indexes outside the window from the front, pop smaller values from the back, then push the current index. The front is always the maximum of the current window. Each index enters and leaves once, so the total time is O(n) instead of O(nk).
17
Evaluate a postfix expression of single digit numbers using a stack.
Push digits and apply operators to the top two values.
int evalPostfix(const char *s) {
int st[100], top = -1;
for (; *s; s++) {
if (isdigit((unsigned char)*s)) st[++top] = *s - '0';
else if (strchr("+-*/", *s)) {
int b = st[top--], a = st[top--];
switch (*s) {
case '+': st[++top] = a + b; break;
case '-': st[++top] = a - b; break;
case '*': st[++top] = a * b; break;
case '/': st[++top] = a / b; break;
}
}
}
return st[top];
}
23*5+ evaluates to 11.
18
Merge two sorted linked lists into one sorted list.
A raw struct includes padding bytes, platform specific sizes and byte order, so a file written on one compiler or CPU may not read correctly on another. Pointers inside the struct are meaningless after reload. For portable formats, serialise each field explicitly with fixed-width types and a defined byte order, or use a format like JSON or Protocol Buffers.
Track the best sum ending here and the overall best.
long maxSubarray(const int *a, int n) {
long cur = a[0], best = a[0];
for (int i = 1; i < n; i++) {
cur = (cur + a[i] > a[i]) ? cur + a[i] : a[i];
if (cur > best) best = cur;
}
return best;
}
Input {-2, 1, -3, 4, -1, 2, 1, -5, 4} returns 6 for subarray 4, -1, 2, 1.
21
Implement a circular queue with enqueue and dequeue in C.
Picking the first or last element as pivot on sorted input makes every partition split into sizes n-1 and 0, so quicksort degrades to O(n squared) and recursion depth reaches n. Choose a random pivot or median of three, switch to insertion sort for small parts and recurse on the smaller side first to bound stack depth. Introsort switches to heap sort if recursion gets too deep.
23
How do you check whether a linked list is a palindrome in O(1) extra space?
Find the middle with slow and fast pointers, reverse the second half in place, then compare the first half and the reversed second half node by node. Finally reverse the second half again to restore the list, which interviewers appreciate. Time is O(n) and extra space is O(1). A simpler O(n) space approach copies values into an array or stack first.
24
A matrix multiplication in C is very slow for 2000 by 2000 matrices. How would you speed it up?
The naive i, j, k loop accesses one matrix column by column, causing many cache misses. Swap the loop order to i, k, j so inner loops walk rows contiguously, use blocking or tiling to keep chunks in cache, compile with -O3 -march=native to enable vectorisation and consider OpenMP for multiple cores. For production, an optimised BLAS library is fastest.
25
Find the length of the longest substring without repeating characters in C.
Sliding window with last seen positions.
int longestUnique(const char *s) {
int last[256];
for (int i = 0; i < 256; i++) last[i] = -1;
int best = 0, start = 0;
for (int i = 0; s[i]; i++) {
unsigned char c = s[i];
if (last[c] >= start) start = last[c] + 1;
last[c] = i;
if (i - start + 1 > best) best = i - start + 1;
}
return best;
}
For abcabcbb it returns 3.
26
Allocate and free a dynamic 2D array of rows by cols in C.
A single block is cache friendly and easy to free.
int (*grid)[cols] = malloc(rows * sizeof *grid);
if (!grid) return -1;
grid[2][3] = 5;
free(grid);
// array of row pointers alternative
int **m = malloc(rows * sizeof *m);
for (int i = 0; i < rows; i++)
m[i] = calloc(cols, sizeof **m);
for (int i = 0; i < rows; i++) free(m[i]);
free(m);
The first form uses a variable length array type.
27
Write BFS on a graph stored as an adjacency matrix.
Use a queue and a visited array.
void bfs(int n, int adj[n][n], int start) {
int visited[n], queue[n], front = 0, rear = 0;
for (int i = 0; i < n; i++) visited[i] = 0;
visited[start] = 1;
queue[rear++] = start;
while (front < rear) {
int u = queue[front++];
printf("%d ", u);
for (int v = 0; v < n; v++) {
if (adj[u][v] && !visited[v]) {
visited[v] = 1;
queue[rear++] = v;
}
}
}
}
28
Remove the nth node from the end of a linked list in one pass.
Move a lead pointer n steps ahead, then move both together.
Node *removeNthFromEnd(Node *head, int n) {
Node dummy = {0, head};
Node *fast = &dummy, *slow = &dummy;
for (int i = 0; i <= n; i++) fast = fast->next;
while (fast) { fast = fast->next; slow = slow->next; }
Node *del = slow->next;
slow->next = del->next;
free(del);
return dummy.next;
}
The dummy node handles removing the head.
29
Insert a node at the end of a singly linked list using a double pointer.
A pointer to pointer handles the empty list without special cases.
int append(Node **head, int value) {
Node *n = malloc(sizeof *n);
if (!n) return -1;
n->data = value;
n->next = NULL;
while (*head) head = &(*head)->next;
*head = n;
return 0;
}
Call it as append(&head, 5). Keep a tail pointer if you append often.
30
What is structure padding and how can you reduce it?
The compiler inserts padding bytes between members so each one is aligned, which can make a struct larger than the sum of its members. struct { char a; int b; char c; } is usually 12 bytes instead of 6. Reduce padding by ordering members from largest to smallest alignment. Packing with __attribute__((packed)) removes padding but can slow access or fault on some CPUs.
Tips to crack the Cisco C Programming with DSA interview
Revise computer networking deeply, including OSI layers, TCP/IP, subnetting, routing protocols and VLANs.
For test roles, be ready to explain how you would test a network feature, including traffic tools and automation with Python.
Read about Cisco's security and Splunk observability products, which have become a growing focus area.
Keep a one-minute story ready for every project on your CV: problem, your part, tools, result.
Practise the hard questions on this page aloud; Cisco interviewers usually ask follow-ups on your first answer.
Frequently asked questions
How many rounds are there in the Cisco C Programming with DSA interview?
Candidates usually go through 5 stages: Online assessment (aptitude + networking + coding); Technical round 1; Technical round 2; Managerial round; HR round. The exact rounds change with the role, team, location and your experience, so confirm the process with the recruiter.
Which topics should I prepare for the Cisco C Programming with DSA interview?
This practice set leans on Sorting, Searching and Dynamic Programming (6), Linked Lists (6), Arrays and Strings (4), Stacks, Queues and Hashing (4). Revise those first, then practise explaining one or two of your own projects end to end, because most Cisco interviewers ask you to walk through real work.
Are these the exact questions asked at Cisco?
No. These are curated practice questions that match the skills and difficulty usually tested in hardware & semiconductors interviews like Cisco's. They are not a leaked or verified list of past questions.
Where does Cisco hire C Programming with DSA professionals in India?
Cisco has large teams in Bengaluru, Pune, Chennai. Openings and locations change often, so check the Cisco careers page and filter by city and experience.
C Programming with DSA questions for similar companies