Tip 1: Solve at least 300 quality DSA problems from varied topics.
Tip 2: Participate regularly in timed coding contests to improve speed and accuracy.
Tip 3: Revise core concepts periodically and focus on understanding problem patterns, not just solutions.
Tip 1: Showcase strong projects that demonstrate problem-solving and development skills.
Tip 2: Keep your resume concise, relevant, and completely truthful.
The online assessment was 90 minutes long, conducted on the DoSelect platform with proctoring enabled to ensure fairness. It consisted of 4 challenging DSA problems, all of which were hard-level. The environment was serious and focused, as every participant was aware of the difficulty level and the limited time available.

Step 1: Modelled it as a constrained shortest path on an expanded state space. A state is (node u, totalLatency t). The priority queue key is the total toll so far.
Step 2: Initialization: push (1,0) with cost = toll[1].
Step 3: Pop the lowest-toll state; if we’ve already seen a cheaper toll for (u,t), skip.
Step 4: Relax every edge (u,v,w): if t+w ≤ maxL, push (v, t+w) with newCost = curCost + toll[v].
Step 5: Prune dominated states: for each node, if we already achieved latency t′ ≤ t with toll ≤ newCost, skip pushing.
Step 6: Answer = min over t≤maxL of best[n][t]; if none exists, return −1.
(Think “Dijkstra on (node,time) with domination pruning”, exactly how LC-1928 is solved.)

Step 1: Observed the two trips can be modeled as two people walking from (0,0) to (n−1,m−1) simultaneously in k steps (0..n+m−2), each moving right or down.
Step 2: DP state: dp[k][r1][r2] = max value after k moves when walkers are at (r1,c1=k−r1) and (r2,c2=k−r2). If any cell is blocked, state = −∞.
Step 3: Transition from four predecessors at step k−1: (r1−1,r2−1), (r1−1,r2), (r1,r2−1), (r1,r2). Add grid[r1][c1] + grid[r2][c2] (but if same cell, add once).
Step 4: Initialize dp[0][0][0] = grid[0][0] if not blocked.
Step 5: Result = max(0, dp[n+m−2][n−1][n−1]); if it’s −∞, return 0.
(Time O((n+m)·n·n), space can be rolled to O(n²).)

Step 1: Count frequencies; let n = |s| and maxf = max character frequency.
Step 2: By pigeonhole principle, at least max(0, 2·maxf − n) positions must match (a majority letter can’t be fully displaced).
Step 3: Therefore the maximum mismatches = n − minimal matches = min(n, 2·(n − maxf)).
(Constructive idea if needed) Sort indices by character blocks and rotate one block by maxf positions; then greedily swap any residual matches.
This gives O(n) counting + O(n log σ) or O(n) construction, and matches examples (e.g., if maxf ≤ ⌊n/2⌋, answer = n).

Step 1: Framed it as building an optimal binary prefix tree where left edges (‘A’) cost 1 and right edges (‘B’) cost 2; leaves correspond to symbols, minimizing Σ p[i]·(sum of edge costs on its root→leaf path).
Step 2: Used the standard unequal-letter-cost approach: compute target code “lengths” via a Shannon-like bound using the generalized Kraft inequality. For costs {1,2}, the base φ solves φ⁻¹ + φ⁻² = 1 ⇒ φ = (1+√5)/2. Set preliminary lengths ℓᵢ ≈ ⌈log_φ(1/pᵢ)⌉.
Step 3: Applied a package-merge / DP adjustment so that the multiset {ℓᵢ} satisfies the Kraft constraint for costs {1,2}, then assigned canonical codes by growing the A/B tree (no code is a prefix of another; if any code is exactly “A”, all others must begin with ‘B’).
Step 4: Verified on examples (e.g., p = [0.5, 0.3, 0.2]) we can emit {A, BA, BB} or {B, AA, AB}—both achieve the same optimal expected time.
The interview happened in the afternoon in a calm and focused environment. The interviewer was friendly, gave hints when needed, and wanted clear, optimized answers. The round was about one hour long with two hard coding problems. I fully solved the first problem using both recursion and an iterative method. For the second problem, I explained my approach but didn’t get time to write the full code.

Step 1: Saw that it followed a repeated pattern that could be solved using recursion.
Step 2: Wrote a recursive solution to find the parent’s value from the previous row.
Step 3: Also wrote an iterative version to avoid too many recursive calls.

This round was in the afternoon in a serious and focused environment. The interviewer was polite but expected very strong problem-solving skills. The questions were extremely hard. I could only explain the approach for the first problem and couldn’t solve the second. The round lasted about one hour.

Step 1: Understood that the tree structure and distances mattered.
Step 2: Planned to remove extra edges and trim leaves without coins to reduce the search space.
Step 3: Thought of using BFS or DFS to count only the required paths.
Step 4: Could explain the logic to the interviewer but couldn’t finish coding due to time.

Tip 1: Recognized this as a dynamic programming problem with overlapping subproblems.
Tip 2: Considered using a 3D DP approach (index range + extra boxes count).

Here's your problem of the day
Solving this problem will increase your chance to get selected in this company
What is recursion?