Maximum Array Hopping Score II
A medium-tier problem at 57% community acceptance, tagged with Array, Stack, Greedy. Reported in interviews at Zluri and 0 others.
Maximum Array Hopping Score II is a medium-difficulty array problem with a 57% acceptance rate that Zluri has asked in their assessment. The trap is obvious: greedy approaches fail because local maxima don't lead to global optimal scores. You need to recognize that a monotonic stack lets you efficiently track which elements matter for future jumps. If this problem blindsides you during your live OA, StealthCoder surfaces a working solution in seconds, invisible to the proctor.
Companies that ask "Maximum Array Hopping Score II"
Maximum Array Hopping Score II is the kind of problem that decides whether you pass. StealthCoder reads the problem on screen and surfaces a working solution in under 2 seconds. Invisible to screen share. The proctor sees nothing. Built because the OA filter rejects engineers who'd pass the on-site. That's a broken filter. This is the workaround.
Get StealthCoderThe core trick is that you can't just jump to the largest element or the farthest reachable position. You need to compute, for each position, what score you can accumulate by hopping forward. A monotonic stack works here because as you scan right, you maintain a decreasing (or increasing, depending on formulation) sequence of indices. When a new element violates the property, you pop and calculate its contribution. The greedy stumble most candidates hit is forgetting that score comes from the element you land on plus the optimal future score from there, not from visibly picking the best next jump. Stack approach lets you compute this in one pass without backtracking.
Pattern tags
You know the problem.
Make sure you actually pass it.
Maximum Array Hopping Score II recycles across companies for a reason. It's medium-tier, and most candidates blank under the timer. StealthCoder is the hedge: an AI overlay invisible during screen share. It reads the problem and surfaces a working solution in under 2 seconds. Built because the OA filter rejects engineers who'd pass the on-site. That's a broken filter. This is the workaround. Works on HackerRank, CodeSignal, CoderPad, and Karat.
Maximum Array Hopping Score II interview FAQ
Is this really a 57% acceptance problem or harder?+
The stated acceptance rate is 57%, but that includes candidates who immediately recognize the monotonic stack pattern. If you don't see it quickly, the problem feels much harder because greedy attempts lead nowhere. Stack insight is the dividing line.
What makes the greedy approach fail?+
Greedy candidates pick the next-largest element or farthest reachable position. This maximizes immediate reward but locks you into suboptimal paths. The problem requires balancing current score with future optionality. Stack-based DP respects this trade-off; greedy doesn't.
Why monotonic stack and not standard DP?+
Standard DP is O(n^2) because each position checks all reachable positions ahead. Monotonic stack reduces it to O(n) by maintaining useful candidates as you scan. The stack itself tells you which positions matter for future scores.
How does this relate to the Array and Greedy topics?+
It's fundamentally an array problem, but the greedy topic signals a trap: greedy doesn't work here. The lesson is recognizing when greedy fails and when you need a smarter traversal like monotonic stack to extract structure.
Does Zluri ask this in every coding round?+
Zluri is listed as the only company reporting this problem, so it's not a high-frequency FAANG question. But if you're interviewing there and haven't drilled monotonic stacks, this is exactly the kind of problem you could blank on.
Want the actual problem statement? View "Maximum Array Hopping Score II" on LeetCode →