Permutations - Practice Coding Problems

Permutations - Problem

Array Backtracking Medium

Generate All Permutations

Given an array nums containing distinct integers, your task is to generate and return all possible permutations of these numbers. Think of it as finding every possible way to arrange the given numbers.

For example, if you have the numbers [1, 2, 3], you need to find all ways to arrange them: [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], and [3,2,1].

Goal: Return all permutations in any order - the sequence doesn't matter as long as you include every possible arrangement.

Note: Since all integers are distinct, you don't need to worry about duplicate permutations.

Input & Output

example_1.py — Basic case

$ Input: [1,2,3]

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

💡 Note: For three distinct numbers, there are 3! = 6 possible arrangements. Each number appears in each position exactly twice across all permutations.

example_2.py — Two elements

$ Input: [0,1]

› Output: [[0,1],[1,0]]

💡 Note: With two elements, there are only 2! = 2 possible permutations: the original order and the reversed order.

example_3.py — Single element

$ Input: [1]

› Output: [[1]]

💡 Note: A single element has only one permutation - itself. This is our base case where 1! = 1.

Visualization

Tap to expand

Understanding the Visualization

Start Empty

Begin with empty arrangement []

Choose First

Try each number in first position: [1], [2], [3]

Fill Remaining

For each first choice, recursively fill remaining positions

Backtrack

When complete, backtrack and try next option

Collect Results

Gather all complete permutations

Key Takeaway

🎯 Key Insight: Backtracking systematically explores all possibilities by making choices, exploring consequences, then undoing choices to try alternatives. This guarantees we find all permutations without missing any or generating duplicates.

Time & Space Complexity

Time Complexity

⏱️

O(n^n)

n nested loops, each running n times, generating n^n combinations (most invalid)

✓ Linear Growth

Space Complexity

O(n!)

Space to store all n! valid permutations in the result

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 6
-10 ≤ nums[i] ≤ 10
All integers in nums are distinct
Maximum of 6! = 720 permutations possible

Asked in

G Google 45 ⊞ Microsoft 38 a Amazon 35 f Meta 28

The optimal solution uses backtracking to systematically generate all permutations. We make choices at each position, explore all possibilities recursively, then backtrack to try other options. This achieves O(n! × n) time complexity, which is optimal since we must generate all n! permutations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Combinations)	O(n^n)	O(n!)	Generate all possible combinations using nested loops and check validity
Backtracking (Optimal)	O(n! × n)	O(n)	Systematically build permutations using backtracking with choice exploration

Brute Force (Generate All Combinations) — Algorithm Steps

For each position in the result array, try every possible number
Use nested loops (n levels deep) to generate combinations
Check if each combination uses all numbers exactly once
Add valid combinations to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Try every number at every position

Validate

Check if arrangement uses all numbers exactly once

Filter

Keep only valid permutations

Code -

solution.c — C

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

int** result;
int* resultSizes;
int resultCount;
int capacity;

void addResult(int* current, int size) {
    if (resultCount >= capacity) {
        capacity *= 2;
        result = realloc(result, capacity * sizeof(int*));
        resultSizes = realloc(resultSizes, capacity * sizeof(int));
    }
    
    result[resultCount] = malloc(size * sizeof(int));
    for (int i = 0; i < size; i++) {
        result[resultCount][i] = current[i];
    }
    resultSizes[resultCount] = size;
    resultCount++;
}

int isValid(int* current, int currentSize, int* nums, int numsSize) {
    if (currentSize != numsSize) return 0;
    
    // Check if uses all numbers exactly once
    int* used = calloc(21, sizeof(int)); // Assuming range [-10, 10]
    for (int i = 0; i < currentSize; i++) {
        used[current[i] + 10]++;
    }
    
    for (int i = 0; i < numsSize; i++) {
        if (used[nums[i] + 10] != 1) {
            free(used);
            return 0;
        }
    }
    
    free(used);
    return 1;
}

void generateAll(int* nums, int numsSize, int* current, int currentSize) {
    if (currentSize == numsSize) {
        if (isValid(current, currentSize, nums, numsSize)) {
            addResult(current, currentSize);
        }
        return;
    }
    
    for (int i = 0; i < numsSize; i++) {
        current[currentSize] = nums[i];
        generateAll(nums, numsSize, current, currentSize + 1);
    }
}

int** permute(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    result = malloc(1000 * sizeof(int*));
    resultSizes = malloc(1000 * sizeof(int));
    resultCount = 0;
    capacity = 1000;
    
    int* current = malloc(numsSize * sizeof(int));
    generateAll(nums, numsSize, current, 0);
    
    *returnSize = resultCount;
    *returnColumnSizes = resultSizes;
    free(current);
    return result;
}

int main() {
    int nums[] = {1, 2, 3};
    int numsSize = 3;
    int returnSize;
    int* returnColumnSizes;
    
    int** results = permute(nums, numsSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", results[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^n)

n nested loops, each running n times, generating n^n combinations (most invalid)

✓ Linear Growth

Space Complexity

O(n!)

Space to store all n! valid permutations in the result

⚠ Quadratic Space

Constraints

1 ≤ nums.length ≤ 6
-10 ≤ nums[i] ≤ 10
All integers in nums are distinct
Maximum of 6! = 720 permutations possible

42.5K Views

High 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler