Permutations III - Practice Coding Problems

Permutations III - Problem

Array Backtracking Medium

Alternating Permutations Challenge

Given an integer n, you need to find all alternating permutations of the first n positive integers. An alternating permutation is a special arrangement where no two adjacent elements have the same parity - meaning you can't have two odd numbers or two even numbers next to each other.

For example, [1, 2, 3, 4] is alternating because: 1 (odd) → 2 (even) → 3 (odd) → 4 (even). But [1, 3, 2, 4] is not alternating because 1 and 3 are both odd and adjacent.

Goal: Return all valid alternating permutations sorted in lexicographical order.

Input & Output

example_1.py — Basic Case

$ Input: n = 3

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

💡 Note: For n=3, we have numbers [1,2,3]. Only two arrangements alternate: [1,2,3] (odd→even→odd) and [3,2,1] (odd→even→odd). Other arrangements like [1,3,2] fail because 1 and 3 are both odd.

example_2.py — Larger Case

$ Input: n = 4

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

💡 Note: With n=4, we have more possibilities. Each valid permutation alternates between odd and even numbers. For example, [1,2,3,4] goes odd→even→odd→even, which satisfies the constraint.

example_3.py — Edge Case

$ Input: n = 1

› Output: [[1]]

💡 Note: With only one number, there are no adjacent elements to check, so [1] is trivially an alternating permutation.

Constraints

1 ≤ n ≤ 8
The result must be sorted in lexicographical order
Each permutation contains integers from 1 to n exactly once

Visualization

Tap to expand

Understanding the Visualization

Start Fresh

Begin with empty arrangement and all dancers available

Choose Wisely

At each position, only consider dancers that won't break the alternating rule

Build Gradually

Place one dancer at a time, checking parity with the previous dancer

Backtrack Smart

If we hit a dead end, backtrack and try a different dancer

Collect Results

When we place all dancers successfully, we found a valid arrangement

Key Takeaway

🎯 Key Insight: Use backtracking with parity checking to build only valid alternating permutations, avoiding the exponential waste of generating and filtering all permutations.

Asked in

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

The optimal solution uses backtracking to generate only valid alternating permutations. Instead of creating all n! permutations and filtering them, we build permutations step by step, checking the parity constraint at each position. This approach prunes invalid branches early, making it much more efficient than brute force while naturally producing results in lexicographical order.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking (Optimal)	O(k × n!)	O(n)	Use backtracking to build only valid alternating permutations
Brute Force (Generate All Permutations)	O(n! × n)	O(n! × n)	Generate all possible permutations and filter valid alternating ones

Backtracking (Optimal) — Algorithm Steps

Start with an empty permutation and track used numbers
At each position, try all unused numbers
Before placing a number, check if it alternates with the previous number
If valid, place the number and recurse to next position
If we reach the end, we found a valid permutation
Backtrack and try other possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Try First Position

Consider all numbers 1 to n for first position

Check Parity Constraint

For subsequent positions, only try numbers with different parity

Prune Invalid Branches

Skip branches that would violate alternating property

Build Valid Permutations

Continue only on promising paths to build complete solutions

Code -

solution.c — C

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

void backtrack(int n, int* used, int* current, int currentSize, int*** result, int* resultSize, int* capacity) {
    if (currentSize == n) {
        if (*resultSize >= *capacity) {
            *capacity *= 2;
            *result = (int**)realloc(*result, (*capacity) * sizeof(int*));
        }
        (*result)[*resultSize] = (int*)malloc(n * sizeof(int));
        memcpy((*result)[*resultSize], current, n * sizeof(int));
        (*resultSize)++;
        return;
    }
    
    for (int num = 1; num <= n; num++) {
        if (used[num]) continue;
        
        // Check alternating constraint
        if (currentSize > 0) {
            int lastNum = current[currentSize - 1];
            if (lastNum % 2 == num % 2) { // Same parity
                continue;
            }
        }
        
        // Place the number
        current[currentSize] = num;
        used[num] = 1;
        
        backtrack(n, used, current, currentSize + 1, result, resultSize, capacity);
        
        // Backtrack
        used[num] = 0;
    }
}

int main() {
    int n;
    scanf("%d", &n);
    
    int* used = (int*)calloc(n + 1, sizeof(int));
    int* current = (int*)malloc(n * sizeof(int));
    
    int capacity = 100;
    int** result = (int**)malloc(capacity * sizeof(int*));
    int resultSize = 0;
    
    backtrack(n, used, current, 0, &result, &resultSize, &capacity);
    
    printf("[");
    for (int i = 0; i < resultSize; i++) {
        printf("[");
        for (int j = 0; j < n; j++) {
            printf("%d", result[i][j]);
            if (j < n - 1) printf(", ");
        }
        printf("]");
        if (i < resultSize - 1) printf(", ");
        free(result[i]);
    }
    printf("]\n");
    
    free(used);
    free(current);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(k × n!)

k is the number of valid permutations (much less than n!), each taking O(n) time to build

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion stack depth and used array

⚡ Linearithmic Space

24.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Backtracking (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler