Die Szene ist:

Peter ist mit seinem Kumpel Brian im Fitnessstudio, als Brian plötzlich dringend seinen Inhalator braucht. Brian schafft es, Peter den Code für sein Zahlenschloss mitzuteilen, bevor er auf dem Boden zusammenbricht.

In dem Moment, in dem Peter zu Brians Spind kommt und sieht, auf was der Indikator zeigt, überfällt Stewie ihn und sprüht ihm eine volle Dose Pfefferspray ins Gesicht, wodurch Peter erblindet.

Peter muss jetzt versuchen, das Schloss zu öffnen, ohne es anzusehen. Er fängt an, das Rad nach rechts zu drehen und zählt die Zahlen, während er an ihnen vorbeigeht. Dann beginnt er, bei der richtigen Nummer, das Zifferblatt nach links zu drehen, zählt noch und dreht es schließlich nach rechts, bis sich das Schloss öffnet.

Die Herausforderung:

Schreiben Sie eine Funktion / ein Programm, das zwei Eingaben übernimmt, die Kombination von Brian und die Anzeigeposition. Gib die Zahlen aus, die Peter zählen muss.

Regeln:

• Die Kombination und die Indikatorposition müssen separate Argumente sein.
• Die Eingabe kann entweder über die Eingabeaufforderung oder als Funktionsargument erfolgen.
• Die Ausgabe muss auf dem Bildschirm gedruckt / anderweitig angezeigt werden (nicht in eine Datei)
• Angenommen, die Startposition stimmt nicht mit der ersten Zahl überein, und alle drei Zahlen in der Kombination sind eindeutig
• Es ist das im Bild gezeigte Schloss mit möglichen Nummern: 0-39.

Anleitung:

Um das Schloss unten zu öffnen, müssen Sie eine Reihe von Anweisungen befolgen:

1. Sie müssen Ihren Code kennen. Angenommen, es ist (38, 16, 22) für den Moment.
2. Drehen Sie den Drehknopf dreimal nach rechts (dreimal über die Startnummer hinaus) und hören Sie dann auf, wenn die erste Nummer (38) mit der Anzeige übereinstimmt
3. Drehen Sie den Drehknopf 1 Umdrehung nach links, wobei Sie die erste Ziffer überschreiten, und halten Sie an, wenn die zweite Ziffer (16) mit der Anzeige übereinstimmt.
4. Drehen Sie den Drehknopf nach rechts und halten Sie an, wenn die dritte Ziffer (22) mit der Anzeige übereinstimmt
5. Ziehen Sie das Schloss nach unten

Beispiel:

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

Es gelten die Standard-Code-Golfregeln.

Lösungen, die später veröffentlicht werden, können immer noch gewinnen, wenn sie kürzer sind als Dennis 'Antwort.

CJam, 52 39 Bytes

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

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

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

Angenommen, der Indikator wird als arg0 und die Kombination als arg1, arg2 und arg3 in der Befehlszeile übergeben ...

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]

Probieren Sie es online!

Wie?

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

Es fühlt sich so lang an. Es ist aber auch viel los.

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

Probieren Sie es online!

Ich denke, ich kann einige Teile in meiner letzten Zeile besser verketten, aber ich bin noch neu im Codieren von Golf und ich weiß nicht, wie ich diese Listenkombination auf kurze Weise angehen soll.

Ideen zur Verbesserung dieser?

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

Probieren Sie es online!

23 Bytes dank Laikoni gespart