Pancake Sorting

Pancake Sorting - Problem

Given an array of integers arr, sort the array by performing a series of pancake flips.

In one pancake flip we do the following steps:

Choose an integer k where 1 <= k <= arr.length
Reverse the sub-array arr[0...k-1] (0-indexed)

For example, if arr = [3,2,1,4] and we performed a pancake flip choosing k = 3, we reverse the sub-array [3,2,1], so arr = [1,2,3,4] after the pancake flip at k = 3.

Return an array of the k-values corresponding to a sequence of pancake flips that sort arr. Any valid answer that sorts the array within 10 * arr.length flips will be judged as correct.

Input & Output

Example 1 — Basic Case

$ Input: arr = [3,2,1,4]

› Output: [4,4,3]

💡 Note: Use greedy approach: move largest element 4 to front with flip k=4 giving [4,1,2,3], then flip k=4 to put it at end giving [3,2,1,4]. Next move 3 to front with flip k=3 giving [1,2,3,4], which completes the sorting.

Example 2 — Already Sorted

$ Input: arr = [1,2,3,4]

› Output: []

💡 Note: Array is already sorted, no flips needed

Example 3 — Reverse Order

$ Input: arr = [4,3,2,1]

› Output: [4]

💡 Note: Max element 4 is at position 0, so flip k=4 to reverse entire array: [4,3,2,1] → [1,2,3,4]

Constraints

1 ≤ arr.length ≤ 10
1 ≤ arr[i] ≤ arr.length
All integers in arr are unique

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 15 M Microsoft 12

The key insight is to systematically place the largest unsorted element in its correct position using at most 2 flips. Best approach is the greedy algorithm which finds the maximum element and moves it to the front (if needed), then flips it to its correct position. Time: O(n²), Space: O(1).

Common Approaches

✓ Brute Force - Try All Flip Sequences

⏱️ Time: O(n! × n²) Space: O(n)

Try every possible sequence of pancake flips by exploring all combinations of k-values. For each sequence, check if it results in a sorted array.

Greedy - Move Largest Element First

⏱️ Time: O(n²) Space: O(1)

For each position from right to left, find the largest unsorted element. Move it to the front with one flip, then move it to its correct position with another flip.

Brute Force - Try All Flip Sequences — Algorithm Steps

Generate all possible flip sequences
For each sequence, simulate the flips
Check if result is sorted
Return first valid sequence found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with unsorted array [3,2,1,4]

Try Flips

Systematically try all k-values from 2 to n

Find Solution

Return first sequence that sorts the array

Code -

solution.c — C

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

bool isSorted(int* a, int n) {
    for (int i = 0; i < n - 1; i++) {
        if (a[i] > a[i+1]) return false;
    }
    return true;
}

void flip(int* arr, int k) {
    for (int i = 0; i < k / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[k - 1 - i];
        arr[k - 1 - i] = temp;
    }
}

int* solution(int* arr, int n, int* returnSize) {
    if (isSorted(arr, n)) {
        *returnSize = 0;
        return malloc(sizeof(int));
    }
    
    int* result = malloc(2 * n * sizeof(int));
    int* workArr = malloc(n * sizeof(int));
    
    for (int i = 0; i < n; i++) {
        workArr[i] = arr[i];
    }
    
    int count = 0;
    
    // Greedy approach: for each position from end to start
    for (int size = n; size > 1; size--) {
        // Find the index of the maximum element in the current subarray
        int maxIdx = 0;
        for (int i = 1; i < size; i++) {
            if (workArr[i] > workArr[maxIdx]) {
                maxIdx = i;
            }
        }
        
        // If the max element is already at the end, continue
        if (maxIdx == size - 1) {
            continue;
        }
            
        // If the max element is not at the beginning, flip it to the beginning
        if (maxIdx != 0) {
            flip(workArr, maxIdx + 1);
            result[count++] = maxIdx + 1;
        }
        
        // Flip the max element from the beginning to its correct position
        flip(workArr, size);
        result[count++] = size;
    }
    
    *returnSize = count;
    free(workArr);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int arr[100];
    int n = 0;
    
    // Parse the array manually
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        int num = 0;
        while (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            p++;
        }
        arr[n++] = num;
    }
    
    int returnSize;
    int* result = solution(arr, n, &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! × n²)

Factorial number of possible sequences, each taking O(n²) time to simulate

⚠ Quadratic Growth

Space Complexity

O(n)

Stack space for recursion and storing current flip sequence

⚡ Linearithmic Space

28.4K Views

Medium Frequency

~25 min Avg. Time

856 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 Flip Sequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler