Beautiful Arrangement

Given an integer n, consider permutations of the integers from 1 through n.
A permutation perm is a beautiful arrangement when, for every 1-indexed position i, at least one of these conditions holds:
perm[i] is divisible by i.
i is divisible by perm[i].
Return the number of beautiful arrangements.

Function
countArrangement(n: int) → int

Examples
Example 1
n = 2
return = 2
The valid arrangements are [1,2] and [2,1]. Each value is compatible with its 1-indexed position.
Example 2
n = 1
return = 1
The only arrangement is [1], and 1 is compatible with position 1.

Constraints
1 <= n <= 15

The trick: don't generate permutations and then check them. Build the arrangement position by position, and at each position i only try unused numbers where num % i == 0 or i % num == 0. Dead branches get cut the moment a placement fails. Track used numbers with a boolean array or a bitmask. The common pitfall is filling values 1..n into positions instead of checking the condition per position, or forgetting the arrangement is 1-indexed, so you test i against the wrong index. A good speedup is filling positions from n down to 1, since high positions have fewer valid candidates and prune sooner. For a cleaner approach, use a bitmask DP where the mask's popcount gives the current position, and memoize on mask. That's O(2^n * n). If the live OA freezes you, StealthCoder can hand you the working solution so you aren't stuck.

If this hits your live OA and you blank, StealthCoder solves it in seconds, invisible to the proctor.