Beautiful Arrangement II - Practice Coding Problems

Beautiful Arrangement II - Problem

Array Math Medium

Beautiful Arrangement II is a fascinating array construction problem that challenges you to create a specific pattern of differences between adjacent elements.

🎯 The Challenge: Given two integers n and k, you need to construct an array of n different positive integers (ranging from 1 to n) such that the absolute differences between adjacent elements produce exactly k distinct values.

📊 What you're doing: If your array is [a₁, a₂, a₃, ..., aₙ], then the difference array [|a₁ - a₂|, |a₂ - a₃|, |a₃ - a₄|, ..., |aₙ₋₁ - aₙ|] must contain exactly k unique values.

Example: For n=4, k=2, one valid answer is [1,2,4,3] because the differences are [1,2,1] which has exactly 2 distinct values: {1, 2}.

Input & Output

example_1.py — Basic Case

$ Input: n = 4, k = 2

› Output: [1, 4, 2, 3]

💡 Note: The differences are |1-4|=3, |4-2|=2, |2-3|=1. We have 3 differences but only 2 distinct values {2, 3} if we consider the optimal construction pattern. Actually, this gives us {1, 2, 3} which has 3 distinct values. A better answer is [1, 2, 4, 3] giving differences [1, 2, 1] with exactly 2 distinct values: {1, 2}.

example_2.py — Minimum Case

$ Input: n = 3, k = 1

› Output: [1, 2, 3]

💡 Note: When k=1, we need exactly 1 distinct difference. The array [1, 2, 3] gives differences [1, 1], which has exactly 1 distinct value: {1}.

example_3.py — Maximum Differences

$ Input: n = 5, k = 4

› Output: [1, 5, 2, 4, 3]

💡 Note: Using the alternating pattern: differences are |1-5|=4, |5-2|=3, |2-4|=2, |4-3|=1. This gives us exactly 4 distinct values: {1, 2, 3, 4}.

Visualization

Tap to expand

Understanding the Visualization

🎼 Set the Range

Like a piano with keys 1 to n, position your hands at both ends

🎹 Alternate Extremes

Play alternating high-low pattern: creates maximum interval variety efficiently

📊 Count Intervals

Each alternation creates a new interval size: n-1, n-2, n-3, etc.

🎵 Fill with Scale

Once you have k intervals, complete the melody with a simple scale

Key Takeaway

🎯 Key Insight: The alternating extremes pattern is like creating dramatic musical intervals - by jumping between the highest and lowest available notes, we efficiently generate exactly the number of distinct intervals we need, then complete the melody smoothly.

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to check differences

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current permutation and set to track differences

⚡ Linearithmic Space

Constraints

1 ≤ k < n ≤ 10⁴
The array must contain all integers from 1 to n exactly once
k must be less than n (since maximum possible distinct differences is n-1)

Asked in

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

The optimal solution uses a clever alternating extremes pattern to construct the array efficiently. By alternating between the smallest and largest unused numbers for the first k+1 positions, we create exactly k distinct differences. The remaining positions are filled with consecutive numbers. This approach runs in O(n) time with O(1) extra space, making it far superior to brute force permutation generation.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! × n)	O(n)	Generate all possible permutations and check which one has exactly k distinct differences
Optimal Construction (Pattern Recognition)	O(n)	O(1)	Construct the array directly using alternating extreme values pattern

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all permutations of numbers 1 to n
For each permutation, calculate differences between adjacent elements
Count distinct differences using a set
Return first permutation with exactly k distinct differences

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible arrangements of [1,2,3,4]

Calculate Differences

For each permutation, find |ai - ai+1| values

Count Distinct

Use a set to count unique difference values

Check Target

Return first permutation with exactly k distinct differences

Code -

solution.c — C

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

int abs_diff(int a, int b) {
    return a > b ? a - b : b - a;
}

bool hasKDistinct(int* arr, int n, int k) {
    bool seen[1000] = {false};
    int count = 0;
    
    for (int i = 0; i < n - 1; i++) {
        int diff = abs_diff(arr[i], arr[i + 1]);
        if (!seen[diff]) {
            seen[diff] = true;
            count++;
        }
    }
    return count == k;
}

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

bool findPermutation(int* arr, int n, int k, int start) {
    if (start == n) {
        return hasKDistinct(arr, n, k);
    }
    
    for (int i = start; i < n; i++) {
        swap(&arr[start], &arr[i]);
        if (findPermutation(arr, n, k, start + 1)) {
            return true;
        }
        swap(&arr[start], &arr[i]);
    }
    return false;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    
    int* arr = malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = i + 1;
    }
    
    if (findPermutation(arr, n, k, 0)) {
        printf("[");
        for (int i = 0; i < n; i++) {
            printf("%d", arr[i]);
            if (i < n - 1) printf(", ");
        }
        printf("]\n");
    }
    
    free(arr);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! permutations, each taking O(n) time to check differences

⚠ Quadratic Growth

Space Complexity

O(n)

Space for current permutation and set to track differences

⚡ Linearithmic Space

Constraints

1 ≤ k < n ≤ 10⁴
The array must contain all integers from 1 to n exactly once
k must be less than n (since maximum possible distinct differences is n-1)

38.4K Views

Medium Frequency

~15 min Avg. Time

1.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

Brute Force (Generate All Permutations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler