Beautiful Array - Practice Coding Problems

Beautiful Array - Problem

Beautiful Array Construction

Imagine you need to construct a special permutation of numbers from 1 to n called a beautiful array. This array has a unique mathematical property: no three elements can form an arithmetic progression when you pick any two elements and check if there's a middle element that's their average.

More formally, an array nums of length n is beautiful if:
• nums is a permutation of integers [1, 2, ..., n]
• For every 0 ≤ i < j < n, there is no index k with i < k < j where 2 * nums[k] == nums[i] + nums[j]

Your task is to construct and return any beautiful array of length n. The mathematical guarantee ensures that at least one solution always exists!

Input & Output

example_1.py — Small Case

$ Input: n = 4

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

💡 Note: This is a valid beautiful array because no element is the average of two others positioned further apart. For example, there's no k where 2*nums[k] equals nums[i] + nums[j] for i < k < j.

example_2.py — Single Element

$ Input: n = 1

› Output: [1]

💡 Note: Base case: A single element array is always beautiful since there are no triplets to check.

example_3.py — Larger Case

$ Input: n = 5

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

💡 Note: Another valid beautiful array. The divide-and-conquer approach generates odds [1,5,3] from transforming [1,3,2] and evens [2,4] from transforming [1,2], then concatenates them.

Visualization

Tap to expand

Understanding the Visualization

Divide

Split the problem: create beautiful arrangements for smaller groups

Transform Odds

Apply 2*x-1 to get odd positions (ensures no averaging with evens)

Transform Evens

Apply 2*x to get even positions (maintains beautiful property)

Conquer

Combine odds + evens safely (mathematical guarantee of beauty)

Key Takeaway

🎯 Key Insight: By separating odds and evens through mathematical transformations, we guarantee that no odd number can be the average of any two numbers in our array, making it safe to combine beautiful subsequences into a larger beautiful array!

Time & Space Complexity

Time Complexity

⏱️

O(n! * n³)

O(n!) permutations, each requiring O(n³) checks for all triplets

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
nums must be a permutation of [1, 2, ..., n]
No arithmetic progression: 2 * nums[k] ≠ nums[i] + nums[j] for i < k < j

Asked in

G Google 15 ⊞ Microsoft 8 a Amazon 5 f Meta 3

The optimal solution uses divide and conquer with a key mathematical insight: if we have a beautiful array A, then 2*A-1 (odds) and 2*A (evens) are both beautiful arrays. Since an odd number can never be the average of any two numbers (one must be even), we can safely concatenate odds and evens. This achieves O(n log n) time complexity through recursive construction.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Permutations)	O(n! * n³)	O(n)	Generate all permutations and check each one for the beautiful property
Divide and Conquer (Optimal)	O(n log n)	O(n log n)	Recursively build beautiful arrays by separating odds and evens using mathematical properties

Brute Force (Generate All Permutations) — Algorithm Steps

Generate all n! permutations of numbers 1 to n
For each permutation, check all triplets (i, k, j) where i < k < j
Verify that 2 * nums[k] ≠ nums[i] + nums[j] for all such triplets
Return the first permutation that satisfies all conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutation

Create a permutation like [1,3,2,4]

Check All Triplets

For each i < k < j, verify 2*nums[k] ≠ nums[i] + nums[j]

Validate or Reject

If any triplet fails, try next permutation

Code -

solution.c — C

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

bool isBeautiful(int* arr, int n) {
    for (int i = 0; i < n; i++) {
        for (int j = i + 2; j < n; j++) {
            for (int k = i + 1; k < j; k++) {
                if (2 * arr[k] == arr[i] + arr[j]) {
                    return false;
                }
            }
        }
    }
    return true;
}

bool generatePermutations(int* nums, int n, int* current, bool* used, int pos, int** result) {
    if (pos == n) {
        if (isBeautiful(current, n)) {
            *result = (int*)malloc(n * sizeof(int));
            for (int i = 0; i < n; i++) {
                (*result)[i] = current[i];
            }
            return true;
        }
        return false;
    }
    
    for (int i = 0; i < n; i++) {
        if (!used[i]) {
            used[i] = true;
            current[pos] = nums[i];
            if (generatePermutations(nums, n, current, used, pos + 1, result)) {
                return true;
            }
            used[i] = false;
        }
    }
    return false;
}

int* beautifulArray(int n) {
    int* nums = (int*)malloc(n * sizeof(int));
    bool* used = (bool*)calloc(n, sizeof(bool));
    int* current = (int*)malloc(n * sizeof(int));
    int* result = NULL;
    
    for (int i = 0; i < n; i++) {
        nums[i] = i + 1;
    }
    
    generatePermutations(nums, n, current, used, 0, &result);
    
    free(nums);
    free(used);
    free(current);
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! * n³)

O(n!) permutations, each requiring O(n³) checks for all triplets

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing current permutation and recursion stack

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 1000
nums must be a permutation of [1, 2, ..., n]
No arithmetic progression: 2 * nums[k] ≠ nums[i] + nums[j] for i < k < j

28.4K Views

Medium Frequency

~25 min Avg. Time

892 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