Prime Arrangements

Prime Arrangements - Problem

Math Easy

Return the number of permutations of 1 to n so that prime numbers are at prime indices (1-indexed).

Recall that an integer is prime if and only if it is greater than 1, and cannot be written as a product of two positive integers both smaller than it.

Since the answer may be large, return the answer modulo 10^9 + 7.

Input & Output

Example 1 — Small Case

$ Input: n = 5

› Output: 12

💡 Note: For n=5, we have primes [2,3,5] and non-primes [1,4]. Prime positions are [2,3,5] and non-prime positions are [1,4]. We can arrange 3 primes in 3 prime positions in 3! = 6 ways, and 2 non-primes in 2 non-prime positions in 2! = 2 ways. Total = 6 × 2 = 12.

Example 2 — Minimum Case

$ Input: n = 1

› Output: 1

💡 Note: For n=1, there's only number 1 (non-prime) at position 1 (non-prime). Only one valid arrangement: [1]. Result = 1! = 1.

Example 3 — Even Case

$ Input: n = 4

› Output: 4

💡 Note: For n=4, primes are [2,3] and non-primes are [1,4]. Prime positions are [2,3] and non-prime positions are [1,4]. Arrangements = 2! × 2! = 2 × 2 = 4.

Constraints

1 ≤ n ≤ 100

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that prime numbers must be placed at prime positions and non-prime numbers at non-prime positions. We count how many primes exist from 1 to n, then calculate the arrangements as (prime_count)! × (non_prime_count)!. Best approach is the mathematical formula with Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate all n! permutations of numbers 1 to n, then check each permutation to see if all prime numbers are at prime indices (1-indexed). Count the valid permutations.

Mathematical Formula - Count and Arrange

⏱️ Time: O(n) Space: O(1)

The key insight is that prime numbers must go in prime positions and non-prime numbers must go in non-prime positions. We can count how many primes and non-primes there are, then arrange each group independently using factorial.

Brute Force - Try All Permutations — Algorithm Steps

Step 1: Generate all permutations of [1,2,...,n]
Step 2: For each permutation, check if primes are at prime positions
Step 3: Count valid permutations and return count mod 10^9+7

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all permutations of [1,2,3,4,5]

Validate

Check if primes are at prime positions

Count

Count valid arrangements

Code -

solution.c — C

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

#define MOD 1000000007

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

bool isValidPermutation(int* perm, int n) {
    for (int i = 0; i < n; i++) {
        int pos = i + 1; // 1-indexed position
        if (isPrime(perm[i]) != isPrime(pos)) {
            return false;
        }
    }
    return true;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int generatePermutations(int* arr, int start, int n) {
    if (start == n) {
        return isValidPermutation(arr, n) ? 1 : 0;
    }
    
    int count = 0;
    for (int i = start; i < n; i++) {
        swap(&arr[start], &arr[i]);
        count += generatePermutations(arr, start + 1, n);
        swap(&arr[start], &arr[i]);
    }
    return count;
}

int solution(int n) {
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        nums[i] = i + 1;
    }
    
    int result = generatePermutations(nums, 0, n);
    free(nums);
    return result % MOD;
}

int main() {
    int n;
    scanf("%d", &n);
    
    int result = solution(n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, each taking O(n) to validate

✓ Linear Growth

Space Complexity

O(n)

Store current permutation array and recursion stack

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

856 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 - Try All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler