Odd Even Jump - Practice Coding Problems

Odd Even Jump - Problem

Array Dynamic Programming Stack Sorting Monotonic Stack Ordered Set Hard

Imagine you're a frog hopping across lily pads in a magical pond! 🐸 You're given an integer array arr representing the heights of lily pads. Starting from any pad, you can make a series of jumps following special rules:

Odd-numbered jumps (1st, 3rd, 5th, ...): Jump to the closest pad that's at least as high as your current pad. If multiple pads have the same height, choose the leftmost one.

Even-numbered jumps (2nd, 4th, 6th, ...): Jump to the closest pad that's at most as high as your current pad. If multiple pads have the same height, choose the leftmost one.

Your goal is to reach the last lily pad (index arr.length - 1). A starting position is considered "good" if you can successfully reach the end by following these jumping rules.

Return the number of good starting positions.

Input & Output

example_1.py — Basic Example

$ Input: [10, 13, 12, 14, 15]

› Output: 2

💡 Note: From index 0: 10→12→14→15 (odd→even→odd jumps reach end). From index 2: 12→14→15 (odd→even jumps reach end). From index 4: already at end. Total: 2 good starting positions.

example_2.py — Impossible Jumps

$ Input: [17, 13, 14, 15, 2]

› Output: 2

💡 Note: From index 3: 15→2 (odd jump, but 2 cannot make any valid jumps). Only indices 3 and 4 (the end) are good starting positions.

example_3.py — Single Element

$ Input: [5]

› Output: 1

💡 Note: With only one element, we're already at the end, so there's 1 good starting position.

Constraints

1 ≤ arr.length ≤ 2 × 10⁴
0 ≤ arr[i] < 10⁵
Array values can contain duplicates
Must reach the last index (arr.length - 1) exactly

Visualization

Tap to expand

Understanding the Visualization

Map the Territory

First, the frog studies all lily pads and maps out possible jump destinations using smart algorithms

Work Backwards

Starting from the goal, the frog determines which pads can reach the end

Count Good Starts

Finally, count all starting positions where the frog can successfully complete its journey

Key Takeaway

🎯 Key Insight: The optimal approach processes jump destinations efficiently using monotonic stacks, then uses backward DP to determine reachability in O(n log n) time.

Asked in

G Google 42 a Amazon 28 f Meta 35 ⊞ Microsoft 19

The optimal solution uses monotonic stacks to efficiently find jump destinations and dynamic programming working backwards from the end. Key insight: sort indices by values to process jump destinations in order, then use DP to determine which starting positions can reach the end.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n³)	O(1)	Simulate jumps from each starting position until reaching end or getting stuck
Monotonic Stack + Dynamic Programming	O(n log n)	O(n)	Use monotonic stack to find jump destinations efficiently, then DP to check reachability

Brute Force Simulation — Algorithm Steps

For each starting position i from 0 to n-1
Initialize jump_number = 1 (odd jump first)
While current position < n-1:
- If odd jump: find smallest j > i where arr[j] >= arr[i]
- If even jump: find smallest j > i where arr[j] <= arr[i]
- If no valid jump found, break
- Move to position j, increment jump_number
If we reached the end, increment good_count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin at starting index

Find Next Jump

Search all positions to the right for valid jump

Make Jump

Move to found position or stop if none found

Check End

If at last position, count as good start

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

int oddEvenJumps(int* arr, int n) {
    int goodCount = 0;
    
    for (int start = 0; start < n; start++) {
        int pos = start;
        int jumpNum = 1;
        
        while (pos < n - 1) {
            int nextPos = -1;
            
            if (jumpNum % 2 == 1) { // Odd jump
                int minVal = INT_MAX;
                for (int j = pos + 1; j < n; j++) {
                    if (arr[j] >= arr[pos] && arr[j] < minVal) {
                        minVal = arr[j];
                        nextPos = j;
                    } else if (arr[j] == minVal && j < nextPos) {
                        nextPos = j;
                    }
                }
            } else { // Even jump
                int maxVal = INT_MIN;
                for (int j = pos + 1; j < n; j++) {
                    if (arr[j] <= arr[pos] && arr[j] > maxVal) {
                        maxVal = arr[j];
                        nextPos = j;
                    } else if (arr[j] == maxVal && j < nextPos) {
                        nextPos = j;
                    }
                }
            }
            
            if (nextPos == -1) break;
            
            pos = nextPos;
            jumpNum++;
        }
        
        if (pos == n - 1) goodCount++;
    }
    
    return goodCount;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    int arr[1000];
    int n = 0;
    
    char* token = strtok(input, "[],\n");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", oddEvenJumps(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n starting positions, we may make up to n jumps, each taking O(n) time to find next position

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current position and jump number

✓ Linear Space

28.6K Views

Medium-High Frequency

~35 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler