La escena es:

Peter está en el gimnasio con su amigo Brian cuando de repente Brian necesita urgentemente su inhalador. Brian logra decirle a Peter el código de su cerradura de combinación antes de que caiga al suelo.

En el momento en que Peter llega al casillero de Brian y ve lo que señala el indicador, Stewie lo embosca y rocía una lata llena de spray de pimienta en su cara, cegando a Peter.

Peter ahora debe intentar abrir la cerradura sin mirarla. Comienza a girar el dial hacia la derecha, contando los números mientras los pasa. Luego, en el número correcto, comienza a girar el dial hacia la izquierda, sigue contando, y finalmente lo gira hacia la derecha hasta que se abre la cerradura.

El reto:

Escriba una función / programa que tome dos entradas, la combinación de Brian y la posición del indicador. Saca los números que Peter tiene que contar.

Reglas:

• La combinación y la posición del indicador deben ser argumentos separados.
• La entrada puede ser desde el símbolo del sistema o como argumentos de función.
• La salida debe imprimirse en la pantalla / mostrarse de otro modo (no en el archivo)
• Suponga que la posición inicial no es la misma que el primer número, y que los tres números en la combinación son únicos
• Es la cerradura que se muestra en la imagen a continuación, con posibles números: 0-39.

Instrucciones:

Para abrir el bloqueo a continuación, debe seguir un conjunto de instrucciones:

1. Debes saber tu código. Supongamos que es (38, 16, 22) por ahora.
2. Gire el dial 3 veces hacia la derecha (pasando el número inicial tres veces), luego deténgase cuando el primer número (38) se alinee con el indicador
3. Gire el dial 1 vuelta completa hacia la izquierda, pasando el primer número y pare cuando el segundo número (16) se alinee con el indicador.
4. Gire el dial hacia la derecha y pare cuando el tercer número (22) se alinee con el indicador
5. Tire de la cerradura hacia abajo

Ejemplo:

Input
38 16 22
33  

Output
33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22  21  20  19  18  17  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  39   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31  32  33  34  35  36  37  38  39   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  15  14  13  12  11  10   9   8   7   6   5   4   3   2   1   0  39  38  37  36  35  34  33  32  31  30  29  28  27  26  25  24  23  22

Se aplican reglas estándar de golf de código.

Las soluciones que se publican más tarde aún pueden ganar si son más cortas que la respuesta de Dennis.

CJam, 52 39 bytes

q~[3X0].{@40,m<1$({(+W%}&:T*T@#)T<)}e_p

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

q~      e# Read and evaluate all input. This pushes the initial position
        e# as an integer and the combination as an array.
[3X0]   e# Push [3 1 0]. This encodes the respective numbers of full turns
.{      e# For each number in the combination (N) and the corresponding 
        e# number of full turns (F):
  @     e#   Rotate the initial position on top of the stack.
  40,m< e#   Push [0 ... 39] and rotate it that many units to the left.
        e#   For position P, this pushes [P P+1 ... 39 0 ... P-2 P-1].
  1$(   e#   Copy F and subtract 1.
  {     e#   If the result is non-zero:
    (+  e#     Rotate the array of length 40 one unit to the left.
    W%  e#     Reverse it.
  }&    e#   For position P, this pushes [P P-1 ... 0 39 ... P+2 P+1].
  :T*   e#   Save in T and repeat the array F.
  T@    e#   Push T. Rotate N on top of the stack.
  #)    e#   Find the index of N in T and add 1 to it.
  T<    e#   Keep that many elements from the beginning of T.
  )     e#   Pop the last element of the result (N).
}       e# N is the new initial position.
e_p     e# Flatten the resulting array and print it.

Groovy, 189 175 bytes

Asume que el indicador se pasa como arg0 y el combo se pasa como arg1, arg2 y arg3 en la línea de comando ...

i=(args[0]as int)+1
r={i--;i=i<0?39:i;print"$i "}
l={i=++i%40;print"$i "} 
M={j,c->while(i!=j as int){c()}}
120.times{r()}
M(args[1],r)
40.times{l()}
M(args[2],l)
M(args[3],r)

Perl 5 , 129 + 1 (-a) = 130 bytes

sub c{$f=pop;do{say$f;$f+=$_[0];$f=$f==-1?39:$f==40?0:$f}while$f-$_[1]}$p=3;c(2*!$p-1,@F[$_,$p]),$p=$_ for 3,3,3,0,0,1,2;say$F[2]

Pruébalo en línea!

¿Cómo?

sub c{                       # Takes 3 parameters: increment, ending position, starting position
  $f=pop;                    # first place to start counting
  do{
    say$f;                   # output current position
    $f+=$_[0];               # move position
    $f=$f==-1?39:$f==40?0:$f # roll over when passing zero
  }while$f-$_[1]             # stop when ending positition reached
}

# @F gets defined by the -a command line option
# @F holds the combination followed by the starting position

$p=3;                       # starting position is in array index 3, this variable will track the array index of
                            # the current position on the dial

c(2*!$p-1,@F[$_,$p]),$p=$_  # call the movement function (c), setting direction to the left (1) or right (-1) as needed
                            # based on the array index of the previous position (go left when moving from array index 0)
for 3,3,3,0,0,1,2;          # list of the array index of the next position

say$F[2]                    # output final position

Python 2, 262 bytes

Se siente tan largo. Pero también están sucediendo muchas cosas.

def f(l,s):
 r=lambda a,b,c=1:range(a,b,c)
 a=r(39,l[0],-1);b=r(l[0],-1,-1)
 c=r(l[1],l[2]-1,-1)if l[2]<l[1]else r(l[1],-1,-1);c.extend(r(39,l[2]-1,-1))
 return'  '.join(`x`for x in sum([r(s,-1,-1),a,b,a,b,a,b,r(39,l[0],-1),r(l[0],40),r(0,40),r(0,l[1]+1),c],[]))

Pruébalo en línea!

Creo que puedo concatenar algunas partes mejor en mi última línea, pero todavía soy nuevo en el código de golf y no sé cómo abordar esa combinación de lista de una manera corta.

¿Alguna idea sobre cómo mejorar esto?

Haskell , 135 112 bytes

s!t=[s..39]++[0..mod(t-1)40]
s#t=[s,s-1..0]++[39,38..mod(t+1)40]
(a%b)c s=[s#s,s#s,s#s,s#a,a!a,a!b,b#c,[c]]>>=id

Pruébalo en línea!

Guardado 23 bytes gracias a Laikoni