Qualcomm Coding Interview Questions : OA, Technical Rounds & Onsite | New Grad, SDE1 & Intern
Qualcomm is the world's leading fabless semiconductor company — the engineering team behind Snapdragon processors, 5G modems, and Bluetooth/Wi-Fi chips. As a hardware-software company, Qualcomm's interview process is distinct from pure product companies like Google or Meta. They test a broader skillset: strong DSA fundamentals, C/C++ proficiency, operating system concepts, bit manipulation, embedded systems awareness, and low-level memory management.
For software roles (SWE, Embedded SW, DSP Firmware), the process typically includes a HackerRank OA with MCQs, multiple technical rounds emphasising medium-difficulty DSA, and an HR round. The level of depth in systems questions depends heavily on the team — a mobile GPU team will probe OpenGL/Vulkan, while a firmware team will ask about RTOS, interrupts, and memory-mapped I/O.
This guide covers Qualcomm's full hiring process and 50 actual problems reported by candidates for New Grad, SDE1, and Intern tracks across 2024–2026.
Qualcomm's Hiring Process for SWE Roles (2026)
1. Online Application
- Apply via careers.qualcomm.com. Qualcomm recruits heavily from IITs, NITs, and top engineering colleges through campus drives.
- Tip: Highlight C/C++ experience, any embedded or systems projects, and familiarity with DSA. Qualcomm values depth in systems over breadth of web frameworks.
2. Online Assessment (HackerRank) — 1–2 hours
- 10 coding problems (Easy to Medium) + 20 MCQ questions on C/C++ output prediction, data structure theory, and OS concepts.
- Tip: The MCQ section is heavily weighted. Practice "guess the output" C/C++ questions — pointers, pre/post increment, sizeof, and virtual function dispatch are common. Complete the MCQs before the coding section if you find DSA harder.
3. Phone Screen / Initial Technical Screen — 30–45 minutes
- 1–2 DSA problems plus questions about your resume projects.
- Tip: Expect questions on your strongest projects. Qualcomm interviewers frequently ask "why did you choose this data structure?" or "how would you optimise memory usage here?"
4. Technical Round 1 — 45–60 minutes
- 2–3 LeetCode-style problems, mostly Medium. Linked lists, arrays, and strings dominate.
- Tip: Walk through your approach verbally before coding. Qualcomm interviewers prefer candidates who think out loud, especially on edge cases.
5. Technical Round 2 — 45–60 minutes
- Advanced DSA: trees, graphs, dynamic programming. May also include C++ fundamentals (virtual functions, templates, memory layout).
- Tip: Be ready to write C++ specifically, not just pseudocode. Qualcomm teams use C++ heavily.
6. Technical Round 3 / Deep Dive — 45–60 minutes
- Complex optimisation problems, low-level design (e.g., parking lot, memory allocator), and for embedded/firmware roles: memcpy with overlap, endianness, bit manipulation.
- Tip: For firmware/embedded roles, prepare OS concepts — mutex, semaphore, deadlock, IPC, context switching, and RTOS task scheduling.
7. HR / Behavioural Round — 30–45 minutes
- Cultural fit, teamwork, career goals, and Qualcomm-specific motivation.
- Tip: Research Qualcomm's product roadmap (Snapdragon X Elite, 5G Advanced, AI on-device). Connecting your interest to their products makes a strong impression.
Preparation Resources
Part 1 — HackerRank Online Assessment (OA)
Qualcomm's OA has two sections: 10 coding problems (Easy–Medium, timed individually) and 20 MCQ questions on C/C++ output, data structures, and OS concepts. Both sections are evaluated. The MCQ section is unique to Qualcomm — practice output-based C/C++ questions.
1. Single Number Easy
Every element appears twice except one. Find the single non-repeating element in O(n) time and O(1) space.
Input: nums = [4,1,2,1,2]
Output: 4
Approach: XOR all elements. XOR of a number with itself is 0; XOR with 0 is the number itself. The duplicate pairs cancel out, leaving the single element.
Complexity: Time O(n) · Space O(1)
Follow-up: What if one element appears three times and the rest twice? (LeetCode 137 — Single Number II, bit counting approach.)
2. Count Pairs Divisible by K Hard
Return the number of pairs (i, j) where i < j and nums[i] * nums[j] is divisible by k.
Input: nums = [1,2,3,4,5], k = 2
Output: 7
Approach: For each element, compute g = gcd(nums[i], k). The co-factor needed is k / g. Use a frequency map of gcd(num, k) values seen so far. Count how many prior GCDs form a valid pair.
Complexity: Time O(n log k) · Space O(k)
Follow-up: What if k is very large (up to 10^5)? The GCD-based approach handles it efficiently.
3. String Compression Medium
Compress a string so consecutive repeating characters are replaced by the character followed by its count. "AABCCC" becomes "2A1B3C". If count exceeds 9, split: 13 A's becomes "9A4A".
Input: s = "AABCCC"
Output: "2A1B3C"
Input: s = "AAAAAAAAAAAAA" (13 A's)
Output: "9A4A"
Approach: Iterate with a count pointer. When character changes or count hits 9, append the count and character. Reset count.
Complexity: Time O(n) · Space O(n)
Follow-up: Decompress the compressed string back to the original.
4. Power of Two Easy
Given an integer n, return true if it is a power of two.
Input: n = 16
Output: true (2^4)
Input: n = 6
Output: false
Approach: A power of two has exactly one set bit. Use n > 0 && (n & (n-1)) == 0. The trick: n-1 flips the rightmost set bit and all bits below it.
Complexity: Time O(1) · Space O(1)
Follow-up: Power of Three (LeetCode 326) and Power of Four (LeetCode 342).
5. Implement XOR Without XOR Operator Medium
Implement XOR using only AND, OR, and NOT operations (no ^ operator).
Input: a = 5, b = 3
Output: 6 (101 XOR 011 = 110)
Approach: XOR(a, b) = (a | b) & ~(a & b). This is the definition of XOR: bits that are set in one but not both.
Complexity: Time O(1) · Space O(1)
Follow-up: Implement AND without AND, or a full adder using only NAND gates.
6. Count Set Bits (Hamming Weight) Easy
Count the number of '1' bits (set bits) in the binary representation of a number.
Input: n = 11 (binary: 1011)
Output: 3
Approach: Brian Kernighan's algorithm. Repeatedly do n = n & (n-1) which clears the lowest set bit. Count iterations until n becomes 0.
Complexity: Time O(k) where k is the number of set bits · Space O(1)
Follow-up: Count Bits (LeetCode 338) — return counts for all numbers from 0 to n using DP.
Part 2 — Technical Rounds 1 & 2
These rounds cover medium-difficulty DSA. Qualcomm focuses on linked lists, arrays, trees, and strings. Expect live coding in C++ or Java. Always mention time and space complexity — Qualcomm interviewers consistently ask about it.
7. Two Sum Easy
Find the indices of two numbers in an array that add up to the target.
Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Approach: Hash map storing {value: index}. For each element, check if target - current exists in the map.
Complexity: Time O(n) · Space O(n)
Follow-up: 3Sum (LeetCode 15) — find all unique triplets summing to zero.
8. Maximum Subarray (Kadane's Algorithm) Medium
Find the contiguous subarray with the largest sum.
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6 (subarray [4,-1,2,1])
Approach: Kadane's algorithm. current = max(num, current + num). Update global max at each step.
Complexity: Time O(n) · Space O(1)
Follow-up: Return the start and end indices of the subarray, not just the sum.
9. Merge Intervals Medium
Merge all overlapping intervals from a given list.
Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Approach: Sort by start. Extend the last merged interval's end if the current start overlaps; otherwise push a new interval.
Complexity: Time O(n log n) · Space O(n)
Follow-up: Insert Interval (LeetCode 57) — insert into an already sorted non-overlapping list.
10. Reverse Linked List Easy
Reverse a singly linked list iteratively and recursively.
Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]
Approach: Iterative — three pointers: prev, curr, next. Advance while relinking each node backward. Qualcomm commonly asks for both iterative and recursive versions.
Complexity: Time O(n) · Space O(1) iterative, O(n) recursive
Follow-up: Reverse in groups of k (LeetCode 25).
11. Detect Cycle in Linked List Easy
Determine if a linked list contains a cycle.
Input: head = [3,2,0,-4], pos = 1
Output: true
Approach: Floyd's tortoise and hare. Slow pointer moves 1 step, fast moves 2. If they meet, there is a cycle.
Complexity: Time O(n) · Space O(1)
Follow-up: Find the entry point of the cycle (LeetCode 142).
12. Valid Parentheses Easy
Check if a string of brackets is valid — every open bracket must close in the correct order.
Input: s = "{[]}"
Output: true
Input: s = "([)]"
Output: false
Approach: Stack. Push open brackets; on close bracket, verify the top matches. Stack must be empty at end.
Complexity: Time O(n) · Space O(n)
Follow-up: Minimum add to make parentheses valid (LeetCode 921).
13. Lowest Common Ancestor of BST Easy
Find the lowest common ancestor of two nodes in a BST. Leverage BST ordering properties.
Input: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
Output: 6
Approach: If both p and q are less than root, go left. If both are greater, go right. Otherwise the current node is the LCA.
Complexity: Time O(h) · Space O(1)
Follow-up: LCA of Binary Tree (LeetCode 236) — general case without BST property.
14. Binary Tree Level Order Traversal Medium
Return the level-order traversal of a binary tree's node values.
Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]
Approach: BFS with a queue. At each level, process all current queue nodes, collect their values, and enqueue children.
Complexity: Time O(n) · Space O(n)
Follow-up: Print left view of a binary tree — take the first node at each BFS level.
15. Longest Substring Without Repeating Characters Medium
Find the length of the longest substring with all unique characters.
Input: s = "abcabcbb"
Output: 3 ("abc")
Approach: Sliding window with a hash map of last-seen index. On repeat, advance the left pointer past the previous occurrence.
Complexity: Time O(n) · Space O(min(m, n))
Follow-up: Return the actual substring. Then: handle Unicode characters.
16. Number of Islands Medium
Count islands in a 2D binary grid (adjacent '1's connected horizontally or vertically form an island).
Input: grid = [["1","1","0"],["0","1","0"],["0","0","1"]]
Output: 2
Approach: DFS flood-fill. For each unvisited '1', DFS marks all connected land. Count each DFS call.
Complexity: Time O(m x n) · Space O(m x n)
Follow-up: Number of islands in a stream of operations — use Union-Find.
17. Group Anagrams Medium
Group an array of strings into anagram groups.
Input: ["eat","tea","tan","ate","nat","bat"]
Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
Approach: Hash map keyed by each word's sorted form. All anagrams share the same sorted key.
Complexity: Time O(n * k log k) · Space O(n * k)
Follow-up: Use character frequency tuple as key to avoid sorting.
18. Search in Rotated Sorted Array Medium
Search a target in a rotated sorted array in O(log n).
Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4
Approach: Modified binary search. Determine which half is sorted, then check if target falls in the sorted half. Search there or the other half.
Complexity: Time O(log n) · Space O(1)
Follow-up: Handle duplicates (LeetCode 81).
19. Coin Change Medium
Find the minimum number of coins to make a given amount. Qualcomm variant: maximise the number of toys buyable with a budget.
Input: coins = [1,5,11], amount = 15
Output: 3 (5+5+5)
Approach: Bottom-up DP. For each amount 1 to target, try every coin: dp[i] = min(dp[i], dp[i - coin] + 1).
Complexity: Time O(amount x coins) · Space O(amount)
Follow-up: Coin Change II (LeetCode 518) — count the number of distinct combinations.
20. House Robber Medium
Rob houses along a street without robbing two adjacent ones. Find the maximum amount you can rob.
Input: nums = [2,7,9,3,1]
Output: 12 (rob houses 1, 3, 5 → 2+9+1=12)
Approach: DP with two variables: prev2 (best up to i-2) and prev1 (best up to i-1). curr = max(prev1, prev2 + nums[i]).
Complexity: Time O(n) · Space O(1)
Follow-up: House Robber II (LeetCode 213) — houses in a circle.
21. Kth Largest Element in Array Medium
Find the kth largest element in an unsorted array without sorting fully.
Input: nums = [3,2,1,5,6,4], k = 2
Output: 5
Approach: Min-heap of size k. Heap root is the kth largest. Quickselect achieves O(n) average.
Complexity: Time O(n log k) with heap · Space O(k)
Follow-up: Kth Smallest Element in a Sorted Matrix (LeetCode 378).
22. Symmetric Tree Easy
Check if a binary tree is a mirror of itself (symmetric around its centre).
Input: root = [1,2,2,3,4,4,3]
Output: true
Approach: Recursive helper isMirror(left, right). Returns true if both null, false if only one null, and left.val == right.val && isMirror(left.left, right.right) && isMirror(left.right, right.left).
Complexity: Time O(n) · Space O(h)
Follow-up: Iterative approach using a queue of pairs.
23. Implement Trie Medium
Implement a Trie with insert, search, and startsWith operations.
Input: insert("apple"), search("apple") → true, startsWith("app") → true
Approach: Each node has 26 children and an isEnd flag. Insert/search traverse character by character, creating nodes as needed.
Complexity: Time O(m) per operation · Space O(m x n)
Follow-up: Add delete(word) — mark isEnd = false and prune nodes with no children.
24. Course Schedule Medium
Given courses and prerequisites, determine if you can finish all courses (detect cycle).
Input: numCourses = 2, prerequisites = [[1,0],[0,1]]
Output: false (circular dependency)
Approach: DFS with 3 states: unvisited, visiting, visited. A node in "visiting" state encountered again means a cycle exists.
Complexity: Time O(V + E) · Space O(V)
Follow-up: Course Schedule II (LeetCode 210) — return topological ordering.
25. Minimum Window Substring Hard
Find the minimum window in s containing all characters of t.
Input: s = "ADOBECODEBANC", t = "ABC"
Output: "BANC"
Approach: Sliding window with two frequency maps. Expand right until coverage met, shrink left to minimise.
Complexity: Time O(|s| + |t|) · Space O(|t|)
Follow-up: Find all minimum windows.
Part 3 — Technical Round 3 & Onsite Deep Dives
Advanced DSA, C++ systems concepts, low-level design, and for embedded/firmware roles, memory management and OS concepts. These rounds differentiate senior from junior candidates.
26. Implement memcpy with Overlap Handling Hard
Implement memcpy(dst, src, n) in C that correctly handles overlapping source and destination buffers.
If src < dst and buffers overlap:
Copy backwards (dst+n-1 to dst) to avoid overwriting unread src bytes.
Else:
Copy forwards normally.
Approach: Check if src < dst and they overlap (src + n > dst). If so, copy from the end backwards (memmove semantics). Otherwise copy forward byte by byte. This is essentially implementing memmove.
Complexity: Time O(n) · Space O(1)
Follow-up: Implement memset(ptr, value, n) — fill n bytes starting at ptr with value.
27. Big and Little Endian Conversion Medium
Write a function to convert a 32-bit integer from big-endian to little-endian (byte-swap). Also: write code to detect the endianness of the current machine at runtime.
Input: 0x12345678 (big-endian)
Output: 0x78563412 (little-endian)
Approach: Use bit masks and shifts to extract each byte and reassemble in reversed order. For detection: cast an int to char* and check if the lowest address holds the least significant byte.
Complexity: Time O(1) · Space O(1)
Follow-up: Implement htonl() and ntohl() (host to network byte order and back).
28. Custom strstr() Implementation Medium
Implement strstr(haystack, needle) in C — return a pointer to the first occurrence of needle in haystack, or NULL if not found.
Input: haystack = "hello", needle = "ll"
Output: pointer to "llo" (index 2)
Approach: Naive O(n*m) — slide needle over haystack, check character by character. For production: KMP algorithm gives O(n + m).
Complexity: Naive O(n*m) · KMP O(n + m) · Space O(1) naive, O(m) KMP
Follow-up: Implement KMP failure function. What is its time complexity?
29. Convert Sorted List to Binary Search Tree Medium
Convert a sorted singly linked list to a height-balanced BST.
Input: head = [-10,-3,0,5,9]
Output: [0,-3,9,-10,null,5]
Approach: Use slow/fast pointers to find the middle of the list. Make it the root. Recursively build left and right subtrees from left and right halves.
Complexity: Time O(n log n) · Space O(log n)
Follow-up: O(n) solution — simulate in-order traversal using the list's natural order.
30. Find Intersection of Two Linked Lists Easy
Find the node where two singly linked lists intersect. Return null if they do not.
Input: listA = [4,1,8,4,5], listB = [5,6,1,8,4,5]
Output: Node with value 8
Approach: Two pointers. When pointer A reaches the end, redirect to head of B. When B reaches the end, redirect to head of A. They meet at the intersection (or both reach null).
Complexity: Time O(m + n) · Space O(1)
Follow-up: What if the list has a cycle? Detect cycle first, then find intersection.
31. Serialize and Deserialize Binary Tree Hard
Design an algorithm to serialize a binary tree to a string and deserialize back.
Input: root = [1,2,3,null,null,4,5]
Output: Deserialized tree matches original
Approach: BFS with null markers for serialization. Reconstruct level by level for deserialization.
Complexity: Time O(n) · Space O(n)
Follow-up: Serialize to minimize size — use preorder DFS with null markers.
32. Trapping Rain Water Hard
Calculate the total water trapped between elevation bars.
Input: height = [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6
Approach: Two pointers. Track left_max and right_max. Move pointer at the lower max — water at that cell = max_side - height[i].
Complexity: Time O(n) · Space O(1)
Follow-up: 3D version (LeetCode 407) — BFS with a min-heap.
33. Word Search Medium
Check if a word exists in a 2D board as a connected horizontal/vertical sequence.
Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
Output: true
Approach: DFS backtracking from each matching cell. Mark visited by temporarily altering value; restore after recursion.
Complexity: Time O(m x n x 4^L) · Space O(L)
Follow-up: Word Search II (LeetCode 212) — find all words from a list using a Trie.
34. Merge K Sorted Lists Hard
Merge k sorted linked lists into one sorted list.
Input: lists = [[1,4,5],[1,3,4],[2,6]]
Output: [1,1,2,3,4,4,5,6]
Approach: Min-heap of size k storing (value, index, node). Pop min, push next from that list.
Complexity: Time O(N log k) · Space O(k)
Follow-up: Merge k sorted arrays instead of linked lists.
35. 2D Image Read/Write (Rotate or Mirror) Medium
Given a 2D image as a matrix, rotate it 90 degrees clockwise in-place (a common GPU/image-processing problem at Qualcomm).
Input: [[1,2,3],[4,5,6],[7,8,9]]
Output: [[7,4,1],[8,5,2],[9,6,3]]
Approach: Transpose (swap [i][j] and [j][i]), then reverse each row.
Complexity: Time O(n^2) · Space O(1)
Follow-up: Mirror the image horizontally or vertically. Rotate by arbitrary angle (floating point interpolation).
36. Jump Game II Medium
Find the minimum number of jumps to reach the last index.
Input: nums = [2,3,1,1,4]
Output: 2 (jump from 0 to 1, then 1 to 4)
Approach: Greedy BFS. Track current jump range end and farthest reachable index. When you reach the range end, increment jumps and extend the range.
Complexity: Time O(n) · Space O(1)
Follow-up: What if some jumps have a cost? Use Dijkstra's algorithm.
37. Climbing Stairs Easy
You can climb 1 or 2 steps at a time. Count the number of distinct ways to reach the top.
Input: n = 4
Output: 5 (1+1+1+1, 2+1+1, 1+2+1, 1+1+2, 2+2)
Approach: This is Fibonacci. ways[n] = ways[n-1] + ways[n-2]. Track only two variables.
Complexity: Time O(n) · Space O(1)
Follow-up: Allow jumps of 1, 2, or 3 steps (LeetCode 746 variant).
38. Return Stream of Bytes Medium
Given a read4() API that reads exactly 4 bytes, implement a read(buf, n) function that reads n bytes. The function may be called multiple times.
Input: File = "abcdef", read(4) → 4, read(2) → 2, read(1) → 0
Approach: Maintain an internal buffer and pointer between calls. Fill from the internal buffer first, then call read4() for more data as needed.
Complexity: Time O(n) · Space O(1)
Follow-up: Read N Characters Given Read4 (LeetCode 157) — single call version.
39. Word Ladder Hard
Find the shortest transformation sequence from beginWord to endWord, changing one letter at a time, where each intermediate word must be in the dictionary.
Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
Output: 5 (hit → hot → dot → dog → cog)
Approach: BFS. From each word, generate all one-letter variants. If in the word list and not visited, add to queue. Return level count when endWord is found.
Complexity: Time O(M^2 x N) · Space O(M^2 x N) where M is word length, N is word count
Follow-up: Word Ladder II (LeetCode 126) — return all shortest transformation sequences.
40. Parking Lot System Design Medium
Design a parking lot system that supports multiple levels, different vehicle types (motorbike, car, truck), entry/exit tracking, and fee calculation.
Classes: ParkingLot, Level, ParkingSpot, Vehicle, Ticket, FeeCalculator
Operations: park(vehicle), unpark(ticket), getAvailableSpots(vehicleType)
Approach: Model each level as a list of spots of different sizes. Use a map of vehicle type to eligible spot sizes. Calculate fee as (exit_time - entry_time) x rate. Use an enum for spot types and vehicle types.
Complexity: Time O(levels x spots) for park · Space O(levels x spots)
Follow-up: Add reservation, online payment, and real-time availability display.
41. LRU Cache Medium
Design an LRU Cache with O(1) get and put. This is asked at Qualcomm both as a standalone question and as part of a system design context (modem firmware cache).
Input: capacity = 2, put(1,1), put(2,2), get(1) → 1, put(3,3), get(2) → -1
Approach: Doubly linked list + hash map. Most recent at head, evict from tail. On access, move to head.
Complexity: Time O(1) · Space O(capacity)
Follow-up: Implement in C++ with templates so the cache works with any key-value type.
42. 3Sum Medium
Find all unique triplets that sum to zero.
Input: nums = [-1,0,1,2,-1,-4]
Output: [[-1,-1,2],[-1,0,1]]
Approach: Sort. For each element, two-pointer search on the remainder. Skip duplicates.
Complexity: Time O(n^2) · Space O(1)
Follow-up: 4Sum (LeetCode 18) — add one outer loop.
43. Maximum Depth of Binary Tree Easy
Return the maximum depth (number of nodes along the longest root-to-leaf path) of a binary tree.
Input: root = [3,9,20,null,null,15,7]
Output: 3
Approach: Recursive DFS: 1 + max(maxDepth(left), maxDepth(right)). Return 0 for null node.
Complexity: Time O(n) · Space O(h)
Follow-up: Minimum Depth (LeetCode 111) — depth to the nearest leaf.
44. Balanced Binary Tree Easy
Check if a binary tree is height-balanced — every node's left and right subtree heights differ by at most 1.
Input: root = [3,9,20,null,null,15,7]
Output: true
Approach: Bottom-up DFS returning height. Return -1 if any subtree is unbalanced. Avoids repeated height calculations.
Complexity: Time O(n) · Space O(h)
Follow-up: Convert an unbalanced BST into a balanced BST.
45. Delete Node in Linked List Medium
Given only a pointer to a node (not the head), delete that node from a singly linked list.
Input: head = [4,5,1,9], node = 5
Output: [4,1,9]
Approach: Copy the next node's value into the current node, then bypass the next node (node.val = node.next.val; node.next = node.next.next).
Complexity: Time O(1) · Space O(1)
Follow-up: What if the node to delete is the last node? (This case is impossible per the problem constraints — discuss why.)
46. Insert Interval Medium
Insert a new interval into a sorted non-overlapping list, merging where necessary.
Input: intervals = [[1,3],[6,9]], newInterval = [2,5]
Output: [[1,5],[6,9]]
Approach: Three phases — add all intervals ending before newInterval starts, merge all overlapping intervals into newInterval, add the rest.
Complexity: Time O(n) · Space O(n)
Follow-up: What if the input is unsorted?
47. Cycle Detection in Directed Graph Medium
Detect a cycle in a directed graph given its adjacency list.
Input: V = 4, edges = [[0,1],[1,2],[2,3],[3,1]]
Output: true (cycle: 1 → 2 → 3 → 1)
Approach: DFS with a recursion stack (separate from visited set). Mark nodes entering the stack. If you reach an already-in-stack node, a cycle exists. Unmark on exit.
Complexity: Time O(V + E) · Space O(V)
Follow-up: Detect cycle in undirected graph — simpler, track parent in DFS.
48. Print Left View of Binary Tree Medium
Print the first (leftmost) node at each level of a binary tree when viewed from the left side.
Input: root = [1,2,3,null,5,null,4]
Output: [1,2,5]
Approach: BFS level-order traversal. The first node dequeued at each level is the leftmost visible node. Add it to the result.
Complexity: Time O(n) · Space O(n)
Follow-up: Right view (Binary Tree Right Side View — LeetCode 199) — take the last node at each level.
49. Maximum Subarray Product Medium
Find the contiguous subarray with the largest product.
Input: nums = [2,3,-2,4]
Output: 6 ([2,3])
Approach: Track both max and min at each step (negative x negative = positive). At each element: max_prod = max(num, max*num, min*num), similarly for min.
Complexity: Time O(n) · Space O(1)
Follow-up: What if the array contains zeros? Reset both trackers at each zero.
50. Timer Module with Callback Functions Hard
Design a software timer module in C that allows registering multiple timed callbacks. A client calls register_timer(delay_ms, callback_fn). After delay_ms milliseconds, callback_fn should be invoked. The module should support multiple simultaneous timers.
Design:
Timer struct { uint32_t expiry_tick; void (*callback)(void); }
register_timer(delay_ms, cb) → inserts timer sorted by expiry
tick_handler() → called every ms, fires expired callbacks
Approach: Maintain a min-heap (priority queue) of timers sorted by expiry tick. A periodic hardware interrupt (tick) invokes the tick handler which pops and fires all expired timers.
Complexity: Time O(log n) per registration · Space O(n)
Follow-up: Thread safety — how do you protect the timer list from concurrent access in an RTOS? (Use a mutex or disable interrupts around heap operations.)
Qualcomm Interview Preparation Tips
- C++ is the default language: Unlike pure product companies, Qualcomm heavily uses C++. Practice writing C++ specifically — STL containers, smart pointers, virtual functions, and template basics are fair game.
- MCQ section is unique: The OA has 20 MCQ questions on C/C++ output prediction, time complexity, OOP principles, and OS basics. Practice reading small code snippets and predicting the exact output — pointer arithmetic, pre/post increment, sizeof, and bitwise operations are common.
- Bit manipulation is essential: Qualcomm is a semiconductor company. Questions on bit operations (XOR, AND, OR, shifts, set/clear/toggle bit) appear in the OA and in live technical rounds.
- Systems questions for embedded roles: If targeting Firmware, DSP, or Embedded SW roles, prepare OS fundamentals — mutex vs semaphore, deadlock conditions, IPC mechanisms, RTOS task scheduling, and memory-mapped registers.
- Resume deep dives: Qualcomm interviewers frequently pick 1–2 items from your resume and probe deeply. Be ready to justify every architectural decision, data structure choice, and performance tradeoff in your projects.
- Explain, then code: Qualcomm prefers candidates who state their approach, edge cases, and complexity analysis before writing code — not after.
Join Telegram group for any doubts & discussions!