## digitalmars.D - Pancake Sort comparison

• bearophile (94/94) Jun 17 2010 Another comparison, a translation of a small Python program to D2+Phobos...
```Another comparison, a translation of a small Python program to D2+Phobos2.
Again the original program was in the rosettacode site.

The task asks to implement the Pancake sort, with few demo prints in the middle:
http://en.wikipedia.org/wiki/Pancake_sorting

---------------------

The starting Python 2.x version (not written by me, I have just improved few
things):

def pancakesort(data, tutor=False):
if len(data) <= 1:
return
for size in xrange(len(data), 1, -1):
maxindex = max(range(size), key=data.__getitem__)
if maxindex+1 != size:
# This indexed max needs moving
if maxindex != 0:
# Flip the max item to the left
if tutor:
print "With:", "".join(map(str, data)), "doflip", maxindex+1
data[:maxindex+1] = data[:maxindex+1][::-1]
# Flip it into its final position
if tutor:
print "With:", "".join(map(str, data)), "doflip", size
data[:size] = data[:size][::-1]

if __name__ == "__main__":
import random

data = list("123456789")
while data == sorted(data):
random.shuffle(data)
print "Original List:", "".join(map(str, data))
pancakesort(data, tutor=True)
print "Pancake Sorted List:", "".join(map(str, data))

---------------------

A possible D2+Phobos translation:

import std.stdio, std.algorithm, std.range, std.random;

void pancakeSort(bool tutor=false, T)(T[] data) {
if (data.length <= 1)
return;
foreach_reverse (size; 2 .. data.length + 1) {
int maxIndex = size - minPos!("a > b")(data[0 .. size]).length;
if (maxIndex + 1 != size) {
// This indexed max needs moving
if (maxIndex != 0) {
// Flip the max item to the left
static if (tutor)
writeln("With: ", data, " doflip ", maxIndex + 1);
data[0 .. maxIndex + 1].reverse;
}
// Flip it into its final position
static if (tutor)
writeln("With: ", data, " doflip ", size);
data[0 .. size].reverse;
}
}
}

void main() {
char[] data = "123456789".dup;
while (data == data.dup.sort)
randomShuffle(data);
writeln("Original List: ", data);
pancakeSort!true(data);
writeln("Pancake Sorted List: ", data);
}

I like the reverse property of the built-in D arrays.

It's probably possible to make this D2 code more general, so it can sort single
linked lists too, but it's not worth it and the code gets longer and less easy
to understand.

During the translation I have found only two small troubles:

This Python line:
for size in xrange(len(data), 1, -1):

Can't be translated like this:
foreach (size; iota(data.length, 1, -1)) {
because length is unsigned, so for the way iota() is designed my code was buggy.
That's another example of why I prefer signed array lengths :-)

This works:
foreach (size; iota(cast(int)data.length, 1, -1)) {

This is another way to translate it that avoids a cast:
foreach_reverse (size; iota(2, data.length+1)) {

Or just:
foreach_reverse (size; 2 .. data.length + 1) {

The other small trouble has come from translating this not obvious Python idiom:
maxindex = max(range(size), key=data.__getitem__)

range(size) is similar to array(iota(size)).

__getitem__ is the standard Python method (of list) that supports the []
operator, similar to opIndex.

In both Python and my dlibs1 the max() takes a second optional argument that is
a key mapper function (similar to the function of schwartzSort of Phobos2 (I'd
like schwartzSort to be renamed to something simpler to write, I have to look
in the docs for its spelling every time I want to use it)), that is quite handy.

So the Python code generates the array of the first size integers, and maps on
them the first items of data, finds their max, and then returns the item of the
array, that is its index.

In this case Phobos2 offers minPos that is more fitting for the job. But
curiously minPos doesn't return an iteger, it returns a range, so if you need
the position you need something like:
a.length - minPos(a).length

I presume the way minPos is designed makes it more elastic, but in most cases I
don't need the resulting range (I don't know in what situations you need the
minPos as currently designed).

In my opinion the current "minPos" name is not good, because this function
doesn't return a position, and it's doesn't find just the minimum. The absence
of maxPos can be understood, but it needs a bit of adjustment for the
programmer, because you can use it to find the max too. In Python there is both
the min and max because it accepts the key function, and it's sometimes not
easy to invent a key function (think about finding the max or min in an array
of strings).

So in the end I have translated it with:
int maxIndex = size - minPos!("a > b")(data[0 .. size]).length;

But in a situation like that (that is common) I prefer to write:
int maxIndex = maxPos(data[0 .. size]);

This time I have found no Phobos2 or D2 bugs :-)

Bye,
bearophile
```
Jun 17 2010