A Alice y Bob les gusta jugar un juego de cartas, con una baraja numerada con enteros consecutivos no negativos.

Sin embargo, Alice tiene una forma muy particular de barajar la baraja. Primero, toma la carta superior del mazo y la coloca en la parte inferior del mazo. Luego ella retira la siguiente carta y comienza un montón con ella. Luego, nuevamente, coloca la carta superior en la parte inferior y coloca la nueva carta superior en la pila. Ella repite este proceso hasta que se vacía el mazo, momento en el que el montón es el nuevo mazo.

  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 | 

^{Figura 1: Alice realiza su barajado en el mazo de 5 cartas "3, 1, 4, 0, 2". La parte posterior de las cartas están todas hacia la izquierda.}

Un día, Bob anuncia que se tomará una semana de vacaciones. Alice, al no tener a nadie con quien jugar, recluta a su amiga Eve. Ahora, Eve es una tramposa desvergonzada, así que cuando ve el peculiar barajado de Alice, se da cuenta de que puede apilar la baraja de antemano para su ventaja.

Cuando Eve llega a casa después del primer día, hace un análisis del juego y descubre que sus mejores probabilidades son cuando las cartas están en el orden 0, 1, 2, 3, 4, 5, ... No lo hizo. sin embargo, capta cuántas cartas había en el mazo, por lo que trama un esquema descabellado para escribir un código en su brazo que, cuando se ejecuta, toma el tamaño del mazo y muestra el orden en el que Eva debe colocar las cartas, de modo que cuando Alice baraja el mazo, el mazo final está en el orden 0, 1, 2, 3, ...

Realmente no le importa a Eve en qué idioma está el código (ella los conoce a todos), o si el código es una función que toma un argumento entero y devuelve una matriz, o un programa completo que toma información a través de un argumento de línea de comando o STDIN y escribiendo los resultados a STDOUT. Sin embargo, necesita el código lo más breve posible, para minimizar la posibilidad de que Alice lo vea y la atrape.

Por inmoral que pueda ser, ¿pueden ayudar a Eve?

Ejemplo de entradas y salidas:

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

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

Pruébalo en línea.

Ejemplo

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

Cómo funciona

])    # 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)

El último elemento en el vector devuelto es la parte superior de la cubierta.

Mathematica, 92 77 46 bytes

Espera la entrada en variable n:

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

Literalmente, se trata de jugar aleatoriamente hacia atrás, moviéndose sobre una carta y luego colocando la carta inferior en la parte superior.

EDITAR: no es necesario realizar un seguimiento de la pila de salida, solo iterar a través de los enteros.

Python 2.7 - 57

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

Agradable y simple, simplemente invierte el barajado. Bastante cerca de cómo lo hace Golfscript.

J (13 caracteres) y K (9)

Como resultado, es un proceso simple para deshacer el shuffle, y los `` me gusta '' de APL tienen el adverbio de plegado /para ayudarlos a hacer esto lo más corto posible.

J toma 13 Char con (_1|.,)/@i.@-, mientras que K sólo necesita 9: |(1!,)/!:. APL sería igualmente breve.

Aquí hay un rastro paso a paso de la versión J.

(_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

Usted puede notar que en el J, invertimos la primera matriz de enteros, pero en el K que lo hace después: esto es debido a que el K veces se parece más a una foldl, en comparación con el de J foldr.