Adobe Hackathon MCQS 2026

Problem Preview

"Adobe Hackathon MCQS 2026 ## Question 1 A live leaderboard uses a Fenwick tree to maintain scores. During an update, a junior dev wrote: ```cpp void add(int i, int delta) { for (; i <= n; i = i - (i & -i)) bit[i] += delta; } ``` The prefix query is correct, but updates seem to "move backward" and miss indices. Which fix restores the standard BIT update traversal? - [ ] Replace `i = i - (i & -i)` with `i = i + (i & -i)` - [ ] Replace ... - [ ] Replace ... - [ ] Replace ... *(Note: Some options were cut off in the source image)* --- ## Question 2 An R&D system clones linked graphs with next and random references. The developer merges clone nodes into the original list alternately during copy. Which step completes the correct O(1)-space cloning process? - [ ] Assign null to all orig... - [ ] Copy all random p... - [ ] Separate cloned... - [ ] Update next po... *(Note: Options were partially visible in the source image)* --- ## Question 3 A distributed ETL pipeline eagerly merges incoming data chunks greedily by always combining the two smallest files. ```python heapify(files) while len(files) > 1: cost = heappop(files) + heappop(files) total_cost += cost heappush(files, cost) ``` If the dataset is `files = [4, 3, 2, 6]`, what is the exact final `total_cost` reliably computed by this optimal greedy logic? - [ ] 26 - [ ] 15 - [ ] 31 - [ ] 29 --- ## Question 4 You maintain many versions of a Persistent Segment Tree, where multiple versions may share internal nodes. Each version is identified by a separate root pointer. The range query logic is identical to a standard segment tree implementation. ```cpp int query(Node* node, int tl, int tr, int l, int r) { if (!node || l > r) return 0; if (l == tl && r == tr) return node->sum; int tm = (tl + tr) / 2; return query(node->left, tl, tm, l, min(r, tm)) + query(node->right, tm + 1, tr, max(l, tm + 1), r); } ``` - [ ] It begins traversal ... immutable nodes ... - [ ] It checks modifi... introduced by up... - [ ] It dynamically c... the required hi... - [ ] It merges part... array state at... *(Note: Options were partially visible in the source image)* --- ## Question 5 Consider a nested loop where the outer loop index `i` ranges from 1 to `n`, and for each outer iteration, the inner loop index `j` starts at 1 and repeatedly doubles until it exceeds `n`, so the inner loop executes `O(log n)` times. Each inner iteration performs an operation that takes `O(i)` time, where the cost depends on the outer index. What is the overall time complexity of this structure? - [ ] O(n log n) - [ ] O(n^2) - [ ] O(n^3) - [ ] O(n^2 log n) --- ## Question 6 A payments platform reconciles signed ledger deltas where refunds and adjustments can reduce running totals. A senior engineer rejects a sliding-window scan because several valid ranges may include negative values. A reviewer proposes a single pass that tracks cumulative totals and returns any matching contiguous range. A regression appears when lookup order or difference direction is changed around the stored cumulative state. A candidate must complete the marked block so the implementation remains negative-inclusive and linear. ```cpp pair findRange(vector<int>& arr, int target) { unordered_map<int, int> hm; int curr_sum = 0; for (int i = 0; i < arr.size(); i++) { curr_sum += arr[i]; if (curr_sum == target) return {0, i}; // Which missing block best completes the implementation? hm[curr_sum] = i; } return {-1, -1}; } ``` - [ ] Store curr_... stored bou... - [ ] Reset curr_... boundary... - [ ] Check target... stored bo... - [ ] Check curr_sum - target in hm... *(Note: Options were partially visible in the source image)* --- ## Question 7 An analytics service stores an unrooted tree of account transfers and, for every possible root, must compute a subtree aggregate used by a fraud score. Each directed edge value is cached after a DFS call, and a prototype deletes processed adjacency entries so high-degree vertices are not rescanned on every call. The prototype works for a distance-pair aggregate where removing one neighbour's effect is implemented by subtraction. A new product rule changes the merge to an associative operation that has no reliable inverse, while the latency target still requires total linear work and the original adjacency may be copied once but should not be rebuilt per root. The reviewer must decide how to preserve the same directed-edge cache idea without silently dropping or duplicating a neighbour contribution. Which design should replace the inverse-based exclusion step? - [ ] Keep one balanced tree of cached directed-edge states per vertex and update it after every deletion, then query the aggregate excluding a neighbour by removing and reinserting that leaf. - [ ] Keep the accumulated merged state per vertex, replace the queried neighbour contribution with the identity state, and reuse the previous left-fold result without rebuilding surrounding ranges. - [ ] Keep an ordered contribution array per vertex, compute prefix and suffix merged states after local edge-cache changes, and answer each directed exclusion by merging the two ranges around that neighbour. - [ ] Keep deleting adjacency entries as before, but compute the missing parent-side state by one extra DFS from the parent when requested, caching that result for later roots at the same vertex. --- ## Question 8 An optimization review checks a Java solver used only for boards that fit inside a signed integer mask. The service accepts n and compares counts against a trusted slow solver. For n = 4 and n = 5, this version undercounts even though it terminates and never stores board rows. The reviewer is not allowed to replace the approach with arrays or sets and must identify the precise state-transition defect. ```java int solve(int n) { int m = (1 << n) - 1; return dfs(m, 0, 0, 0); } int dfs(int m, int d1, int col, int d2) { if (col == m) { return 1; } int open = m & ~(d1 | col | d2); int total = 0; while (open != 0) { int bit = open & -open; open ^= bit; total += dfs(m, (d1 | bit) << 1, col | bit, (d2 | bit) << 1); } return total; } ``` - [ ] This candidate bit is removed with XOR before recursion; low-bit removal should happen only after recursive return to keep the current placement visible across deeper levels. - [ ] One diagonal conflict mask is advanced in the same direction as the other after a placement; opposing attack rays must be projected to opposite neighboring columns before the next row is evaluated. - [ ] The terminal check compares column occupancy with the board mask; the solver should instead stop by tracked depth so partial states cannot be accepted as completed boards. - [ ] The availability expression complements conflicts before applying the board mask; it should apply the mask first so high unused bits cannot influence the candidate scan. ## Question 9 A compliance platform imports partner-provided binary trees as candidate search indexes before enabling range-based reads. The validator must reject duplicate keys, preserve strict ordering across every descendant relationship, and handle keys equal to `Integer.MIN_VALUE` or `Integer.MAX_VALUE` without sentinel collisions. A recent incident passed a tree where a lower descendant satisfied its immediate parent but crossed an ordering boundary created several levels above, causing range queries to skip live records. The reviewer now compares Java helpers used by `validate(root)` and wants the implementation that accepts exactly valid search indexes, rejects ancestor-boundary violations, and avoids modifying nodes or building an inorder list. Which helper should be accepted? - [ ] ```java boolean ok(TreeNode x, long lo, long hi) { if (x == null) return true; if (x.left != null && x.left.val >= x.val) return false; if (x.right != null && x.right.val <= x.val) return false; return ok(x.left, lo, hi) && ok(x.right, lo, hi); } ``` - [ ] ```java boolean ok(TreeNode x, long lo, long hi) { if (x == null) return true; if (x.val <= lo || x.val >= hi) return false; return ok(x.left, lo, x.val) && ok(x.right, x.val, hi); } ``` - [ ] ```java boolean ok(TreeNode x, long lo, long hi) { if (x == null) return true; if (x.val >= lo || x.val <= hi) return false; return ok(x.left, lo, x.val) && ok(x.right, lo, hi); } ``` - [ ] ```java boolean ok(TreeNode x, long lo, long hi) { if (x == null) return true; if (x.val < lo || x.val > hi) return false; return ok(x.left, lo, x.val) && ok(x.right, x.val, hi); } ``` --- ## Question 10 A team integrates Dinic's algorithm into a traffic-routing engine. Flow occasionally exceeds edge capacity invariants after multiple phases. DFS code: ```cpp int dfs(int u, int pushed) { if (pushed == 0) return 0; for (auto &e : adj[u]) { if (e.cap > 0) { int tr = dfs(e.to, min(pushed, e.cap)); if (tr) { e.cap -= tr; adj[e.to][e.rev].cap += tr; return tr; } } } return 0; } ``` BFS builds `level[]` correctly. Which missing condition is directly responsible for violating Dinic's correctness? - [ ] `level[e.to] == level[u] + 1` - [ ] `pushed > 0` - [ ] `u == sink` - [ ] `e.rev >= 0` --- ## Question 11 A cloud storage system uses a trie to index filenames. Users frequently search for partial matches (e.g., "*doc*" for "document.pdf"). The current implementation traverses the entire trie for wildcard queries, causing latency. Which optimization reduce"