Prime Arrangements - Practice Coding Problems

Prime Arrangements - Problem

Math Easy

Imagine you have numbers from 1 to n and you want to arrange them in a line. But here's the twist: you want prime numbers to sit in prime positions (using 1-based indexing)!

Your task is to count how many different ways you can arrange the numbers 1, 2, 3, ..., n such that whenever a number is prime, it must be placed at a prime-numbered position.

Example: For n=5, the numbers are [1,2,3,4,5]. Prime numbers are {2,3,5} and prime positions are {2,3,5}. So primes must go in prime positions, and non-primes {1,4} must go in non-prime positions {1,4}.

Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic Case

$ Input: n = 5

› Output: 12

💡 Note: Numbers [1,2,3,4,5]: Primes {2,3,5} must go to prime positions {2,3,5}, non-primes {1,4} to positions {1,4}. Arrangements: 3! × 2! = 6 × 2 = 12.

example_2.py — Small Case

$ Input: n = 2

› Output: 1

💡 Note: Numbers [1,2]: Prime {2} must go to prime position {2}, non-prime {1} to position {1}. Only one valid arrangement: [1,2].

example_3.py — Edge Case

$ Input: n = 1

› Output: 1

💡 Note: Only number [1]: Since 1 is not prime and position 1 is not prime, there's exactly one valid arrangement: [1].

Visualization

Tap to expand

Understanding the Visualization

Identify VIPs

Count how many VIP guests (prime numbers) we have

Count VIP Seats

Count how many VIP seats (prime positions) are available

Arrange VIPs

VIP guests can be arranged among VIP seats in VIP_count! ways

Arrange Regular Guests

Regular guests can be arranged among regular seats in regular_count! ways

Multiply Results

Total arrangements = VIP_arrangements × regular_arrangements

Key Takeaway

🎯 Key Insight: This is a combinatorial problem where we separate the constraints - primes must go to prime positions, non-primes to non-prime positions. The total arrangements are simply the product of arrangements within each group!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count primes + O(n) to calculate factorials

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting and calculation

✓ Linear Space

Constraints

1 ≤ n ≤ 100
Time limit: 1 second
Return answer modulo 10⁹ + 7

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses combinatorial mathematics: count prime numbers and prime positions (which are equal), then calculate prime_count! × non_prime_count! since primes can only be arranged among prime positions and non-primes among non-prime positions. This achieves O(n) time complexity instead of the brute force O(n!) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all n! permutations and count valid ones
Optimal: Count Primes and Calculate Factorials	O(n)	O(1)	Count primes, then multiply factorials of prime and non-prime counts

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all possible permutations of numbers 1 to n
For each permutation, check if prime numbers are at prime positions
Count and return valid permutations modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create one possible arrangement of 1 to n

Check Validity

Verify if primes are in prime positions

Count Valid

If valid, increment counter

Repeat

Continue for all n! permutations

Code -

solution.c — C

#include <stdio.h>
#include <math.h>
#include <stdbool.h>

#define MOD 1000000007

bool isPrime(int num) {
    if (num < 2) return false;
    for (int i = 2; i <= (int)sqrt(num); i++) {
        if (num % i == 0) return false;
    }
    return true;
}

bool isValidArrangement(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        int pos = i + 1;
        if (isPrime(arr[i]) != isPrime(pos)) {
            return false;
        }
    }
    return true;
}

void swap(int arr[], int i, int j) {
    int temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

void generatePermutations(int arr[], int n, int start, int* result) {
    if (start == n) {
        if (isValidArrangement(arr, n)) {
            *result = (*result + 1) % MOD;
        }
        return;
    }
    
    for (int i = start; i < n; i++) {
        swap(arr, start, i);
        generatePermutations(arr, n, start + 1, result);
        swap(arr, start, i);
    }
}

int numPrimeArrangements(int n) {
    int numbers[n];
    for (int i = 0; i < n; i++) {
        numbers[i] = i + 1;
    }
    
    int result = 0;
    generatePermutations(numbers, n, 0, &result);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, check each in O(n) time

⚠ Quadratic Growth

Space Complexity

O(n)

Space for recursion stack and current permutation

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 100
Time limit: 1 second
Return answer modulo 10⁹ + 7

28.4K Views

Medium Frequency

~15 min Avg. Time

832 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

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler