Beautiful Arrangement - Practice Coding Problems

Beautiful Arrangement - Problem

Imagine you're arranging n unique numbers from 1 to n in a special way! A beautiful arrangement is a permutation where every position follows a harmonious rule: either the number divides its position, or the position divides the number.

For example, if n = 2, the arrangement [1, 2] is beautiful because:
• Position 1: number 1 divides position 1 ✓
• Position 2: number 2 divides position 2 ✓

Your mission is to count how many beautiful arrangements are possible for a given n. This is a classic backtracking problem that challenges you to explore all valid permutations efficiently!

Input & Output

example_1.py — Simple Case

$ Input: n = 2

› Output: 2

💡 Note: For n=2, we have numbers [1,2] and positions [1,2]. Valid arrangements: [1,2] (1%1=0, 2%2=0) and [2,1] (2%1=0, 1%2≠0 but 2%1=0). Both work!

example_2.py — Medium Case

$ Input: n = 3

› Output: 3

💡 Note: For n=3, valid arrangements are [1,2,3], [2,1,3], and [3,2,1]. For example, [1,2,3]: pos1 has 1 (1%1=0✓), pos2 has 2 (2%2=0✓), pos3 has 3 (3%3=0✓).

example_3.py — Edge Case

$ Input: n = 1

› Output: 1

💡 Note: For n=1, there's only one arrangement [1] at position [1]. Since 1%1=0, this is beautiful. Count = 1.

Visualization

Tap to expand

Understanding the Visualization

Start at Position 1

Try placing each number 1 to n at position 1, checking divisibility

Move to Next Position

For each valid placement, recurse to the next position with remaining numbers

Prune Invalid Branches

If no number works at current position, backtrack immediately

Count Complete Arrangements

When all positions are filled, increment the solution counter

Key Takeaway

🎯 Key Insight: Backtracking with constraint checking allows us to eliminate entire branches of invalid arrangements early, making the algorithm much faster than brute force permutation generation.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, check n positions for each

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current permutation and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 15
The answer is guaranteed to fit in a 32-bit integer
For n > 10, brute force approaches will timeout

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses backtracking to build beautiful arrangements incrementally. Instead of generating all n! permutations, we try placing numbers at each position and immediately backtrack when the divisibility constraint is violated. This reduces the search space dramatically, achieving O(k) time complexity where k is the number of valid arrangements.

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Permutations	O(n! × n)	O(n)	Generate all n! permutations and count valid ones
Backtracking with Pruning (Optimal)	O(k) where k is number of valid arrangements	O(n)	Build arrangements incrementally, backtrack when constraints violated

Generate All Permutations — Algorithm Steps

Generate all permutations of [1, 2, ..., n]
For each permutation, check every position
Count permutations where all positions satisfy the divisibility rule
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all n! possible arrangements of numbers 1 to n

Test Each Arrangement

For each permutation, check if every position satisfies the divisibility rule

Count Valid Ones

Increment counter for arrangements that pass all position tests

Code -

solution.c — C

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

int isBeautiful(int* perm, int n) {
    for (int i = 0; i < n; i++) {
        int pos = i + 1;
        int num = perm[i];
        if (num % pos != 0 && pos % num != 0) {
            return 0;
        }
    }
    return 1;
}

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

int generatePermutations(int* nums, int start, int n, int* count) {
    if (start == n - 1) {
        if (isBeautiful(nums, n)) {
            (*count)++;
        }
        return *count;
    }
    
    for (int i = start; i < n; i++) {
        swap(&nums[start], &nums[i]);
        generatePermutations(nums, start + 1, n, count);
        swap(&nums[start], &nums[i]);
    }
    return *count;
}

int countArrangement(int n) {
    int* nums = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        nums[i] = i + 1;
    }
    
    int count = 0;
    generatePermutations(nums, 0, n, &count);
    
    free(nums);
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

Generate n! permutations, check n positions for each

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current permutation and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 15
The answer is guaranteed to fit in a 32-bit integer
For n > 10, brute force approaches will timeout

89.2K Views

Medium Frequency

~15 min Avg. Time

2.8K 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

Generate All Permutations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler