🚨🚨 Hardcore Leetcode - rm -rf if I fail once 🚨🚨

A self-imposed “LeetCode interview” gauntlet turns into a high-pressure grind: solve two easy, two medium, and two hard problems in one sitting, with zero retries. The core twist is the stakes—failure triggers a destructive “rm -rf /” style wipe of the computer—so every wrong submission becomes existential rather than merely embarrassing. To mimic a real whiteboard interview, the challenge forces a read-and-explain phase plus a 20-minute coding timer per problem, while the streamer keeps switching between whiteboard-style reasoning and rapid JavaScript implementation.

The first easy problem (“Score of a String”) is handled with a straightforward adjacent-character approach: compute each character’s score via ASCII codes, sum the absolute differences across neighboring letters, and validate with sample inputs like “hello” → 13. The streamer emphasizes interview habits—whiteboarding first, then coding once the plan is clear—and repeatedly tests locally to avoid accidental catastrophic execution. The submission succeeds, reinforcing the “dress for success” mindset and pushing momentum into the next tasks.

The second easy (“Maximum Achievable Number”) becomes a logic-and-interpretation battle. The operations allow increasing or decreasing both the number and the parameter T simultaneously, leading the streamer to treat the maximum as effectively num + 2T (with an added guard for T < 1 returning num). Despite confusion over wording—especially whether decreasing the “maximum achievable number” ever makes sense—the solution is submitted and accepted. That win matters because it preserves the “no deletion” streak and keeps the challenge’s psychological pressure intact.

The first medium (“Debounce”) is implemented as a timer-cancel-and-reset mechanism. The streamer builds a debounced wrapper that stores the latest arguments, clears any pending timeout, and schedules execution after T milliseconds—carefully managing closure state so only the most recent call within the window fires. Local tests approximate the timing examples, and the submission is accepted.

The second medium (“Merge Nodes Between Zeros”) is solved by scanning the linked-list-like structure (with zeros as delimiters), accumulating sums between consecutive zeros, and emitting new nodes without zeros in the output. The approach is linear: traverse once, reset the running sum at each delimiter, and build a new list of merged sums.

The first hard (“Unique Paths III”) is the most technically intense section. The streamer attempts a depth-first search that counts all valid paths visiting every non-obstacle square exactly once, using a visited matrix (with obstacles treated as already visited) and backtracking. After debugging boundary conditions and base cases (start/end handling, obstacle skipping, and ensuring all required squares are visited), the hard submission is accepted.

The final hard is “Maximum Score Words.” The streamer tries a recursive search over subsets of words, using letter-frequency accounting to ensure each chosen word can be formed from available letters, and tracking the maximum total score. The implementation is heavily iterative and debug-driven; despite partial local checks and reasoning about ignoring invalid words, the final submission ultimately fails due to time constraints (timeout). The run ends with the streamer still “alive” (no rm -rf), but the challenge collapses on performance rather than correctness—turning the whole interview fantasy into a lesson about algorithmic efficiency under strict time limits.