Previous Permutation With One Swap - Practice Coding Problems

Previous Permutation With One Swap - Problem

Array Greedy Medium

Imagine you have a sequence of positive integers representing a permutation, and you want to find the next smaller arrangement in lexicographical order - but with a twist! You can only make exactly one swap between two positions.

Given an array arr of positive integers (not necessarily distinct), your task is to return the lexicographically largest permutation that is smaller than the original array, achievable with exactly one swap operation.

If no such smaller permutation exists with a single swap, return the original array unchanged.

Example: For [3,2,1], we can swap positions 0 and 1 to get [2,3,1], which is lexicographically smaller. For [1,2,3], no single swap can make it smaller, so we return [1,2,3].

Note: Lexicographical order is like dictionary order - compare elements from left to right, and the first difference determines which is smaller.

Input & Output

example_1.py — Basic Case

$ Input: [3,2,1]

› Output: [2,3,1]

💡 Note: We can swap positions 0 and 1 to get [2,3,1], which is lexicographically smaller than [3,2,1] and is the largest such permutation possible with one swap.

example_2.py — No Valid Swap

$ Input: [1,2,3]

› Output: [1,2,3]

💡 Note: The array is already in ascending order, so no single swap can make it lexicographically smaller. Return the original array.

example_3.py — Duplicates

$ Input: [3,1,1,3]

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

💡 Note: We can swap positions 0 and 1 to get [1,3,1,3]. Even though there are duplicates, this gives us the optimal result.

Constraints

1 ≤ arr.length ≤ 10⁴
1 ≤ arr[i] ≤ 10⁴
Array elements are positive integers
Elements are not necessarily distinct

Visualization

Tap to expand

Understanding the Visualization

Scan from Right

Start from the rightmost position and move left to find the first position where you can make a beneficial change

Find Best Candidate

For that position, look to the right and find the largest digit that is still smaller than the current digit

Make the Swap

Swap these two positions to get the lexicographically largest permutation that is smaller than the original

Key Takeaway

🎯 Key Insight: The greedy approach works because we want the rightmost position where we can make a beneficial change, and among all candidates, we choose the largest smaller digit to maximize our result.

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a greedy approach scanning from right to left. For each position, find the largest smaller element to its right and make the swap that produces the lexicographically largest smaller permutation. Time complexity: O(n²), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(n³)	O(n)	Try every possible swap and find the best result
Greedy Approach (Optimal)	O(n²)	O(1)	Find the rightmost beneficial position and make the optimal swap

Brute Force (Try All Swaps) — Algorithm Steps

Try swapping every pair of positions (i, j) where i < j
For each swap, check if the resulting array is lexicographically smaller than original
Among all valid results, keep track of the lexicographically largest one
Return the best result found, or original array if no valid swap exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Try All Pairs

Generate all possible (i,j) pairs where i < j

Swap & Compare

For each pair, swap elements and check if result is smaller than original

Track Best

Keep the lexicographically largest valid result

Code -

solution.c — C

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

int isSmaller(int* a, int* b, int n) {
    for (int i = 0; i < n; i++) {
        if (a[i] < b[i]) return 1;
        if (a[i] > b[i]) return 0;
    }
    return 0;
}

int isLarger(int* a, int* b, int n) {
    for (int i = 0; i < n; i++) {
        if (a[i] > b[i]) return 1;
        if (a[i] < b[i]) return 0;
    }
    return 0;
}

int* prevPermOpt1(int* arr, int n) {
    int* result = (int*)malloc(n * sizeof(int));
    int* temp = (int*)malloc(n * sizeof(int));
    memcpy(result, arr, n * sizeof(int));
    int found = 0;
    
    // Try all possible swaps
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            memcpy(temp, arr, n * sizeof(int));
            // Swap
            int t = temp[i];
            temp[i] = temp[j];
            temp[j] = t;
            
            // Check if smaller than original
            if (isSmaller(temp, arr, n)) {
                found = 1;
                if (isLarger(temp, result, n)) {
                    memcpy(result, temp, n * sizeof(int));
                }
            }
        }
    }
    
    free(temp);
    if (!found) {
        memcpy(result, arr, n * sizeof(int));
    }
    return result;
}

int main() {
    int arr[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Skip '['
    while (scanf("%d%c", &arr[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    int* result = prevPermOpt1(arr, 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³)

O(n²) pairs to try, each requiring O(n) comparison to check if lexicographically smaller

⚠ Quadratic Growth

Space Complexity

O(n)

Need to store copies of array for comparison and the best result

⚡ Linearithmic Space

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler