Scena jest:

Peter jest na siłowni ze swoim kumplem Brianem, gdy Brian nagle potrzebuje pilnie inhalatora. Brianowi udaje się przekazać Peterowi kod do zamka szyfrowego, zanim upadnie na podłogę.

W chwili, gdy Peter dociera do szafki Briana i widzi, na co wskazuje wskaźnik, Stewie zaskakuje go i rozpyla pełną puszkę pieprzu w twarz, oślepiając Petera.

Peter musi teraz spróbować otworzyć zamek, nie patrząc na niego. Zaczyna przekręcać pokrętło w prawo, licząc cyfry, gdy je podaje. Następnie, pod prawidłowym numerem, zaczyna przekręcać pokrętło w lewo, wciąż licząc, a na koniec obraca je w prawo, aż zamek się otworzy.

Wyzwanie:

Napisz funkcję / program, który pobiera dwa dane wejściowe, kombinację od Briana i pozycję wskaźnika. Wypisz liczby, które Peter musi policzyć.

Zasady:

• Kombinacja i pozycja wskaźnika muszą być osobnymi argumentami.
• Dane wejściowe mogą pochodzić z wiersza polecenia lub jako argumenty funkcji.
• Wyjście musi zostać wydrukowane na ekranie / w inny sposób wyświetlone (nie do pliku)
• Załóżmy, że pozycja początkowa nie jest taka sama jak pierwsza liczba i że wszystkie trzy liczby w kombinacji są unikalne
• Jest to zamek pokazany na poniższym obrazku, z możliwymi numerami: 0-39.

Instrukcje:

Aby otworzyć blokadę poniżej, musisz postępować zgodnie z instrukcjami:

1. Musisz znać swój kod. Załóżmy, że na razie (38, 16, 22).
2. Obróć pokrętło 3 razy w prawo (trzykrotnie mijając początkowy numer), a następnie zatrzymaj się, gdy pierwszy numer (38) zrówna się ze wskaźnikiem
3. Obróć pokrętło 1 o pełny obrót w lewo, mijając pierwszy numer, i zatrzymaj się, gdy drugi numer (16) zrówna się ze wskaźnikiem.
4. Obróć pokrętło w prawo i zatrzymaj się, gdy trzeci numer (22) zrówna się ze wskaźnikiem
5. Pociągnij blokadę w dół

Przykład:

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

Obowiązują standardowe zasady gry w golfa.

Rozwiązania, które zostaną opublikowane później, nadal mogą wygrać, jeśli są krótsze niż odpowiedź Dennisa.

CJam, 52 39 bajtów

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

Wypróbuj online w interpretatorze CJam .

Jak to działa

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 bajtów

Zakłada, że ​​wskaźnik jest przekazywany jako arg0, a kombinacja jest przekazywana jako arg1, arg2 i arg3 w wierszu poleceń ...

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 bajtów

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]

Wypróbuj online!

W jaki sposób?

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 bajty

Czuje się tak długo. Ale dzieje się również dużo.

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

Wypróbuj online!

Myślę, że mogę lepiej połączyć niektóre części w mojej ostatniej linii, ale wciąż jestem nowy w golfie i nie wiem, jak poradzić sobie z tą kombinacją list w krótki sposób.

Jakieś pomysły na poprawę tego?

Haskell , 135 112 bajtów

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

Wypróbuj online!

Zaoszczędzono 23 bajty dzięki Laikoni