La scena è:

Peter è in palestra con il suo amico Brian quando Brian improvvisamente ha un disperato bisogno del suo inalatore. Brian riesce a dire a Peter il codice del suo lucchetto a combinazione prima di crollare sul pavimento.

Nel momento in cui Peter arriva nell'armadietto di Brian e vede a cosa sta indicando l'indicatore, Stewie gli tira un'imboscata e gli spruzza in faccia una lattina piena di spray al pepe, accecando così Peter.

Peter ora deve provare ad aprire la serratura senza guardarla. Comincia a girare il quadrante verso destra, contando i numeri mentre li passa. Quindi, al numero corretto inizia a girare il quadrante verso sinistra, continuando a contare, e infine lo gira verso destra fino all'apertura della serratura.

La sfida:

Scrivi una funzione / programma che accetta due input, la combinazione di Brian e la posizione dell'indicatore. Mostra i numeri che Peter deve contare.

Regole:

• La combinazione e la posizione dell'indicatore devono essere argomenti separati.
• L'input può provenire dal prompt dei comandi o come argomenti di funzione.
• L'output deve essere stampato sullo schermo / altrimenti visualizzato (non su file)
• Supponiamo che la posizione iniziale non sia la stessa del primo numero e che tutti e tre i numeri nella combinazione siano univoci
• È il lucchetto mostrato nell'immagine qui sotto, con possibili numeri: 0-39.

Istruzioni:

Per aprire la serratura di seguito, è necessario seguire una serie di istruzioni:

1. Devi conoscere il tuo codice. Supponiamo che sia (38, 16, 22) per ora.
2. Ruotare il quadrante 3 volte verso destra (passando tre volte il numero iniziale), quindi fermarsi quando il primo numero (38) si allinea con l'indicatore
3. Ruotare il quadrante 1 giro completo a sinistra, passando il primo numero e fermarsi quando il secondo numero (16) si allinea con l'indicatore.
4. Girare la manopola verso destra e fermarsi quando il terzo numero (22) si allinea con l'indicatore
5. Abbassa il blocco

Esempio:

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

Si applicano le regole standard per il golf.

Le soluzioni pubblicate in seguito possono comunque vincere se sono più brevi della risposta di Dennis.

CJam, 52 39 byte

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

Provalo online nell'interprete CJam .

Come funziona

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 byte

Presuppone che l'indicatore sia passato come arg0 e la combo sia passata come arg1, arg2 e arg3 sulla riga di 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 byte

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]

Provalo online!

Come?

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 byte

Sembra così lungo. Ma c'è anche molto da fare.

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

Provalo online!

Penso di poter concatenare meglio alcune parti nella mia ultima riga, ma sono ancora nuovo nel campo del golf e non so come affrontare quella combinazione di elenchi in breve tempo.

Qualche idea su come migliorare?

Haskell , 135 112 byte

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

Provalo online!

Salvato 23 byte grazie a Laikoni