Number of Self-Divisible Permutations - Practice Coding Problems

Number of Self-Divisible Permutations - Problem

Array Math Dynamic Programming Backtracking Bit Manipulation Number Theory Bitmask Medium

Given an integer n, return the number of self-divisible permutations of the 1-indexed array nums = [1, 2, 3, ..., n].

A 1-indexed array a of length n is self-divisible if for every 1 <= i <= n, gcd(a[i], i) == 1 (where gcd is the greatest common divisor).

A permutation of an array is a rearrangement of its elements. For example, the permutations of [1, 2, 3] are: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1].

Input & Output

Example 1 — Small Case

$ Input: n = 2

› Output: 1

💡 Note: Array is [1,2]. For [1,2]: gcd(1,1)=1 ✓, gcd(2,2)=2 ✗. For [2,1]: gcd(2,1)=1 ✓, gcd(1,2)=1 ✓. Only 1 valid arrangement.

Example 2 — Larger Case

$ Input: n = 3

› Output: 2

💡 Note: Need gcd(a[i], i) = 1 for all i. Valid arrangements: [2,1,3] and [3,1,2]. All other permutations fail the GCD constraint.

Example 3 — Edge Case

$ Input: n = 1

› Output: 1

💡 Note: Array is [1]. Only arrangement [1]: gcd(1,1)=1 ✓. One valid permutation.

Constraints

1 ≤ n ≤ 15

Visualization

Tap to expand

Understanding the Visualization

Input

Array [1,2,3,...,n] to permute

Constraint

gcd(a[i], i) = 1 for all positions

Output

Count of valid arrangements

Key Takeaway

🎯 Key Insight: Pre-compute valid number placements based on GCD constraint to prune search space efficiently

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to use backtracking with precomputed valid placements based on GCD constraints. Best approach uses memoization with bitmask to cache subproblems and avoid recomputation. Time: O(n² × 2ⁿ), Space: O(n × 2ⁿ)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Backtracking	O(n! × n)	O(n)	Generate all permutations and count valid ones
Memoization with Bitmask	O(n² × 2ⁿ)	O(n × 2ⁿ)	Cache results using bitmask to represent used numbers
Optimized Backtracking	O(n! × log(max(n)))	O(n²)	Check GCD constraint while building permutation

Brute Force Backtracking — Algorithm Steps

Generate all n! permutations
For each permutation, check if gcd(a[i], i) == 1 for all i
Count valid permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible permutations

Check

Verify GCD constraint for each

Count

Sum valid permutations

Code -

solution.c — C

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

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int backtrack(int pos, int n, bool* used, int* perm) {
    if (pos > n) {
        // Check if current permutation is valid
        for (int i = 1; i <= n; i++) {
            if (gcd(perm[i], i) != 1) {
                return 0;
            }
        }
        return 1;
    }
    
    int count = 0;
    for (int num = 1; num <= n; num++) {
        if (!used[num]) {
            used[num] = true;
            perm[pos] = num;
            count += backtrack(pos + 1, n, used, perm);
            used[num] = false;
        }
    }
    
    return count;
}

int solution(int n) {
    bool* used = (bool*)calloc(n + 1, sizeof(bool));
    int* perm = (int*)calloc(n + 1, sizeof(int));
    int result = backtrack(1, n, used, perm);
    free(used);
    free(perm);
    return result;
}

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)

n! permutations, each requiring n GCD checks

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and current permutation array

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~30 min Avg. Time

845 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 Backtracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler