Alice und Bob spielen gerne ein Kartenspiel mit einem Kartenspiel, das mit aufeinander folgenden nichtnegativen ganzen Zahlen nummeriert ist.

Alice hat jedoch eine ganz besondere Art, das Deck zu mischen. Zuerst nimmt sie die oberste Karte vom Stapel und legt sie unten auf den Stapel. Dann entnimmt sie die nächste Karte und legt sie auf einen Stapel. Dann fährt sie die oberste Karte wieder nach unten und legt die neue oberste Karte auf den Stapel. Sie wiederholt diesen Vorgang, bis sie das Deck geleert hat. An diesem Punkt ist der Stapel das neue Deck.

  deck     |  pile
-----------+-----------
 3 1 4 0 2 | 
 1 4 0 2 3 | 
 4 0 2 3   |         1
 0 2 3 4   |         1
 2 3 4     |       0 1
 3 4 2     |       0 1
 4 2       |     3 0 1
 2 4       |     3 0 1
 4         |   2 3 0 1
           | 4 2 3 0 1
 4 2 3 0 1 | 

^{Abbildung 1: Alice mischt auf dem 5-Karten-Deck "3, 1, 4, 0, 2". Die Rückseiten der Karten zeigen alle nach links.}

Eines Tages gibt Bob bekannt, dass er eine Woche Urlaub macht. Alice, die niemanden hat, mit dem sie spielen kann, engagiert ihre Freundin Eva. Jetzt ist Eve ein schamloser Betrüger, und als sie Alice 'eigentümliches Durcheinander sieht, merkt sie, dass sie das Deck vorher zu ihrem Vorteil stapeln kann!

Wenn Eva nach dem ersten Tag nach Hause kommt, analysiert sie das Spiel und stellt fest, dass sie die besten Chancen hat, wenn die Karten in der Reihenfolge 0, 1, 2, 3, 4, 5 sind. Das hat sie nicht fangen Sie jedoch ab, wie viele Karten sich im Stapel befanden, und schraffieren Sie ein hirnrissiges Schema, um einen Code auf ihren Arm zu schreiben, der beim Ausführen die Größe des Stapels annimmt und die Reihenfolge anzeigt, in der Eve die Karten einlegen muss, damit wann Alice mischt das Deck, das letzte Deck ist in der Reihenfolge 0, 1, 2, 3, ...

Es spielt keine Rolle, in welcher Sprache sich der Code befindet (sie kennt sie alle) oder ob der Code eine Funktion ist, die ein ganzzahliges Argument verwendet und ein Array zurückgibt, oder ein vollständiges Programm, das Eingaben über ein Befehlszeilenargument oder STDIN vornimmt und Schreiben der Ergebnisse an STDOUT. Sie braucht den Code jedoch so kurz wie möglich, um die Wahrscheinlichkeit zu minimieren, dass Alice ihn sieht und sie fängt.

So unmoralisch es auch sein mag, könnt ihr Eve helfen?

Beispiel Ein- und Ausgänge:

in  out
 1  0
 2  0 1
 5  2 4 0 3 1
10  2 9 4 8 0 7 3 6 1 5
52  6 51 25 50 12 49 24 48 1 47 23 46 11 45 22 44 5 43 21 42 10 41 20 40 2 39 19
    38 9 37 18 36 4 35 17 34 8 33 16 32 0 31 15 30 7 29 14 28 3 27 13 26

GolfScript, 15 14 13 Bytes

])~,{\+)\+}/`

Probieren Sie es online aus.

Beispiel

$ golfscript alice.gs <<< 10
[2 9 4 8 0 7 3 6 1 5]

Wie es funktioniert

])    # Collect the stack into an array and pop. This leaves [] below the input string.
~     # Interpret the input string.
,     # For input “N”, push the array [ 0 … N-1 ] (the pile).
{     # For each card on the pile:
  \+  # Put the card on top of the deck.
  )   # Remove a card from the bottom of the deck.
  \+  # Put the card on top of the deck.
}/    #
`     # Convert the deck into a string.

Julia, 83

u(n)=(a=[n-1:-1:0];l=Int[];[push!(l,shift!(push!(l,pop!(a)))) for i=1:length(a)];l)

Das letzte Element im zurückgegebenen Vektor ist die Oberseite des Decks.

Mathematica, 92 77 46 Bytes

Erwartet die Eingabe in Variable n:

l={};(l=RotateRight[{#-1}~Join~l])&/@Range@n;l

Es wird nur buchstäblich rückwärts gespielt, indem man über eine Karte fährt und dann die unterste Karte auflegt.

BEARBEITEN: Sie müssen den Ausgabestapel nicht verfolgen, sondern müssen nur die ganzen Zahlen durchlaufen.

Python 2.7 - 57

d=[0]
for j in range(1,input()):d=[d.pop()]+[j]+d
print d

Schön und einfach, einfach den Shuffle umkehren. Ziemlich nah dran, wie es Golfscript macht.

J (13 Zeichen) und K (9)

Wie sich herausstellt, ist es ein einfacher Vorgang, das Mischen rückgängig zu machen, und APL-Likes haben das Fold-Adverb /, um dies so kurz wie möglich zu machen.

J nimmt 13 Zeichen mit (_1|.,)/@i.@-, während K braucht nur 9: |(1!,)/!:. APL wäre ähnlich knapp.

Hier ist eine Schritt-für-Schritt-Anleitung für die J-Version.

(_1|.,)/@i.@- 4                  NB. recall that J is right-associative
(_1|.,)/@i. - 4                  NB. u@v y  is  u v y
(_1|.,)/@i. _4                   NB. monad - is Negate
(_1|.,)/ i. _4                   NB. @
(_1|.,)/ 3 2 1 0                 NB. monad i. is Integers, negative arg reverses result
3 (_1|.,) 2 (_1|.,) 1 (_1|.,) 0  NB. u/ A,B,C  is  A u B u C
3 (_1|.,) 2 (_1|.,) _1 |. 1 , 0  NB. x (M f g) y  is  M f x g y
3 (_1|.,) 2 (_1|.,) _1 |. 1 0    NB. dyad , is Append
3 (_1|.,) 2 (_1|.,) 0 1          NB. dyad |. is Rotate
3 (_1|.,) _1 |. 2 , 0 1          NB. repeat ad nauseam
3 (_1|.,) _1 |. 2 0 1
3 (_1|.,) 1 2 0
_1 |. 3 , 1 2 0
_1 |. 3 1 2 0
0 3 1 2

Sie werden vielleicht bemerken, dass wir in J zuerst das Array der ganzen Zahlen umkehren, aber in K machen wir es danach: Dies liegt daran, dass die K-Falte im foldlVergleich zu den J- Zahlen eher wie eine ist foldr.