Data commit

Task/Pancake-numbers/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Pancake_numbers

Task/Pancake-numbers/00-TASK.txt

@@ -0,0 +1,14 @@
+Adrian Monk has problems and an assistant,  Sharona Fleming. Sharona can deal with most of Adrian's problems except his lack of punctuality paying her remuneration. 2 pay checks down and she prepares him pancakes for breakfast. Knowing that he will be unable to eat them unless they are stacked in ascending order of size she leaves him only a skillet which he can insert at any point in the pile and flip all the above pancakes, repeating until the pile is sorted. Sharona has left the pile of n pancakes such that the maximum number of flips is required. Adrian is determined to do this in as few flips as possible. This sequence n->p(n) is known as the Pancake numbers.
+
+The task is to determine p(n) for n = 1 to 9, and for each show an example requiring p(n) flips.
+
+[[Sorting_algorithms/Pancake_sort]] actually performs the sort some giving the number of flips used. How do these compare with p(n)?
+
+Few people know p(20), generously I shall award an extra credit for anyone doing more than p(16).
+
+
+;References
+# [https://www.bbvaopenmind.com/en/science/mathematics/bill-gates-and-the-pancake-problem Bill Gates and the pancake problem]
+# [https://oeis.org/A058986 A058986]
+<br><br>
+

Task/Pancake-numbers/AWK/pancake-numbers.awk

@@ -0,0 +1,23 @@
+# syntax: GAWK -f PANCAKE_NUMBERS.AWK
+# converted from C
+BEGIN {
+    for (i=0; i<4; i++) {
+      for (j=1; j<6; j++) {
+        n = i * 5 + j
+        printf("p(%2d) = %2d  ",n,main(n))
+      }
+      printf("\n")
+    }
+    exit(0)
+}
+function main(n,  adj,gap,sum) {
+    gap = 2
+    sum = 2
+    adj = -1
+    while (sum < n) {
+      adj++
+      gap = gap * 2 - 1
+      sum += gap
+    }
+    return(n + adj)
+}

Task/Pancake-numbers/Applesoft-BASIC/pancake-numbers.basic

@@ -0,0 +1,15 @@
+100 HOME
+110 FOR I = 0 TO 3
+120  FOR J = 1 TO 5
+130   LET N = (I * 5) + J
+140   LET C = C + 1
+150   GOSUB 200
+160   PRINT "p("; N; ") = "; P; "  "
+170  NEXT J
+180 NEXT I
+190 END
+200 REM pancake(n)
+210  LET G = 2 : LET S = 2 : LET A = -1
+220  IF S < N THEN LET A = A + 1 : LET G = (G * 2) - 1 : LET S = S + G
+230  IF S >= N THEN LET P = N + A : RETURN
+240 GOTO 220

Task/Pancake-numbers/BASIC256/pancake-numbers.basic

@@ -0,0 +1,23 @@
+c = 0
+
+for i = 0 to 3
+	for j = 1 to 5
+		n = (i * 5) + j
+		c += 1
+		print "p("; rjust(string(n),2); ") = "; pancake(n); "  ";
+		if c mod 5 = 0 then print
+	next j
+next i
+end
+
+function pancake(n)
+	gap = 2
+	sum = 2
+	adj = -1
+	while sum < n
+		adj += 1
+		gap = (gap * 2) - 1
+		sum += gap
+	end while
+	return rjust(string(n + adj), 2)
+end function

Task/Pancake-numbers/C++/pancake-numbers.cpp

@@ -0,0 +1,54 @@
+#include <iostream>
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <queue>
+#include <numeric>
+#include <iomanip>
+
+std::vector<int32_t> flip_stack(std::vector<int32_t>& stack, const int32_t index) {
+	reverse(stack.begin(), stack.begin() + index);
+	return stack;
+}
+
+std::pair<std::vector<int32_t>, int32_t> pancake(const int32_t number) {
+	std::vector<int32_t> initial_stack(number);
+	std::iota(initial_stack.begin(), initial_stack.end(), 1);
+	std::map<std::vector<int32_t>, int32_t> stack_flips = { std::make_pair(initial_stack, 1) };
+	std::queue<std::vector<int32_t>> queue;
+	queue.push(initial_stack);
+
+	while ( ! queue.empty() ) {
+		std::vector<int32_t> stack = queue.front();
+		queue.pop();
+
+		const int32_t flips = stack_flips[stack] + 1;
+		for ( int i = 2; i <= number; ++i ) {
+			std::vector<int32_t> flipped = flip_stack(stack, i);
+			if ( stack_flips.find(flipped) == stack_flips.end() ) {
+				stack_flips[flipped] = flips;
+				queue.push(flipped);
+			}
+		}
+    }
+
+	auto ptr = std::max_element(
+		stack_flips.begin(), stack_flips.end(),
+		[] ( const auto & pair1, const auto & pair2 ) {
+	    	return pair1.second < pair2.second;
+		}
+	);
+
+	return std::make_pair(ptr->first, ptr->second);
+}
+
+int main() {
+	for ( int32_t n = 1; n <= 9; ++n ) {
+		std::pair<std::vector<int32_t>, int32_t> result = pancake(n);
+		std::cout << "pancake(" << n << ") = " << std::setw(2) << result.second << ". Example [";
+		for ( uint64_t i = 0; i < result.first.size() - 1; ++i ) {
+			std::cout << result.first[i] << ", ";
+		}
+		std::cout << result.first.back() << "]" << std::endl;
+	}
+}

Task/Pancake-numbers/C/pancake-numbers.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+
+int pancake(int n) {
+    int gap = 2, sum = 2, adj = -1;
+    while (sum < n) {
+        adj++;
+        gap = gap * 2 - 1;
+        sum += gap;
+    }
+    return n + adj;
+}
+
+int main() {
+    int i, j;
+    for (i = 0; i < 4; i++) {
+        for (j = 1; j < 6; j++) {
+            int n = i * 5 + j;
+            printf("p(%2d) = %2d  ", n, pancake(n));
+        }
+        printf("\n");
+    }
+    return 0;
+}

Task/Pancake-numbers/Chipmunk-Basic/pancake-numbers.basic

@@ -0,0 +1,21 @@
+100 c = 0
+110 for i = 0 to 3
+120   for j = 1 to 5
+130     n = (i*5)+j
+140     c = c+1
+150     print "p(";format$(n,"##");") = ";format$(pancake(n),"##");"  ";
+160     if c mod 5 = 0 then print
+170   next j
+180 next i
+190 end
+200 function pancake(n)
+210   gap = 2
+220   sum = 2
+230   adj = -1
+240   while sum < n
+250     adj = adj+1
+260     gap = (gap*2)-1
+270     sum = sum+gap
+280   wend
+290   pancake = n+adj
+300 end function

Task/Pancake-numbers/Cowgol/pancake-numbers.cowgol

@@ -0,0 +1,45 @@
+include "cowgol.coh";
+
+sub pancake(n: uint8): (r: uint8) is
+    var gap: uint8 := 2;
+    var sum: uint8 := 2;
+    var adj: int8 := -1;
+
+    while sum < n loop
+        adj := adj + 1;
+        gap := gap * 2 - 1;
+        sum := sum + gap;
+    end loop;
+
+    r := n + adj as uint8;
+end sub;
+
+# print 2-digit number
+sub print2(n: uint8) is
+    if n<10 then
+        print_char(' ');
+    else
+        print_char(n/10 + '0');
+    end if;
+    print_char(n%10 + '0');
+end sub;
+
+# print item
+sub print_item(n: uint8) is
+    print("p(");
+    print2(n);
+    print(") = ");
+    print2(pancake(n));
+    print("  ");
+end sub;
+
+var i: uint8 := 0;
+while i < 4 loop
+    var j: uint8 := 1;
+    while j < 6 loop
+        print_item(i*5 + j);
+        j := j + 1;
+    end loop;
+    print_nl();
+    i := i + 1;
+end loop;

Task/Pancake-numbers/D/pancake-numbers.d

@@ -0,0 +1,54 @@
+import std.stdio;
+import std.algorithm;
+import std.random;
+import std.range;
+
+int pancake(int n) {
+    int gap = 2, sum = 2, adj = -1;
+	
+    while (sum < n) {
+        adj++;
+        gap = 2 * gap - 1;
+        sum += gap;
+    }
+	
+    return n + adj;
+}
+
+Range pancakeSort(Range)(Range r) {
+	foreach_reverse (immutable i; 2 .. r.length + 1) {
+		immutable maxIndex = i - r[0 .. i].minPos!q{a > b}.length;
+		
+		if (maxIndex + 1 != i) {
+			if (maxIndex != 0) {
+				r[0 .. maxIndex + 1].reverse();
+			}
+			
+			r[0 .. i].reverse();
+		}
+	}
+	
+	return r;
+}
+
+void main() {
+	writeln("\nThe maximum number of flips to sort a given number of elements is:\n");
+	
+	foreach (i; 1..11)
+	{
+		auto data = iota(1, i+1).array;
+		
+		if (i != 1) {
+			// Protection against the edge case data.lenght == 1 not handled by randomShuffle
+			// where also data is invariant with regard to pancakeSort
+			do
+				data.randomShuffle;
+			while (data.isSorted);
+		}
+		
+		auto sortedData = data.dup;
+		sortedData.pancakeSort;
+		
+		writefln("pancake(%2d) = %2d  e.g  %s  ->  %s", i, pancake(i), data, sortedData);
+	}
+}

Task/Pancake-numbers/F-Sharp/pancake-numbers.fs

@@ -0,0 +1,9 @@
+// Pancake numbers. Nigel Galloway: October 28th., 2020
+let pKake z=let n=[for n in 1..z-1->Array.ofList([n.. -1..0]@[n+1..z-1])]
+            let e=let rec fG n g=match g with 0->n |_->fG (n*g) (g-1) in fG 1 z
+            let rec fN i g l=match (Set.count g)-e with 0->(i,List.last l)
+                                                       |_->let l=l|>List.collect(fun g->[for n in n->List.permute(fun g->n.[g]) g])|>Set.ofList
+                                                           fN (i+1) (Set.union g l) (Set.difference l g|>Set.toList)
+            fN 0 (set[[1..z]]) [[1..z]]
+
+[1..9]|>List.iter(fun n->let i,g=pKake n in printfn "Maximum number of flips to sort %d elements is %d. e.g %A->%A" n i g [1..n])

Task/Pancake-numbers/FreeBASIC/pancake-numbers.basic

@@ -0,0 +1,23 @@
+Dim As Integer num_pancakes = 20
+Dim As Integer i, j, c = 0, n
+
+Function pancake(n As Integer) As Integer
+    Dim As Integer gap = 2, sum = 2, adj = -1
+    While sum < n
+        adj += 1
+        gap = (gap * 2) - 1
+        sum += gap
+    Wend
+    Return n + adj
+End Function
+
+For i = 0 To 3
+    For j = 1 To 5
+        n = (i * 5) + j
+        c += 1
+        Print Using "p(##) = ##  "; n; pancake(n);
+        If c Mod 5 = 0 Then Print
+    Next j
+Next i
+
+Sleep

Task/Pancake-numbers/GW-BASIC/pancake-numbers.basic

@@ -0,0 +1,17 @@
+100 CLS
+110 FOR I = 0 TO 3
+120  FOR J = 1 TO 5
+130   N = (I*5)+J
+140   C = C+1
+150   GOSUB 200
+160   PRINT USING "p(##) = ##  ";N;PANCAKE
+170  NEXT J
+180 NEXT I
+190 END
+200 REM pancake(n)
+210  GAP = 2
+220  SUM = 2
+230  ADJ = -1
+240  IF SUM < N THEN ADJ = ADJ+1 : GAP = (GAP*2)-1 : SUM = SUM+GAP
+250  IF SUM >= N THEN PANCAKE = N+ADJ : RETURN
+260 GOTO 240

Task/Pancake-numbers/Gambas/pancake-numbers.gambas

@@ -0,0 +1,27 @@
+Public Sub Main()
+
+  Dim i As Integer, j As Integer, c As Integer = 0, n As Integer
+
+  For i = 0 To 3
+    For j = 1 To 5
+      n = (i * 5) + j
+      c += 1
+      Print "p("; Format$(n, "##"); ") = "; Format$(pancake(n), "##"); "  ";
+      If c Mod 5 = 0 Then Print
+    Next
+  Next
+
+End
+
+Function pancake(n As Integer) As Integer
+
+  Dim gap As Integer = 2, sum As Integer = 2, adj As Integer = -1
+
+  While sum < n
+    adj += 1
+    gap = (gap * 2) - 1
+    sum += gap
+  Wend
+  Return n + adj
+
+End Function

Task/Pancake-numbers/Go/pancake-numbers-1.go

@@ -0,0 +1,23 @@
+package main
+
+import "fmt"
+
+func pancake(n int) int {
+    gap, sum, adj := 2, 2, -1
+    for sum < n {
+        adj++
+        gap = gap*2 - 1
+        sum += gap
+    }
+    return n + adj
+}
+
+func main() {
+    for i := 0; i < 4; i++ {
+        for j := 1; j < 6; j++ {
+            n := i*5 + j
+            fmt.Printf("p(%2d) = %2d  ", n, pancake(n))
+        }
+        fmt.Println()
+    }
+}

Task/Pancake-numbers/Go/pancake-numbers-2.go

@@ -0,0 +1,100 @@
+package main
+
+import (
+    "fmt"
+    "strconv"
+    "strings"
+    "time"
+)
+
+type assoc map[string]int
+
+// Converts a string of the form "[1 2]" into a slice of ints: {1, 2}
+func asSlice(s string) []int {
+    split := strings.Split(s[1:len(s)-1], " ")
+    le := len(split)
+    res := make([]int, le)
+    for i := 0; i < le; i++ {
+        res[i], _ = strconv.Atoi(split[i])
+    }
+    return res
+}
+
+// Merges two assocs into one. If the same key is present in both assocs
+// its value will be the one in the second assoc.
+func merge(m1, m2 assoc) assoc {
+    m3 := make(assoc)
+    for k, v := range m1 {
+        m3[k] = v
+    }
+    for k, v := range m2 {
+        m3[k] = v
+    }
+    return m3
+}
+
+// Finds the maximum value in 'dict' and returns the first key
+// it finds (iteration order is undefined) with that value.
+func findMax(dict assoc) string {
+    max := -1
+    maxKey := ""
+    for k, v := range dict {
+        if v > max {
+            max = v
+            maxKey = k
+        }
+    }
+    return maxKey
+}
+
+// Creates a new slice of ints by reversing an existing one.
+func reverse(s []int) []int {
+    le := len(s)
+    rev := make([]int, le)
+    for i := 0; i < le; i++ {
+        rev[i] = s[le-1-i]
+    }
+    return rev
+}
+
+func pancake(n int) (string, int) {
+    numStacks := 1
+    gs := make([]int, n)
+    for i := 0; i < n; i++ {
+        gs[i] = i + 1
+    }
+    goalStack := fmt.Sprintf("%v", gs)
+    stacks := assoc{goalStack: 0}
+    newStacks := assoc{goalStack: 0}
+    for i := 1; i <= 1000; i++ {
+        nextStacks := assoc{}
+        for key := range newStacks {
+            arr := asSlice(key)
+            for pos := 2; pos <= n; pos++ {
+                t := append(reverse(arr[0:pos]), arr[pos:len(arr)]...)
+                newStack := fmt.Sprintf("%v", t)
+                if _, ok := stacks[newStack]; !ok {
+                    nextStacks[newStack] = i
+                }
+            }
+        }
+        newStacks = nextStacks
+        stacks = merge(stacks, newStacks)
+        perms := len(stacks)
+        if perms == numStacks {
+            return findMax(stacks), i - 1
+        }
+        numStacks = perms
+    }
+    return "", 0
+}
+
+func main() {
+    start := time.Now()
+    fmt.Println("The maximum number of flips to sort a given number of elements is:")
+    for i := 1; i <= 10; i++ {
+        example, steps := pancake(i)
+        fmt.Printf("pancake(%2d) = %-2d  example: %s\n", i, steps, example)
+    }
+    fmt.Printf("\nTook %s\n", time.Since(start))
+}

Task/Pancake-numbers/Java/pancake-numbers-1.java

@@ -0,0 +1,23 @@
+public class Pancake {
+    private static int pancake(int n) {
+        int gap = 2;
+        int sum = 2;
+        int adj = -1;
+        while (sum < n) {
+            adj++;
+            gap = 2 * gap - 1;
+            sum += gap;
+        }
+        return n + adj;
+    }
+
+    public static void main(String[] args) {
+        for (int i = 0; i < 4; i++) {
+            for (int j = 1; j < 6; j++) {
+                int n = 5 * i + j;
+                System.out.printf("p(%2d) = %2d  ", n, pancake(n));
+            }
+            System.out.println();
+        }
+    }
+}

Task/Pancake-numbers/Java/pancake-numbers-2.java

@@ -0,0 +1,47 @@
+import static java.util.Comparator.comparing;
+import static java.util.stream.Collectors.toList;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.stream.IntStream;
+
+
+public class Pancake {
+
+    private static List<Integer> flipStack(List<Integer> stack, int spatula) {
+        List<Integer> copy = new ArrayList<>(stack);
+        Collections.reverse(copy.subList(0, spatula));
+        return copy;
+    }
+
+    private static Map.Entry<List<Integer>, Integer> pancake(int n) {
+        List<Integer> initialStack = IntStream.rangeClosed(1, n).boxed().collect(toList());
+        Map<List<Integer>, Integer> stackFlips = new HashMap<>();
+        stackFlips.put(initialStack, 1);
+        Queue<List<Integer>> queue = new ArrayDeque<>();
+        queue.add(initialStack);
+        while (!queue.isEmpty()) {
+            List<Integer> stack = queue.remove();
+            int flips = stackFlips.get(stack) + 1;
+            for (int i = 2; i <= n; ++i) {
+                List<Integer> flipped = flipStack(stack, i);
+                if (stackFlips.putIfAbsent(flipped, flips) == null) {
+                    queue.add(flipped);
+                }
+            }
+        }
+        return stackFlips.entrySet().stream().max(comparing(e -> e.getValue())).get();
+    }
+
+    public static void main(String[] args) {
+        for (int i = 1; i <= 10; ++i) {
+            Map.Entry<List<Integer>, Integer> result = pancake(i);
+            System.out.printf("pancake(%s) = %s. Example: %s\n", i, result.getValue(), result.getKey());
+        }
+    }
+}

Task/Pancake-numbers/Julia/pancake-numbers-1.julia

@@ -0,0 +1,14 @@
+function pancake(len)
+    gap, gapsum, adj = 2, 2, -1
+    while gapsum < len
+        adj += 1
+        gap = gap * 2 - 1
+        gapsum += gap
+    end
+    return len + adj
+end
+
+for i in 1:25
+    print("pancake(", lpad(i, 2), ") = ", rpad(pancake(i), 5))
+    i % 5 == 0 && println()
+end

Task/Pancake-numbers/Julia/pancake-numbers-2.julia

@@ -0,0 +1,22 @@
+function pancake(len)
+    goalstack = collect(1:len)
+    stacks, numstacks = Dict(goalstack => 0), 1
+    newstacks = deepcopy(stacks)
+    for i in 1:1000
+        nextstacks = Dict()
+        for (arr, steps) in newstacks, pos in 2:len
+            newstack = vcat(reverse(arr[1:pos]), arr[pos+1:end])
+            haskey(stacks, newstack) || (nextstacks[newstack] = i)
+        end
+        newstacks = nextstacks
+        stacks = merge(stacks, newstacks)
+        perms = length(stacks)
+        perms == numstacks && return findmax(stacks)
+        numstacks = perms
+    end
+end
+
+for i in 1:10
+    steps, example = pancake(i)
+    println("pancake(", lpad(i, 2), ") = ", rpad(steps, 5), " example: ", example)
+end

Task/Pancake-numbers/Kotlin/pancake-numbers-1.kotlin

@@ -0,0 +1,17 @@
+fun pancake(n: Int): Int {
+    var gap = 2
+    var sum = 2
+    var adj = -1
+    while (sum < n) {
+        adj++
+        gap = gap * 2 - 1
+        sum += gap
+    }
+    return n + adj
+}
+
+fun main() {
+    (1 .. 20).map {"p(%2d) = %2d".format(it, pancake(it))}
+    val lines = results.chunked(5).map { it.joinToString("  ") }
+    lines.forEach { println(it) }
+}

Task/Pancake-numbers/Kotlin/pancake-numbers-2.kotlin

@@ -0,0 +1,25 @@
+data class PancakeResult(val example: List<Int>, val depth: Int)
+
+fun pancake(n: Int): PancakeResult {
+  fun List<Int>.copyFlip(spatula: Int) = toMutableList().apply { subList(0, spatula).reverse() }
+  val initialStack = List(n) { it + 1 }
+  val stackFlips = mutableMapOf(initialStack to 1)
+  val queue = ArrayDeque(listOf(initialStack))
+  while (queue.isNotEmpty()) {
+    val stack = queue.removeFirst()
+    val flips = stackFlips[stack]!! + 1
+    for (spatula in 2 .. n) {
+      val flipped = stack.copyFlip(spatula)
+      if (stackFlips.putIfAbsent(flipped, flips) == null) {
+        queue.addLast(flipped)
+      }
+    }
+  }
+  return stackFlips.maxByOrNull { it.value }!!.run { PancakeResult(key, value) }
+}
+
+fun main() {
+  for (i in 1 .. 10) {
+    with (pancake(i)) { println("pancake($i) = $depth. Example: $example") }
+  }
+}

Task/Pancake-numbers/MAD/pancake-numbers.mad

@@ -0,0 +1,18 @@
+            NORMAL MODE IS INTEGER
+            VECTOR VALUES ROW = $5(2HP[,I2,4H] = ,I2,S2)*$
+
+            INTERNAL FUNCTION(N)
+            ENTRY TO P.
+            GAP = 2
+            ADJ = -1
+            THROUGH LOOP, FOR SUM=2, GAP, SUM.GE.N
+            ADJ = ADJ + 1
+LOOP        GAP = GAP * 2 - 1
+            FUNCTION RETURN N + ADJ
+            END OF FUNCTION
+
+            THROUGH OUTP, FOR R=1, 5, R.G.20
+OUTP        PRINT FORMAT ROW, R,P.(R), R+1,P.(R+1), R+2,P.(R+2),
+          0     R+3,P.(R+3), R+4,P.(R+4), R+5,P.(R+5)
+
+            END OF PROGRAM

Task/Pancake-numbers/Nim/pancake-numbers-1.nim

@@ -0,0 +1,19 @@
+import strformat, strutils
+
+func pancake(n: int): int =
+  var
+    gap, sumGaps = 2
+    pg = 1
+    adj = -1
+  while sumGaps < n:
+    inc adj
+    inc pg, gap
+    swap pg, gap
+    inc sumGaps, gap
+  result = n + adj
+
+var line = ""
+for n in 1..20:
+  line.addSep("   ")
+  line.add &"p({n:>2}) = {pancake(n):>2}"
+  if n mod 5 == 0: (echo line; line.setLen(0))

Task/Pancake-numbers/Nim/pancake-numbers-2.nim

@@ -0,0 +1,41 @@
+import sequtils, strformat, strutils, tables
+
+type
+  StepTable = TableRef[seq[int], int]
+  Result = tuple[steps: int; example: seq[int]]
+
+func findMax(t: StepTable): Result =
+  result.steps = -1
+  for example, steps in t.pairs:
+    if steps > result.steps:
+      result = (steps, example)
+
+func partialReversed(arr: openArray[int]; pos: int): seq[int] =
+  result.setlen(arr.len)
+  for i in 0..<pos:
+    result[i] = arr[pos - 1 - i]
+  for i in pos..arr.high:
+    result[i] = arr[i]
+
+func pancake(n: int): Result =
+  var goalStack = toSeq(1..n)
+  var stacks, newStacks: StepTable = newTable({goalStack: 0})
+  var numStacks = 1
+  for i in 1..1000:
+    var nextStacks = new(StepTable)
+    for arr, steps in newStacks.pairs:
+      for pos in 2..n:
+        let newStack = partialReversed(arr, pos)
+        if newStack notin stacks:
+          nextStacks[newStack] = i
+    newStacks = nextStacks
+    for key, value in newStacks:
+      stacks[key] = value
+    let perms = stacks.len
+    if perms == numStacks:
+      return stacks.findMax()
+    numStacks = perms
+
+for n in 1..10:
+  let (steps, example) = pancake(n)
+  echo &"p({n:>2}) = {steps:>2}    example: ", example.join(", ")

Task/Pancake-numbers/OoRexx/pancake-numbers-1.rexx

@@ -0,0 +1,20 @@
+/*REXX program calculates/displays 20 pancake numbers (from 1 to 20,inclusive). */
+ol=''
+Do pcn=1 To 20
+  ol=ol 'p('format(pcn,2)') ='format(pancake(pcn),3)' '
+  If pcn//5=0 Then Do
+    Say strip(ol)
+    ol=''
+    End
+  End
+Exit
+/*------------------------------------------------------------------------------*/
+pancake: Procedure
+  Parse Arg n                            /* obtain  N                           */
+  gap= 2                                 /* initialize the GAP.                 */
+  sum= 2                                 /* initialize the SUM.                 */
+  Do adj=0 While sum <n                  /* perform while  SUM is less than  N. */
+    gap= gap*2 - 1                       /* calculate the GAP.                  */
+    sum= sum + gap                       /* add the  GAP  to the  SUM.          */
+    End   /*adj*/
+  Return n +adj -1                       /* return an adjusted adjustment sum.  */

Task/Pancake-numbers/OoRexx/pancake-numbers-2.rexx

@@ -0,0 +1,86 @@
+/* REXX Driver for pancake.test */
+do n=2 To 10
+  Call pancake n
+  End
+Exit
+pancake: Procedure
+/**********************************************************************
+* REXX pancake.rex
+* The task is to determine p(n) for n = 1 to 9,
+* and for each show an example requiring p(n) flips.
+* inspired by java and output like Phix
+* Note: Using q~delete(1) to get the next candidate for flipping
+* has dramatic performance consequences for large stacks.
+* Therefore, I leave the queue alone and use a pointer (qp)
+* 20230604 Walter Pachl
+**********************************************************************/
+Call time 'R'
+parse arg n                          -- Number of pancakes
+init=left('123456789abc',n)          -- ordered pancakes
+Call o 'heureka' n
+q=.queue~new                         -- implements the queue
+qp=1
+ex=0
+q~append(init)
+stackFlips.=-1                       -- initialize map
+stackFlips.init=0                    -- stackFlips.v: number of flips
+                                     -- from init to v
+cnt.=0
+cnt.1=1
+max=0
+Do while qp<=q~items                 -- as long we can flip
+  s=q[qp]
+  qp+=1                            -- get next element
+  flips=stackFlips.s+1               -- flips for the successors
+  cnt.flips=cnt.flips+1              -- count them
+  If flips>max Then ex=0             -- a new maximum
+  max=max(max,flips)
+  Do i=2 To n                        -- process n-1 successors
+    t=flip(s,i)                      -- one of them
+    If stackFlips.t=-1 Then Do       -- not set so far
+      stackFlips.t=flips             -- flips from init to t
+      q~append(t)                    -- append it to the queue
+      If ex<3 Then Do                -- show the forst 3 examples
+        call o flips t
+        If ex>=0 Then Do             -- record the data to be shown
+          example=''                 -- as an example (see o2)
+          Do While t<>''
+            Parse Var t c +1 t
+            Select
+              When c='a' Then c=10
+              When c='b' Then c=11
+              When c='c' Then c=12
+              Otherwise Nop
+              End
+            example=example||c||','
+            End
+          exf=flips
+          example=strip(example,'T',',')
+          End
+        ex=ex+1
+        End
+      End
+    End
+  End
+Call o 'max cnt.max:' max cnt.max
+te=time('E')                         -- elaüsed time
+te=strip(format(te,8,1))
+Call o te 'seconds'
+Call o ''
+Call o2 'p('n') = 'exf', example: {'example'} (of' cnt.max', 'te's)'
+Return
+
+flip: Procedure
+Parse Arg s,k                        -- cf. flipStack in java
+Return substr(s,k,1)reverse(left(s,k-1))||substr(s,k+1)
+
+o: -- investigation and debug output
+Return
+Say arg(1)
+Return lineout('heureka.txt',arg(1))
+
+o2: -- result to be shown in rosettacode
+Say arg(1)
+Call lineout 'heureka.out',arg(1)
+Call lineout 'heureka.out'
+Return

Task/Pancake-numbers/Perl/pancake-numbers.pl

@@ -0,0 +1,43 @@
+use strict;
+use warnings;
+use feature 'say';
+
+sub pancake {
+    my($n) = @_;
+    my ($gap, $sum, $adj) = (2, 2, -1);
+    while ($sum < $n) { $sum += $gap = $gap * 2 - 1 and $adj++ }
+    $n + $adj;
+}
+
+my $out;
+$out .= sprintf "p(%2d) = %2d ", $_, pancake $_ for 1..20;
+say $out =~ s/.{1,55}\K /\n/gr;
+
+# Maximum number of flips plus examples using exhaustive search
+sub pancake2 {
+    my ($n) = @_;
+    my $numStacks = 1;
+    my @goalStack = 1 .. $n;
+    my %newStacks = my %stacks = (join(' ',@goalStack), 0);
+    for my $k (1..1000) {
+        my %nextStacks;
+        for my $pos (2..$n) {
+            for my $key (keys %newStacks) {
+                my @arr = split ' ', $key;
+                my $cakes = join ' ', (reverse @arr[0..$pos-1]), @arr[$pos..$#arr];
+                $nextStacks{$cakes} = $k unless $stacks{$cakes};
+            }
+        }
+        %stacks = (%stacks, (%newStacks = %nextStacks));
+        my $perms    = scalar %stacks;
+        my %inverted = reverse %stacks;
+        return $k-1, $inverted{(sort keys %inverted)[-1]} if $perms == $numStacks;
+        $numStacks = $perms;
+   }
+}
+
+say "\nThe maximum number of flips to sort a given number of elements is:";
+for my $n (1..9) {
+    my ($a,$b) = pancake2($n);
+    say "pancake($n) = $a example: $b";
+}

Task/Pancake-numbers/Phix/pancake-numbers-1.phix

@@ -0,0 +1,17 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">pancake</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">gap</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sum_gaps</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">gap</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">adj</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
+     <span style="color: #008080;">while</span> <span style="color: #000000;">sum_gaps</span><span style="color: #0000FF;"><</span><span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">adj</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #000000;">gap</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">gap</span><span style="color: #0000FF;">*</span><span style="color: #000000;">2</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
+         <span style="color: #000000;">sum_gaps</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">gap</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">adj</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">n</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">20</span><span style="color: #0000FF;">),</span>
+          <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">({</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pancake</span><span style="color: #0000FF;">)}),</span>
+          <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"p(%2d) = %2d"</span><span style="color: #0000FF;">},</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">))</span>
+<!--

Task/Pancake-numbers/Phix/pancake-numbers-2.phix

@@ -0,0 +1,17 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">pancake</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">gap</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">2</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">pg</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sum_gaps</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">gap</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">adj</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>
+     <span style="color: #008080;">while</span> <span style="color: #000000;">sum_gaps</span><span style="color: #0000FF;"><</span><span style="color: #000000;">n</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">adj</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
+         <span style="color: #0000FF;">{</span><span style="color: #000000;">pg</span><span style="color: #0000FF;">,</span><span style="color: #000000;">gap</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">gap</span><span style="color: #0000FF;">,</span><span style="color: #000000;">gap</span><span style="color: #0000FF;">+</span><span style="color: #000000;">pg</span><span style="color: #0000FF;">}</span>
+         <span style="color: #000000;">sum_gaps</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">gap</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #000000;">n</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">adj</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">n</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+ <span style="color: #004080;">sequence</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">20</span><span style="color: #0000FF;">),</span>
+          <span style="color: #000000;">r</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">columnize</span><span style="color: #0000FF;">({</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pancake</span><span style="color: #0000FF;">)}),</span>
+          <span style="color: #000000;">p</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">,{{</span><span style="color: #008000;">"p(%2d) = %2d"</span><span style="color: #0000FF;">},</span><span style="color: #000000;">r</span><span style="color: #0000FF;">})</span>
+ <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">p</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">))</span>
+<!--

Task/Pancake-numbers/Phix/pancake-numbers-3.phix

@@ -0,0 +1,38 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">function</span> <span style="color: #000000;">visitor</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">stack</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000080;font-style:italic;">/*unused*/</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">stacks</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">pos</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stack</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+ <span style="color: #000080;font-style:italic;">--  for pos=0 to length(stack)-2 do</span>
+         <span style="color: #004080;">sequence</span> <span style="color: #000000;">newstack</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">reverse</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stack</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">pos</span><span style="color: #0000FF;">])&</span><span style="color: #000000;">stack</span><span style="color: #0000FF;">[</span><span style="color: #000000;">pos</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..$]</span>
+ <span style="color: #000080;font-style:italic;">--      sequence newstack = stack[1..pos]&reverse(stack[pos+1..$])</span>
+         <span style="color: #008080;">if</span> <span style="color: #7060A8;">getd_index</span><span style="color: #0000FF;">(</span><span style="color: #000000;">newstack</span><span style="color: #0000FF;">,</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])=</span><span style="color: #004600;">NULL</span> <span style="color: #008080;">then</span>
+             <span style="color: #7060A8;">setd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">newstack</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">[$])</span> <span style="color: #000080;font-style:italic;">-- (next round)</span>
+             <span style="color: #7060A8;">setd</span><span style="color: #0000FF;">(</span><span style="color: #000000;">newstack</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span> <span style="color: #000080;font-style:italic;">-- (the master)</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #000000;">1</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">pancake</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">len</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">goalstack</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">len</span><span style="color: #0000FF;">),</span>
+              <span style="color: #000000;">stacks</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">new_dict</span><span style="color: #0000FF;">({{</span><span style="color: #000000;">goalstack</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">}})}</span>
+     <span style="color: #008080;">while</span> <span style="color: #004600;">true</span> <span style="color: #008080;">do</span>
+         <span style="color: #000000;">stacks</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">new_dict</span><span style="color: #0000FF;">()</span>
+         <span style="color: #000080;font-style:italic;">-- add any flips of stacks[$-1]
+         --   not already in stacks[1]
+         --               to stacks[$]</span>
+         <span style="color: #7060A8;">traverse_dict</span><span style="color: #0000FF;">(</span><span style="color: #000000;">visitor</span><span style="color: #0000FF;">,</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">,</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">[$-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
+         <span style="color: #008080;">if</span> <span style="color: #7060A8;">dict_size</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">[$])=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">eg</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">getd_partial_key</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">[$-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">],</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>
+     <span style="color: #004080;">integer</span> <span style="color: #000000;">sz</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">dict_size</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">[$-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
+     <span style="color: #7060A8;">papply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">destroy_dict</span><span style="color: #0000FF;">)</span>
+     <span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">stacks</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">eg</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sz</span><span style="color: #0000FF;">}</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #004080;">atom</span> <span style="color: #000000;">t0</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">time</span><span style="color: #0000FF;">()</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">8</span> <span style="color: #008080;">do</span> <span style="color: #000080;font-style:italic;">-- (for &lt;2s)</span>
+     <span style="color: #0000FF;">{</span><span style="color: #004080;">integer</span> <span style="color: #000000;">pn</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">eg</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">sz</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">pancake</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"p(%d) = %d, example: %v (of %,d, %s)\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">pn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">eg</span><span style="color: #0000FF;">,</span><span style="color: #000000;">sz</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+<!--

Task/Pancake-numbers/PureBasic/pancake-numbers.basic

@@ -0,0 +1,26 @@
+Procedure pancake(n)
+  gap.i = 2
+  sum.i = 2
+  adj.i = -1
+  While sum < n
+    adj + 1
+    gap = (gap * 2) - 1
+    sum + gap
+  Wend
+  ProcedureReturn n + adj
+EndProcedure
+
+OpenConsole()
+Define.i i, j, c, n
+
+For i = 0 To 3
+  For j = 1 To 5
+    n = (i * 5) + j
+    c + 1
+    Print("p(" + RSet(Str(n),2) + ") = " + RSet(Str(pancake(n)),2) + "  ")
+    If Mod(c, 5 )= 0: PrintN(""): EndIf
+  Next j
+Next i
+
+Input()
+CloseConsole()

Task/Pancake-numbers/Python/pancake-numbers.py

@@ -0,0 +1,42 @@
+"""Pancake numbers. Requires Python>=3.7."""
+import time
+
+from collections import deque
+from operator import itemgetter
+from typing import Tuple
+
+Pancakes = Tuple[int, ...]
+
+
+def flip(pancakes: Pancakes, position: int) -> Pancakes:
+    """Flip the stack of pancakes at the given position."""
+    return tuple([*reversed(pancakes[:position]), *pancakes[position:]])
+
+
+def pancake(n: int) -> Tuple[Pancakes, int]:
+    """Return the nth pancake number."""
+    init_stack = tuple(range(1, n + 1))
+    stack_flips = {init_stack: 0}
+    queue = deque([init_stack])
+
+    while queue:
+        stack = queue.popleft()
+        flips = stack_flips[stack] + 1
+
+        for i in range(2, n + 1):
+            flipped = flip(stack, i)
+            if flipped not in stack_flips:
+                stack_flips[flipped] = flips
+                queue.append(flipped)
+
+    return max(stack_flips.items(), key=itemgetter(1))
+
+
+if __name__ == "__main__":
+    start = time.time()
+
+    for n in range(1, 10):
+        pancakes, p = pancake(n)
+        print(f"pancake({n}) = {p:>2}. Example: {list(pancakes)}")
+
+    print(f"\nTook {time.time() - start:.3} seconds.")

Task/Pancake-numbers/QBasic/pancake-numbers.basic

@@ -0,0 +1,22 @@
+DECLARE FUNCTION pancake! (n)
+
+FOR i = 0 TO 3
+    FOR j = 1 TO 5
+        n = (i * 5) + j
+        c = c + 1
+        PRINT USING "p(##) = ##  "; n; pancake(n);
+        IF c MOD 5 = 0 THEN PRINT
+    NEXT j
+NEXT i
+
+FUNCTION pancake (n)
+    gap = 2
+    sum = 2
+    adj = -1
+    WHILE sum < n
+        adj = adj + 1
+        gap = (gap * 2) - 1
+        sum = sum + gap
+    WEND
+    pancake = n + adj
+END FUNCTION

Task/Pancake-numbers/REXX/pancake-numbers-1.rexx

@@ -0,0 +1,19 @@
+/*REXX program calculates/displays 20 pancake numbers (from 1 to 20,inclusive). */
+/* Gerard Schildberger's code reformatted and refurbished                       */
+pad=copies(' ',10)                                               /*indentation. */
+Say pad center('pancakes',10    ) center('pancake flips',15)     /*show the hdr.*/
+Say pad center(''        ,10,"-") center('',15,"-")              /*  "   "  sep.*/
+Do pcn=1 To 20
+  Say pad center(pcn,10) center(pancake(pcn),15)                 /*index,flips. */
+  End
+Exit                                      /*stick a fork in it, we're all done. */
+/*------------------------------------------------------------------------------*/
+pancake: Procedure
+  Parse Arg n                            /* obtain  N                           */
+  gap= 2                                 /* initialize the GAP.                 */
+  sum= 2                                 /* initialize the SUM.                 */
+  Do adj=0 While sum <n                  /* perform while  SUM is less than  N. */
+    gap= gap*2 - 1                       /* calculate the GAP.                  */
+    sum= sum + gap                       /* add the  GAP  to the  SUM.          */
+    End   /*adj*/
+  Return n +adj -1                       /* return an adjusted adjustment sum.  */

Task/Pancake-numbers/REXX/pancake-numbers-2.rexx

@@ -0,0 +1,93 @@
+/* REXX Driver for pancake.test */
+do n=2 To 10
+  Call pancake n
+  End
+pancake: Procedure
+/**********************************************************************
+* REXX pancake.rex
+* The task is to determine p(n) for n = 1 to 9,
+* and for each show an example requiring p(n) flips.
+* inspired by java and output like Phix
+* 20230531 Walter Pachl
+**********************************************************************/
+Call time 'R'
+parse arg n                          -- Number of pancakes
+init=left('123456789abc',n)          -- ordered pancakes
+Call o 'heureka' n
+q.=0                                 -- implements the queue
+qp=1
+ex=0
+call qadd init
+stackFlips.=-1                       -- initialize map
+stackFlips.init=0                    -- stackFlips.v: number of flips
+                                     -- from init to v
+cnt.=0
+cnt.1=1
+max=0
+Do while qp<=q.0                     -- as long we can flip
+  s=qget()                           -- get head of queue
+  flips=stackFlips.s+1               -- flips for the successors
+  cnt.flips=cnt.flips+1              -- count them
+  If flips>max Then ex=0             -- a new maximum
+  max=max(max,flips)
+  Do i=2 To n                        -- process n-1 successors
+    t=flip(s,i)                      -- one of them
+    If stackFlips.t=-1 Then Do       -- not set so far
+      stackFlips.t=flips             -- flips from init to t
+      Call qadd t                    -- append it to the queue
+      If ex<3 Then Do                -- show the first 3 examples
+        call o flips t
+        If ex>=0 Then Do             -- record the data to be shown
+          example=''                 -- as an example (see o2)
+          Do While t<>''
+            Parse Var t c +1 t
+            Select
+              When c='a' Then c=10
+              When c='b' Then c=11
+              When c='c' Then c=12
+              Otherwise Nop
+              End
+            example=example||c||','
+            End
+          exf=flips
+          example=strip(example,'T',',')
+          End
+        ex=ex+1
+        End
+      End
+    End
+  End
+Call o 'max cnt.max:' max cnt.max
+te=time('E')                         -- elapsed time
+te=strip(format(te,8,1))
+Call o te 'seconds'
+Call o ''
+Call o2 'p('n') = 'exf', example: {'example'} (of' cnt.max', 'te's)'
+Return
+
+flip: Procedure
+Parse Arg s,k                        -- cf. flipStack in java
+Return substr(s,k,1)reverse(left(s,k-1))||substr(s,k+1)
+
+qadd:                                -- add an element to the queue
+Parse Arg e
+z=q.0+1
+q.z=e
+q.0=z
+Return
+
+qget:                                -- get top element from the queue
+e=q.qp                               -- and remove it from the queue
+qp=qp+1
+Return e
+
+o: -- investigation and debug output
+Return
+Say arg(1)
+Return lineout('heureka.txt',arg(1))
+
+o2: -- result to be shown in rosettacode
+Say arg(1)
+Call lineout 'heureka.out',arg(1)
+Call lineout 'heureka.out'
+Return

Task/Pancake-numbers/Raku/pancake-numbers-1.raku

@@ -0,0 +1,9 @@
+# 20201110 Raku programming solution
+
+sub pancake(\n) {
+   my ($gap,$sum,$adj) = 2, 2, -1;
+   while ($sum < n) { $sum += $gap = $gap * 2 - 1 and $adj++ }
+   return n + $adj;
+}
+
+for (1..20).rotor(5) { say [~] @_».&{ sprintf "p(%2d) = %2d ",$_,pancake $_ } }

Task/Pancake-numbers/Raku/pancake-numbers-2.raku

@@ -0,0 +1,21 @@
+sub pancake(\n) {
+   my @goalStack = (my \numStacks = $ = 1)..n ;
+   my %newStacks = my %stacks = @goalStack.Str, 0 ;
+   for 1..1000 -> \k {
+      my %nextStacks = ();
+      for %newStacks.keys».split(' ') X 2..n -> (@arr, \pos) {
+         given flat @arr[0..^pos].reverse, @arr[pos..*-1] {
+            %nextStacks{$_.Str} = k unless %stacks{$_.Str}:exists
+         }
+      }
+      %stacks ,= (%newStacks = %nextStacks);
+      my $perms    = %stacks.elems;
+      my %inverted = %stacks.antipairs;      # this causes loss on examples
+      my \max_key  = %inverted.keys.max;     # but not critical for our purpose
+      $perms == numStacks ?? return %inverted{max_key}, k-1 !! numStacks=$perms
+   }
+   return '', 0
+}
+
+say "The maximum number of flips to sort a given number of elements is:";
+for 1..9 -> $j { given pancake($j) { say "pancake($j) = $_[1] example: $_[0]" }}

Task/Pancake-numbers/Ring/pancake-numbers.ring

@@ -0,0 +1,15 @@
+for n = 1 to 9
+    see "p(" + n + ") = " + pancake(n) + nl
+next
+return 0
+
+func pancake(n)
+     gap = 2
+     sum = 2
+     adj = -1;
+     while (sum < n)
+            adj = adj + 1
+            gap = gap * 2 - 1
+            sum = sum + gap
+     end
+     return n + adj

Task/Pancake-numbers/Ruby/pancake-numbers.rb

@@ -0,0 +1,19 @@
+def pancake(n)
+    gap = 2
+    sum = 2
+    adj = -1
+    while sum < n
+        adj = adj + 1
+        gap = gap * 2 - 1
+        sum = sum + gap
+    end
+    return n + adj
+end
+
+for i in 0 .. 3
+    for j in 1 .. 5
+        n = i * 5 + j
+        print "p(%2d) = %2d  " % [n, pancake(n)]
+    end
+    print "\n"
+end

Task/Pancake-numbers/True-BASIC/pancake-numbers.basic

@@ -0,0 +1,21 @@
+FUNCTION pancake(n)
+    LET gap = 2
+    LET sum = 2
+    LET adj = -1
+    DO while sum < n
+       LET adj = adj+1
+       LET gap = (gap*2)-1
+       LET sum = sum+gap
+    LOOP
+    LET pancake = n+adj
+END FUNCTION
+
+FOR i = 0 to 3
+    FOR j = 1 to 5
+        LET n = (i*5)+j
+        LET c = c+1
+        PRINT  using "p(##) = ##  ": n, pancake(n);
+        IF remainder(round(c),5) = 0 then PRINT
+    NEXT j
+NEXT i
+END

Task/Pancake-numbers/Wren/pancake-numbers-1.wren

@@ -0,0 +1,21 @@
+import "/fmt" for Fmt
+
+var pancake = Fn.new { |n|
+    var gap = 2
+    var sum = 2
+    var adj = -1
+    while (sum < n) {
+        adj = adj + 1
+        gap = gap*2 - 1
+        sum = sum + gap
+    }
+    return n + adj
+}
+
+for (i in 0..3) {
+    for (j in 1..5) {
+        var n = i*5 + j
+        Fmt.write("p($2d) = $2d  ", n, pancake.call(n))
+    }
+    System.print()
+}

Task/Pancake-numbers/Wren/pancake-numbers-2.wren

@@ -0,0 +1,64 @@
+import "/fmt" for Fmt
+
+// Converts a string of the form "[1, 2]" into a list: [1, 2]
+var asList = Fn.new { |s|
+    var split = s[1..-2].split(", ")
+    return split.map { |n| Num.fromString(n) }.toList
+}
+
+// Merges two maps into one. If the same key is present in both maps
+// its value will be the one in the second map.
+var mergeMaps = Fn.new { |m1, m2|
+    var m3 = {}
+    for (key in m1.keys) m3[key] = m1[key]
+    for (key in m2.keys) m3[key] = m2[key]
+    return m3
+}
+
+// Finds the maximum value in 'dict' and returns the first key
+// it finds (iteration order is undefined) with that value.
+var findMax = Fn.new { |dict|
+    var max = -1
+    var maxKey = null
+    for (me in dict) {
+        if (me.value > max) {
+            max = me.value
+            maxKey = me.key
+        }
+    }
+    return maxKey
+}
+
+var pancake = Fn.new { |len|
+    var numStacks = 1
+    var goalStack = (1..len).toList.toString
+    var stacks = {goalStack: 0}
+    var newStacks = {goalStack: 0}
+    for (i in 1..1000) {
+        var nextStacks = {}
+        for (key in newStacks.keys) {
+            var arr = asList.call(key)
+            var pos = 2
+            while (pos <= len) {
+                var newStack = (arr[pos-1..0] + arr[pos..-1]).toString
+                if (!stacks.containsKey(newStack)) nextStacks[newStack] = i
+                pos = pos + 1
+            }
+        }
+        newStacks = nextStacks
+        stacks = mergeMaps.call(stacks, newStacks)
+        var perms = stacks.count
+        if (perms == numStacks) return [findMax.call(stacks), i - 1]
+        numStacks = perms
+    }
+}
+
+var start = System.clock
+System.print("The maximum number of flips to sort a given number of elements is:")
+for (i in 1..9) {
+    var res = pancake.call(i)
+    var example = res[0]
+    var steps = res[1]
+    Fmt.print("pancake($d) = $-2d  example: $n", i, steps, example)
+}
+System.print("\nTook %(System.clock - start) seconds.")

Task/Pancake-numbers/Yabasic/pancake-numbers.basic

@@ -0,0 +1,22 @@
+for i = 0 to 3
+    for j = 1 to 5
+        n = (i * 5) + j
+        c = c + 1
+        print "p(", n using "##", ") = ";
+		print pancake(n) using "##", "  ";
+        if mod(c, 5) = 0  print
+    next j
+next i
+end
+
+sub pancake(n)
+    gap = 2
+    sum = 2
+    adj = -1
+    while sum < n
+        adj = adj + 1
+        gap = (gap * 2) - 1
+        sum = sum + gap
+    wend
+    return n + adj
+end sub