Prime Jumps Hackerrank Solution GitHub

Understanding the Prime Jumps Problem

The HackerRank Prime Jumps problem asks you to find the minimum number of jumps from position 0 to position n, where each jump must land on a prime-numbered position. You start at 0, and every jump moves you forward by exactly one step to the next available prime. So from 0 you'd jump to 2 (the first prime), then to 3, then 5, then 7, and so on. The answer is simply how many primes are less than or equal to n. That's actually the straightforward version. Some variations of this problem on HackerRank make it slightly more complex by allowing you to jump from any current prime position to any later prime position, and they ask for the minimum number of jumps to reach position n even if n itself isn't prime (in which case you overshoot to the smallest prime >= n). But the core idea stays the same: you need a fast way to enumerate primes and then count or select among them.

Prime Jumps Hackerrank Solution GitHub

If you want to look at my full implementation, it's up on GitHub under the repo name that includes this phrase. You'll find the Python solution, a C++ version, and some test cases that I used when I was debugging edge conditions. The repo also has a README that explains how to run each solution locally against sample inputs. Here's how I approach it in practice, because the naive method breaks down quickly.

The Sieve Approach

A naive trial-division primality test for every number up to n runs in roughly O(n * sqrt(n)) time. For HackerRank constraints where n can reach 10^6 or higher, that's going to time out. You need the Sieve of Eratosthenes, which runs in O(n log log n) and precomputes all primes up to n in one pass. Here's the sieve implementation I use:

def sieve_of_eratosthenes(n):
    is_prime = [True] * (n + 1)
    is_prime[0] = is_prime[1] = False
    for i in range(2, int(n0.5) + 1):
        if is_prime[i]:
            for j in range(i*i, n + 1, i):
                is_prime[j] = False
    return is_prime

This builds a boolean array where each index tells you whether that number is prime. After running this once, you can answer "is x prime?" in O(1) time for the rest of your solution. That's the critical optimization — one upfront cost, then free lookups. After sieving, finding the answer is just counting or selecting from the primes. For the standard version where you jump from prime to consecutive prime, you simply count how many True values exist in is_prime[1:n+1]. For the version where you can skip primes, you find the smallest index i where is_prime[i] is true and i >= n, then figure out the minimum jumps from the sequence of primes up to that point.

Common Pitfalls I've Encountered

The first issue people run into is the boundary condition at n = 1. The sieve correctly marks 1 as not prime, so the count of primes from 1 to 1 is zero. But some problem variants expect a different behavior here — a few HackerRank submissions fail their hidden test cases because the problem setter considers position 1 reachable in zero jumps from itself, while others expect an error or a special case. Check the problem statement carefully. The wording around "starting position" and "target position" will tell you whether n = 1 returns 0 or is invalid. Another issue I hit recently involved memory limits. On one version of the problem, n went up to 10^7, and my boolean array approach consumed about 10 MB, which was fine. But when I switched to a set-based prime storage for a variation, the overhead pushed it over the limit. If you're working near the memory ceiling, stick with the boolean array. Python's bytearray type is a good middle ground — it uses one byte per entry instead of the full object overhead of a regular list of booleans.

def sieve_bytearray(n):
    is_prime = bytearray([1]) * (n + 1)
    is_prime[0] = is_prime[1] = 0
    for i in range(2, int(n0.5) + 1):
        if is_prime[i]:
            is_prime[i*i:n+1:i] = bytearray([0]) * len(range(i*i, n+1, i))
    return is_prime

This slice-assignment trick is significantly faster in Python than nested loops and uses roughly 1/8th the memory of a regular list of integers. It's also the version that passed all test cases in the tightest time limit I've seen on this problem. There's a useful theorem worth knowing: any integer >= 2 can be expressed as a sum of at most three primes (this is related to the weak Goldbach conjecture, proved by Helfgott in 2013). In the context of the jump problem, this means the answer for most values of n will be a small number. If you can jump from any prime to any later prime, the maximum answer you'll ever see for n up to 10^6 is around 3 or 4, because you can reach any position with just a handful of prime-sized jumps. But don't rely on this theorem for your solution. The problem is still solvable with pure sieve + counting, and bringing in advanced number theory doesn't improve your runtime. It does help you sanity-check your answers though. If your solution returns 15 for n = 1000, something is wrong, because the theoretical maximum is tiny.

Putting It Together

Here's the complete solution for the standard version: Time complexity: O(n log log n). Space complexity: O(n) bytes. For n = 10^6 this runs in well under a second in Python and barely registers in C++. The byte array slice assignment in particular is what makes the Python version competitive — without it, the inner loop alone would be too slow for the larger test cases. I've also seen people try to optimize by only sieving odd numbers, cutting memory in half. It works but adds complexity to the indexing logic and the final count. For HackerRank's constraints, the straightforward bytearray approach is usually faster to write and less prone to off-by-one errors under time pressure.

The GitHub repo I linked earlier contains this solution plus a C++ port, a Java version, and a set of corner-case tests including n = 0, n = 1, n = 2, and the maximum input size. If you're getting WA on specific test cases, comparing your output against my test runner is probably the fastest way to find the discrepancy.