Qualcomm — Programming Practice List (coding questions to drill)¶

Source: the actual coding questions asked in the 75 reports in qualcomm_camera_interview_experiences.md. I kept only programming/coding questions (write code, an algorithm, or predict/debug code) and dropped pure theory, HR/behavioral, networking/DBMS/cloud, ML-theory, and pen-and-paper puzzles (those live in 04_os.md, 06_ml_deeplearning.md, 08_logical_puzzles_aptitude.md, 11_behavioral_hr_projects.md). Near-duplicates are collapsed into one entry with variants noted.

How to use: You're rusty in C/C++, so the categories are ordered easy → hard, and within each category, items are ordered easy → hard. Start at the top of Part 1, do a few per category, and circle back. Part 2 is a 70-item C/C++ syntax/capability warm-up to do first or alongside if the language feels rusty (it overlaps Part 1 on purpose).

Legend: [E] easy · [M] medium · [H] hard. LC = closest LeetCode problem to practice on. →NN = the concept is explained in that prep file. Check off [ ] → [x] as you go.

✅ Solutions (clean, compile-verified C/C++ — try each yourself first, then check): Part 1 · A–C (C & memory) · Part 1 · D–G (arrays/strings/bits) · Part 1 · H–K (lists/trees) · Part 1 · L–O (recursion/C++/design) · Part 2 (warm-ups) · Part 3 (algorithms)

Part 1 — Categorized practice list (easy → hard)¶

A. Warm-ups: numbers, bits-as-math & simple strings · start here¶

Pure syntax/logic reps to get your hands moving in C/C++. - [ ] Swap two numbers without a third variable — [E] (→01) - [ ] Check whether a number is even/odd, and largest of three — [E] - [ ] Reverse a string in place — [E] · LC344 (→01 E) - [ ] Reverse the digits of an integer / sum of digits / count digits — [E] - [ ] Multiply two numbers discussing many approaches (shift-add, repeated addition) — [E→M] (→08 E2) - [ ] Divide a number by 4 without the / operator (use >> 2) — [E] (→01, →09) - [ ] Convert a string to an integer (your own atoi) — [M] · LC8 - [ ] Validate a string is a palindrome — [E] · LC125 - [ ] Pattern printing in C (pyramids / number triangles) — [E] - [ ] Count occurrences of a word in a paragraph (e.g. count "is" in a sentence) — [E→M] - [ ] String compression: AABCCC → 2A1B3C (with the run-cap twist: 13 A's → 9A4A) — [M] - [ ] Replace every a with ab in a string (in place, mind the resize) — [M] - [ ] Decode an encoded string: "a10101b001c11" → "a21b1c3" (binary→decimal per token) — [M]

B. C pointers, memory & language — write it & predict it · the Qualcomm signature area¶

• Predict the output of pointer/operator snippets (10 rapid-fire) — [M] (→01 G4)
• Find the bug in int main(){char *p; while(i<50) p++; return p;} — [E] (→01 G4)
• Predict output of malloc in a loop / MCQ compile-time vs run-time errors — [M] (→01)
• Basic pointer declare/deref; types of pointers; void pointers usage — [E] (→01 A1/A3)
• Pointer subtraction — what does q - p yield? — [E] (→01 A5)
• Function pointers + callback functions (declare, call, use) — [M] (→01 A4)
• Relationship between function pointers and inline — [M] (→01 G3)
• Dangling pointer — show one and how to avoid it; what happens on null-pointer deref (stack/memory level) — [M] (→01 A2/D3)
• Pass-by-value vs pass-by-reference — write code + explain memory (struct example) — [E] (→01)
• struct vs union + struct padding: compute sizeof of given structs — [M] (→01 F3)
• Define a data structure to store exactly 12 bits of data (bit-fields) — [M]
• Check endianness — write C/C++ to detect big/little, and swap endianness — [M] (→01 F1)
• Storage classes (static/extern/register/auto) — predict lifetime/scope/visibility from code — [M] (→01 B)
• volatile — when/why; const placement — [M] (→01 B3)
• Return a stream of bytes from a function (no dangling — heap or caller buffer) — [M] (→01 E5/A6)

C. Implement standard library / low-level routines · classic Qualcomm "write it yourself"¶

• memcpy yourself — [M] (→01 E1)
• memcpy handling overlap + memmove (copy direction) — [H] (→01 E1)
• memcpy without a temporary array / covering all error scenarios — [M]
• strcmp yourself — [E] (→01 E2)
• strstr the optimal way (naive then KMP) — [H] (→01 E3)
• sizeof operator yourself (macro, pointer-arithmetic trick) — [M] (→01 E4)
• malloc/free strategy — describe how you'd implement them (free lists, headers) — [H] (→01 C2)

D. Arrays¶

• Rotate an array by k to the right — [E] · LC189
• Merge two sorted arrays in-place (into nums1) — [M] · LC88
• Find the missing number in an unsorted 1..n (optimal: XOR or sum) — [E] · LC268
• First and last position of an element in a sorted array — [M] · LC34
• Search in a sorted array of "infinite" size (exponential + binary search) — [M]
• Count pairs whose sum is divisible by k — [M]
• N meetings in one room (activity selection) — [M] · GfG
• Minimum number of platforms for trains given arrival/departure — [M] · GfG
• Sliding-window maximum (max in every window of size k) — [H] · LC239
• Trapping rain water — [H] · LC42

E. Searching & sorting¶

• Binary search — implement + write pseudocode + complexity in all scenarios — [E] · LC704 (→03)
• Merge sort — implement — [M] (→03)
• Quick sort — how does the pivot choice impact complexity? — [M] (→03)
• Sort a linked list — and discuss merge sort vs quick sort for lists — [H] · LC148

F. Strings (algorithmic)¶

• Reverse the words in a sentence / reverse odd-positioned words — [M] · LC151
• Longest substring without repeating characters — [M] · LC3
• Longest palindromic substring — [M] · LC5
• Count of palindromic substrings — [M] · LC647

G. Bit manipulation¶

• Count the number of set bits in a number — [E] · LC191 (→03)
• Check power of two using only bitwise ops, O(1) (no pow/log2) — [E] · LC231
• Flip the kth bit from the right — [E]
• Reverse the bits of a number (and then count set bits) — [M] · LC190
• Single Number (the one element appearing once) — [M] · LC136

H. Linked lists · the most-asked DSA family at Qualcomm¶

• Reverse a singly linked list — [E] · LC206 (→03)
• Insert a node at beginning / kth position / into a sorted (dictionary-order) list — [E]
• Find the middle of a linked list — [E] · LC876
• Detect a loop (Floyd slow/fast) — single, circular, and doubly linked — [M] · LC141 (→03)
• Find the length of the loop in a linked list — [M]
• Detect and remove a loop — [M] · LC142
• Nth node from the end (multiple approaches) — [M] · LC19
• Delete a node given only a pointer to it (incl. circular list) — [M] · LC237
• Pairwise swap nodes / swap nodes in pairs — [M] · LC24
• Reverse a doubly linked list — [M]
• Intersection point of two linked lists (brute force + O(n)) — [M] · LC160
• Rotate: move the last node to the front (1..n → n,1..n-1) — [M]
• Merge two sorted linked lists — [M] · LC21
• Convert a sorted linked list to a BST — [H] · LC109
• Reverse nodes in k-group — [H] · LC25
• Merge k sorted lists (whiteboard + complexity) — [H] · LC23

I. Stacks & queues¶

• Implement a stack with all operations (array or list) — [E]
• Implement a stack using queues (or queue using stacks) — [M] · LC225/232
• Asteroid Collision (stack simulation) — [M] · LC735

J. Trees & BST¶

• Find the maximum element in a binary tree — [E]
• Left view of a binary tree — [M] · GfG
• Create / insert into a BST (write create + insert) — [E]
• Delete a node in a binary tree / BST — [M] · LC450
• Check whether a binary tree is a BST — [M] · LC98
• Minimum distance between two nodes of a binary tree (LCA + depths; call-stack analysis) — [M]
• Fix a BST where two nodes were swapped — [H] · LC99
• Binary Tree Maximum Path Sum — [H] · LC124
• Count permutations of a preorder that form the same BST — [H]

K. Hashing¶

• Implement a hash table (buckets + chaining; handle collisions) — [M] (→03)
• Hashing vs hash tables — and use a hashmap to count pairs divisible by k — [M]

L. Recursion, DP & graphs¶

• Recursion + the call stack — factorial/fib and the memory used (lead-in to DP) — [E] (→03)
• Maximise the number of toys purchasable with amount K (coin-change-style DP) — [M] · LC322-ish
• Generate valid sentences from words (word break / segmentation) — [H] · LC139/140
• BFS vs DFS — implement graph traversal — [M] (→03)
• Number of Islands — [M] · LC200
• Topological sort — [M] · LC210
• Propagate failures through a dependency graph — [H]

M. C++ & OOP (write the code)¶

• Function overloading vs overriding — show both in code — [E] (→02)
• Polymorphism — virtual function with an example; types with code — [M] (→02)
• Types of inheritance + resolving multiple-inheritance ambiguity (diamond) — [M] (→02)
• Operator overloading (e.g. + and << for a small class) — [M] (→02)
• new/delete vs malloc/free; smart pointer basics — [M] (→02)
• Implement a thread-safe Singleton (private ctor, static instance, double-checked locking / Meyers) — [H] (→02)
• Implement your own immutable class — [H] (→02/10)

N. Concurrency / multithreading (write the code)¶

• Print odd and even numbers sequentially using two threads + a mutex/condition variable — [M] (→04)
• Program using pthreads (create/join, pass args) — [M] (→07)
• Two threads accessing the same map — protect with mutex/locking — [M]
• Implement a binary semaphore (+ follow-ups) — [H] (→04)
• Write pseudocode that creates a deadlock on threads (then fix it) — [M] (→04)
• Identify the race condition in given pseudocode — [M] (→04)

O. Design / implement-a-system · hardest; code-heavy design¶

• LRU cache (hashmap + doubly linked list) — and the "twisted LRU" variant — [H] · LC146 (→03/10)
• LFU cache — [H] · LC460
• Timer module: handle timeouts & fire callbacks for many clients (timer wheel / min-heap) — [H] (→10)
• Lottery machine: non-repeating random 1..N, circular elimination, logging, clean class design — [H] (→10)
• Screen-tearing fix: CRT panel + SoC share one frame buffer (producer/consumer, reader-writer sync) — [H] (→05/10)
• Text editor with undo/redo — [H]
• Lift / elevator management system (FSM + scheduling) — [H] (→10)
• Camera-driver architecture for multiple sensors (HAL + ops tables + registration) — [H] (→07/10)

Part 2 — Prerequisites: ~70 C/C++ base warm-ups (build syntax & capability first)¶

Do these to get fluent again before the harder Part-1 items. Grouped by skill, each group easy → hard. Plain practice — no interview pressure. (Overlaps Part 1 on purpose.)

C — basics & control flow¶

• Print "Hello, World"; read & print an int, float, char, and a string
• Sum and average of an array; find the max and min of an array
• Print 1..n; factorial, Fibonacci, multiplication table (loops)
• Sum of digits, reverse an integer, count digits
• Even/odd, prime check, leap year, largest of three
• Patterns: right triangle, pyramid, number triangle
• GCD/LCM (Euclid) — iterative and recursive

C — functions & recursion¶

• Refactor the above into functions; pass arguments by value
• Recursion: factorial, Fibonacci, GCD, sum of array, power(x,n)
• Tower of Hanoi (classic recursion)

C — pointers¶

• Declare a pointer, take an address, dereference; print an address with %p
• Swap two ints via pointers (pass-by-pointer)
• Walk an array with a pointer (pointer arithmetic); arr[i] == *(arr+i)
• Pointer to pointer; modify a pointer inside a function
• Function pointer: declare one, call a function through it, build a tiny 2-entry dispatch table
• void*: store an int then a float, cast back to print

C — arrays, strings, matrices¶

• Reverse an array in place; linear search; bubble sort; insert/delete an element
• 2D array: sum, transpose, matrix multiply (incl. dynamic 2D array)
• Strings as char[]: your own strlen, strcpy, strcmp, strcat
• Reverse a string; count vowels; to-upper; palindrome check

C — structs, unions, enums¶

• Define a struct; make an array of structs; pass a struct to a function (by value vs pointer)
• Nested struct; typedef a struct; a struct with a pointer member
• Define a union and observe shared storage; define an enum and print it
• Compute sizeof for several structs and explain the padding

C — dynamic memory & storage¶

• malloc + free an int array; calloc; realloc to grow it
• Allocate and free a dynamic 2D array (and avoid the leak on error paths)
• static local counter across calls; const; global vs static global (file scope); extern across two files

C — bitwise & misc¶

• AND/OR/XOR/NOT/shift; set / clear / toggle / test the kth bit
• Count set bits; check power of two; swap without temp (XOR)
• File I/O: write lines to a file, read them back, count words in a file

C++ — I/O, strings, containers¶

• std::cout/std::cin; std::string basics (concat, length, substr, find)
• std::vector: push_back, index, iterate (index loop, range-for, iterator)
• std::map / std::unordered_map: insert, lookup, iterate; std::set; std::pair
• std::sort with a custom comparator (lambda); std::stack, std::queue, std::priority_queue

C++ — classes & objects¶

• Define a class with private data + public methods; getters/setters; the this pointer
• Constructors: default, parameterized, copy constructor, member initializer list; destructor
• static members & methods; const member functions
• References (int&), reference parameters, const references
• Operator overloading: operator+ for a Complex/Vector2, operator<< for printing

C++ — inheritance & polymorphism¶

• Inheritance: base/derived, access specifiers, constructor/destructor order
• Virtual function + override; pure virtual / abstract class; virtual destructor (and why)
• Demonstrate runtime vs compile-time polymorphism (overriding vs overloading/templates)
• Trigger and explain object slicing

C++ — templates, RAII, smart pointers¶

• Function template (max<T>); class template (Stack<T> or Pair<A,B>)
• unique_ptr and shared_ptr basics; show RAII (resource freed in destructor)
• new/delete, new[]/delete[]; a leak, then fix it with a smart pointer
• Exceptions: try/catch/throw; why RAII makes exceptions safe
• A lambda capturing by value vs reference; store one in std::function

C++ — build-a-class capstones (bridge into Part 1)¶

• Implement a dynamic array (vector-lite: push_back with geometric growth)
• Implement a singly linked list class (insert/delete/reverse/print)
• Implement a Stack and a Queue class
• Implement a thread-safe Singleton
• Implement a small LRU cache with std::list + std::unordered_map

Part 3 — Algorithms to understand (explain & trace, not code from scratch)¶

These were asked "for understanding," not to whiteboard from zero. Goal for each: explain the idea, trace a tiny example, state complexity and trade-offs. Cross-refs (→NN) point to the full write-up. Ordered most-asked/foundational first within each group.

P. OS / systems algorithms · the heaviest "explain the algorithm" area at Qualcomm¶

• Deadlock — the 4 Coffman conditions + prevention vs avoidance vs detection+recovery — understand: which condition each strategy breaks (→04)
• Banker's algorithm (deadlock avoidance) — understand: the safety check + resource-request check; "is this state safe?"; complexity ~O(m·n²) (→04)
• Deadlock detection — understand: wait-for graph (single instance) vs resource-allocation graph (multi-instance) cycle detection (→04)
• CPU scheduling: FCFS, SJF/SRTF, Priority, Round Robin (time quantum / time-slicing), weighted RR — understand: draw the Gantt chart, compute waiting/turnaround time; starvation (→04)
• Disk scheduling: FCFS, SSTF, SCAN/C-SCAN, LOOK/C-LOOK — understand: trace head movement, which is "best" and why (the asked Q) (→04, →10)
• Page replacement: FIFO, LRU, Optimal, Clock/second-chance — understand: count page faults on a reference string; Belady's anomaly (→04)
• Demand paging + page-fault handling — understand: the step-by-step fault service path (→04)
• Virtual→physical address translation — understand: paging, multi-level page tables, TLB hit/miss (→04, →09)
• Context switch — understand: what state is saved/restored and why it's costly (→04)
• Priority inversion → priority inheritance / priority ceiling — understand: the bug and the fix (Mars Pathfinder) (→04)
• Producer–consumer (bounded buffer) & reader–writer — understand: the semaphore/mutex/condition-variable solution (→04, →10)
• Dining philosophers — understand: how it deadlocks and the resource-ordering / arbitrator fix (→04)
• Cache coherence (MESI) + cache mapping (direct / set-associative) + LRU eviction — understand: states & invalidation (→09)
• Fault tolerance / redundancy — understand: TMR / N-modular redundancy, heartbeat + failover (the "redundant systems takeover" Q)

Q. Core algorithm techniques (explain idea + complexity)¶

• Big-O notation — best/average/worst, amortized; time-complexity of common operations — [E] (→03)
• Binary search + variants (first/last, rotated, infinite array) — complexity in each scenario (→03)
• Merge sort / quick sort / heap sort — understand: recurrence, pivot & partition, why pivot choice changes quicksort to O(n²), stability (→03)
• Floyd's cycle detection (tortoise & hare) — understand: why the pointers meet (→03)
• KMP string matching — understand: the LPS / failure table → O(n+m) (→01 E3, →03)
• Hashing internals — understand: collision resolution (chaining vs open addressing), load factor, rehash (→03)
• BFS vs DFS — when to use each; topological sort (Kahn's / DFS) (→03)
• Shortest path: Dijkstra & A* — the "Google Maps road-blocks / rerouting" question (→03, →10)
• Dynamic programming — understand: how to recognize it & set up the recurrence (coin change / knapsack) (→03)

R. Compiler & architecture procedures¶

• Phases of a compiler — lexing → parsing → semantic → IR → optimization → codegen — understand: what each phase does (→09)
• Intermediate-code optimization — constant folding, common-subexpression elimination, dead-code elimination
• Instruction pipelining — stages, hazards (structural/data/control), forwarding/stalls (→09)

S. Camera / ISP algorithms (understand the pipeline & each block)¶

• The ISP pipeline raw→output — black-level → demosaic → white balance → denoise → color-correction → gamma/tone-map → sharpen (→05)
• Demosaic / debayer — bilinear interpolation over a Bayer CFA (→05)
• 3A — auto-exposure, auto-white-balance (gray-world), autofocus (contrast vs PDAF) (→05)
• Multi-frame HDR — exposure bracketing → align → merge → tone-map; the challenges (→05)
• Noise reduction — spatial vs temporal vs bilateral/NLM (→05)
• Edge detection — Sobel gradient; the Canny steps (→05)
• Image interpolation — bilinear vs bicubic (incl. "interpolate between two frames") (→05)
• Image segmentation & masking / convolution (→05)
• Video rate/bit-rate control & motion estimation (I/P/B frames) (→05)

T. ML / deep-learning algorithms (explain & derive)¶

• Backpropagation — forward pass + chain-rule gradients (dense and convolutional) (→06)
• Gradient descent — batch / SGD / mini-batch; learning-rate effects (→06)
• Adam optimizer — 1st/2nd moments, bias correction, defaults lr=1e-3, betas=(0.9,0.999) (→06)
• Convolution + receptive field, pooling, batch norm (→06)
• 1×1 convolution — how it reduces computation (channel bottleneck FLOP math) (→06)
• CNN architectures — VGG; Inception (multi-scale + 1×1); ResNet (residual/skip, vanishing gradients) (→06)
• Object detection — R-CNN family vs YOLO (→06)
• Seq2seq encoder–decoder + attention / cross-attention; Whisper conv front-end (→06)
• Audio for ML — STFT → mel filter-bank; SpecAugment / noise augmentation (→06)

Generated from qualcomm_camera_interview_experiences.md. Concepts cross-referenced to the topic guides (→01 C, →02 C++/OOP, →03 DSA, →04 OS, →05 camera, →06 ML, →07 embedded, →08 puzzles, →09 arch, →10 design). Tip: Part 2 to regain fluency → Part 1 top-to-bottom to rebuild coding muscle → Part 3 to lock in the algorithms you only need to explain. Part 3 is concept-recall (best reviewed in the linked topic file), not coding reps.