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
How do you remove whitespace from the start of a string?