A cena é:

Peter está na academia com seu amigo Brian quando Brian de repente precisa desesperadamente de seu inalador. Brian consegue contar a Peter o código de sua fechadura de combinação antes que ele desmaie no chão.

No momento em que Peter chega ao armário de Brian e vê o que o indicador está apontando, Stewie o embosca e joga uma lata cheia de spray de pimenta em seu rosto, cegando Peter.

Peter agora deve tentar abrir a fechadura sem olhar para ela. Ele começa a girar o dial para a direita, contando os números enquanto passa por eles. Ele então, no número correto, começa a girar o dial para a esquerda, ainda contando, e finalmente o gira para a direita até que a fechadura se abra.

O desafio:

Escreva uma função / programa que aceite duas entradas, a combinação de Brian e a posição do indicador. Saída os números que Peter tem que contar.

Regras:

• A combinação e a posição do indicador devem ser argumentos separados.
• A entrada pode ser no prompt de comando ou como argumentos de função.
• A saída deve ser impressa na tela / exibida de outra forma (não no arquivo)
• Suponha que a posição inicial não seja igual ao primeiro número e que todos os três números da combinação sejam exclusivos
• É o cadeado mostrado na figura abaixo, com números possíveis: 0-39.

Instruções:

Para abrir o bloqueio abaixo, você precisa seguir um conjunto de instruções:

1. Você deve conhecer seu código. Suponha que seja (38, 16, 22) por enquanto.
2. Gire o dial 3 vezes para a direita (passando o número inicial três vezes) e depois pare quando o primeiro número (38) estiver alinhado com o indicador
3. Gire o dial 1 volta completa para a esquerda, passando o primeiro número e pare quando o segundo número (16) estiver alinhado com o indicador.
4. Gire o dial para a direita e pare quando o terceiro número (22) estiver alinhado com o indicador
5. Puxe a trava para baixo

Exemplo:

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

Aplicam-se regras de código padrão de golfe.

As soluções postadas posteriormente ainda podem vencer se forem menores que a resposta de Dennis.

CJam, 52 39 bytes

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

Experimente online no intérprete CJam .

Como 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

Assume que o indicador é passado como arg0 e a combinação é passada como arg1, arg2 e arg3 na linha 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]

Experimente online!

Quão?

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

Parece tão longo. Mas também há muita mudança acontecendo.

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],[]))

Experimente online!

Eu acho que posso concatenar algumas partes melhor na minha última linha, mas ainda sou novo no código do golfe e não sei como lidar com essa combinação de lista de uma maneira curta.

Alguma idéia para melhorar isso?

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

Experimente online!

Economizou 23 bytes graças a Laikoni