Prime Arrangements
You have a list of numbers from 1 to n. You need to arrange these numbers in such a way that prime numbers are at prime numbered positions (starting from 1).
For example, if n=5, one possible arrangement could be [1,2,5,4,3], where the prime numbers 2, 3, and 5 are at the 2nd, 3rd, and 5th positions respectively. However, the arrangement [5,2,3,4,1] is not valid because the prime number 5 is not at a prime numbered position, but at position 1.
Your job is to figure out how many such arrangements are possible and return that count. But the total can be quite large, so we’re interested in the remainder when divided by a large number (1,000,000,007) to avoid overflow.
Python solution:


The problem can be broken down to two tasks. The first is to count the number of primes less than or equal to n, which we do using the Sieve of Eratosthenes algorithm in countPrimes()
. The second task is to compute the factorial of two numbers: the number of primes and the number of nonprimes, which we do using the factorial()
function. Finally, we return the product of these two factorials, modulo 10^9 + 7 to fit the answer within the integer range.
Sieve of Eratosthenes


The function numPrimeArrangements
is designed to find the number of permutations of the first n
positive integers such that the prime numbers are arranged in ascending order and the composite numbers are arranged in ascending order. The result is calculated modulo (10^9 + 7).
Here’s how the function works:
It starts by initializing an array
non
of sizen+1
with all elements set to 0. This array will be used to flag the nonprime numbers (i.e., composite numbers).It initializes
cnt
as a list with two elements [0, 1]. This list will hold the count of nonprime and prime numbers.It initializes
res
to 1. This variable will hold the final result.Then, it iterates over all numbers from 2 to
n
(inclusive). For each numberi
, it checks ifi
is a prime number. Ifi
is a prime number (non[i] == 0
), it marks all multiples ofi
as nonprime (composite) numbers.After identifying whether
i
is prime or not, it increments the respective count incnt
. Then, it multipliesres
with the new count and takes modulo (10^9 + 7).Finally, it returns
res
, which is the number of prime arrangements modulo (10^9 + 7).
The function effectively uses the Sieve of Eratosthenes algorithm to find prime numbers and calculates the factorial of counts of prime and composite numbers in a single pass, resulting in a time complexity of O(n log log n). This time complexity comes from the Sieve of Eratosthenes algorithm used to find all prime numbers up to n
. The space complexity is O(n), where n is the given number, as it creates an array of size n+1
.
The number (10^9 + 7) (or 1_000_000_007
in Python) is a commonly used modulo in many programming problems, especially in competitive programming, for a few reasons:
It is a large prime number: Prime numbers are often used in modulo operations to avoid unintended patterns and ensure a uniform distribution.
It fits within an int: The number (10^9 + 7) is less than (2^{31}  1), which is the maximum value an integer can hold in many programming languages, including Python. This means that the result of a modulo operation will always fit within an int.
It can prevent overflow: When dealing with large numbers, especially factorials, the result can easily exceed the maximum limit of an integer. Taking the modulo helps to keep the number manageable and within limits.
In this particular problem, the result could be very large because the function is essentially calculating the factorial of the count of prime and nonprime numbers. So, to prevent integer overflow and keep the result within the limit, the modulo operation is used.