Codestin Search App

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

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)

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.

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
✓ Optimal Construction (Pattern Recognition)	O(n)	O(1)	Construct the array directly using alternating extreme values pattern
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) — Algorithm Steps

Start with two pointers: left=1, right=n
Alternate between left and right for k+1 elements to create k distinct differences
Increment left and decrement right after each use
Fill remaining positions with consecutive numbers

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set left=1, right=n to track extreme values

Alternate Pattern

Alternate between left and right for k+1 elements

Create Differences

Pattern creates differences: n-1, n-2, n-3, ..., exactly k distinct values

Fill Remaining

Complete array with consecutive numbers (difference = 1)

Code -

solution.c — C

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

int* constructArray(int n, int k, int* returnSize) {
    int* result = malloc(n * sizeof(int));
    int left = 1, right = n;
    int index = 0;
    
    // Create k distinct differences using alternating pattern
    for (int i = 0; i <= k; i++) {
        if (i % 2 == 0) {
            result[index++] = left++;
        } else {
            result[index++] = right--;
        }
    }
    
    // Fill the rest with consecutive numbers
    while (index < n) {
        result[index++] = left++;
    }
    
    *returnSize = n;
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to construct the result

✓ Linear Growth

Space Complexity

O(1)

Only uses constant extra space for pointers and variables

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Optimal Construction (Pattern Recognition) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler