Pancake Sorting - Practice Coding Problems

Pancake Sorting - Problem

Pancake Sorting is a fun sorting algorithm that mimics flipping a stack of pancakes! 🥞

You're given an array of integers arr representing pancakes of different sizes. Your task is to sort the array using only pancake flips. In a pancake flip, you choose an integer k (where 1 ≤ k ≤ arr.length) and reverse the sub-array from index 0 to k-1.

Example: If arr = [3,2,1,4] and you flip with k = 3, you reverse [3,2,1] to get [1,2,3,4].

Goal: Return an array of k-values that represents the sequence of pancake flips needed to sort the array. Any valid solution that uses at most 10 * arr.length flips will be accepted.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: We flip k=4 to reverse the whole array [1,4,2,3], then flip k=2 to get [4,1,2,3], then flip k=4 to get [3,2,1,4], then flip k=3 to get [1,2,3,4].

example_2.py — Already Sorted

$ Input: [1,2,3]

› Output: []

💡 Note: The array is already sorted, so no pancake flips are needed.

example_3.py — Reverse Order

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

› Output: [4,3,2]

💡 Note: We can flip the entire array with k=4 to get [1,2,3,4], but the greedy approach gives [4,3,2]: flip k=4→[1,2,3,4], flip k=3→[3,2,1,4], flip k=2→[2,3,1,4].

Constraints

1 ≤ arr.length ≤ 10
1 ≤ arr[i] ≤ arr.length
All integers in arr are unique
Solution must use at most 10 × arr.length flips

Visualization

Tap to expand

Understanding the Visualization

Find the Target

Locate the largest pancake that's not in its correct position

Flip to Top

Use a flip to bring the target pancake to the top of the stack

Flip to Position

Use another flip to move the pancake to its correct final position

Repeat Process

Continue with the next largest pancake until all are sorted

Key Takeaway

🎯 Key Insight: The greedy approach guarantees a solution using at most 2n flips by strategically moving each element to its correct position with the two-flip strategy.

Asked in

G Google 45 ⊞ Microsoft 32 a Amazon 28 f Meta 21

The optimal approach uses a greedy selection sort strategy with pancake flips. For each position from the end, find the largest unsorted element and use at most 2 flips to move it to the correct position: flip it to the top, then flip it to its final position. This guarantees O(n²) time complexity and uses at most 2n flips.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Flips)	O(n! × n²)	O(n²)	Try all possible flip sequences using backtracking
Greedy Selection Sort Approach	O(n²)	O(1)	Use greedy strategy to place largest elements in correct positions

Brute Force (Try All Flips) — Algorithm Steps

Start with the original array
Try every possible flip position (1 to n)
For each flip, recursively try all subsequent flips
Check if the array is sorted after each sequence
Return the first valid sequence found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with unsorted pancake stack [3,2,4,1]

Try Flip k=2

Flip top 2 pancakes: [3,2,4,1] → [2,3,4,1]

Try Flip k=3

Flip top 3 pancakes: [2,3,4,1] → [4,3,2,1]

Continue Search

Keep trying different flip combinations until sorted

Code -

solution.c — C

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

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

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

bool backtrack(int arr[], int n, int flips[], int* flip_count) {
    if (is_sorted(arr, n)) return true;
    if (*flip_count >= 10 * n) return false;
    
    for (int k = 2; k <= n; k++) {
        flip(arr, k);
        flips[(*flip_count)++] = k;
        
        if (backtrack(arr, n, flips, flip_count)) return true;
        
        (*flip_count)--;
        flip(arr, k); // backtrack
    }
    
    return false;
}

int* pancakeSort(int* arr, int arrSize, int* returnSize) {
    *returnSize = 0;
    int* result = (int*)malloc(10 * arrSize * sizeof(int));
    
    if (is_sorted(arr, arrSize)) {
        return result;
    }
    
    int* work_arr = (int*)malloc(arrSize * sizeof(int));
    for (int i = 0; i < arrSize; i++) {
        work_arr[i] = arr[i];
    }
    
    if (backtrack(work_arr, arrSize, result, returnSize)) {
        free(work_arr);
        return result;
    }
    
    free(work_arr);
    *returnSize = 0;
    return result;
}

int main() {
    int arr[] = {3, 2, 4, 1};
    int size = 4;
    int returnSize;
    
    int* result = pancakeSort(arr, size, &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²)

We try all possible permutations of flips (n!) and each flip operation takes O(n) time, with n comparisons to check if sorted

⚠ Quadratic Growth

Space Complexity

O(n²)

Recursion stack can go deep, and we store intermediate arrays and flip sequences

⚠ Quadratic Space

28.4K Views

Medium Frequency

~15 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 Flips) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler