Prime Pairs With Target Sum - Practice Coding Problems

Prime Pairs With Target Sum - Problem

Prime Pairs With Target Sum

You are given an integer n. Your task is to find all pairs of prime numbers that add up to n.

A prime pair (x, y) must satisfy:
• Both x and y are prime numbers
• 1 ≤ x ≤ y ≤ n
• x + y = n

Return a 2D array containing all valid prime pairs [x, y], sorted by increasing order of x. If no prime pairs exist, return an empty array.

Note: A prime number is a natural number greater than 1 that has exactly two factors: 1 and itself.

Input & Output

example_1.py — Basic case

$ Input: n = 12

› Output: [[5,7]]

💡 Note: The prime numbers ≤ 12 are: 2, 3, 5, 7, 11. Only the pair (5, 7) satisfies: 5 + 7 = 12, both are prime, and 5 ≤ 7.

example_2.py — Multiple pairs

$ Input: n = 18

› Output: [[5,13],[7,11]]

💡 Note: Prime pairs that sum to 18: (5,13) and (7,11). Both pairs satisfy all conditions and are returned in ascending order of the first element.

example_3.py — No pairs exist

$ Input: n = 3

› Output: []

💡 Note: No two prime numbers can sum to 3. The only prime ≤ 3 is 2, and 2 + 2 = 4 ≠ 3. Also, we need x ≤ y, so pairs like (1,2) are invalid since 1 is not prime.

Visualization

Tap to expand

Understanding the Visualization

Sieve Creation

Mark all composite numbers, leaving only primes

Prime Collection

Gather all prime numbers in efficient data structure

Pair Matching

Use optimal strategy (hash lookup or two pointers) to find sum pairs

Key Takeaway

🎯 Key Insight: Precomputing primes with the Sieve of Eratosthenes transforms an O(n²√n) brute force approach into an efficient O(n log log n) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n log log n)

Sieve takes O(n log log n), finding pairs takes O(π(n)) where π(n) is the number of primes ≤ n

⚡ Linearithmic

Space Complexity

O(n)

Space for sieve array and hash set to store primes

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁶
n is guaranteed to be a positive integer
Time limit: 2 seconds per test case

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses the Sieve of Eratosthenes to efficiently generate all prime numbers up to n in O(n log log n) time, then applies either a hash set lookup or two pointers technique to find pairs that sum to the target. This approach significantly outperforms the brute force method by avoiding repeated prime checking.

Common Approaches

Approach	Time	Space	Notes
✓ Sieve + Hash Set	O(n log log n)	O(n)	Precompute all primes using Sieve of Eratosthenes, then find pairs efficiently
Brute Force (Check All Pairs)	O(n²√n)	O(1)	Check every possible pair and verify if both numbers are prime
Sieve + Two Pointers	O(n log log n)	O(n)	Generate primes with sieve, then use two pointers on sorted prime array

Sieve + Hash Set — Algorithm Steps

Generate all prime numbers up to n using Sieve of Eratosthenes
Store all primes in a hash set for O(1) lookup
Iterate through each prime p in ascending order
For each prime p, calculate complement = n - p
If complement is prime and p ≤ complement, add [p, complement] to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Sieve Generation

Create boolean array and mark non-primes

Prime Collection

Store all primes in hash set for O(1) lookup

Pair Finding

For each prime, check if complement exists

Code -

solution.c — C

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

int main() {
    int n;
    scanf("%d", &n);
    
    if (n < 4) {
        printf("[]\n");
        return 0;
    }
    
    // Sieve of Eratosthenes
    bool* isPrime = (bool*)malloc((n + 1) * sizeof(bool));
    memset(isPrime, true, (n + 1) * sizeof(bool));
    isPrime[0] = isPrime[1] = false;
    
    for (int i = 2; i * i <= n; i++) {
        if (isPrime[i]) {
            for (int j = i * i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
    
    // Find and print prime pairs
    printf("[");
    bool first = true;
    for (int p = 2; p <= n / 2; p++) {
        if (isPrime[p]) {
            int complement = n - p;
            if (complement <= n && isPrime[complement] && p <= complement) {
                if (!first) printf(",");
                printf("[%d,%d]", p, complement);
                first = false;
            }
        }
    }
    printf("]\n");
    
    free(isPrime);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log log n)

Sieve takes O(n log log n), finding pairs takes O(π(n)) where π(n) is the number of primes ≤ n

⚡ Linearithmic

Space Complexity

O(n)

Space for sieve array and hash set to store primes

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁶
n is guaranteed to be a positive integer
Time limit: 2 seconds per test case

73.5K Views

Medium Frequency

~15 min Avg. Time

1.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sieve + Hash Set — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler