La scène est:

Peter est au gymnase avec son copain Brian quand Brian a soudainement grand besoin de son inhalateur. Brian parvient à dire à Peter le code de sa serrure à combinaison avant qu'il ne s'effondre sur le sol.

Au moment où Peter arrive dans le casier de Brian et voit ce que l'indicateur pointe, Stewie lui tend une embuscade et lui vaporise une pleine bouteille de gaz poivré sur le visage, aveuglant ainsi Peter.

Peter doit maintenant essayer d'ouvrir la serrure sans la regarder. Il commence à tourner le cadran vers la droite, en comptant les chiffres pendant qu'il les passe. Puis, au bon numéro, il commence à tourner le cadran vers la gauche, toujours en comptant, et enfin le tourne vers la droite jusqu'à ce que la serrure s'ouvre.

Le défi:

Écrivez une fonction / un programme qui prend deux entrées, la combinaison de Brian et la position de l'indicateur. Affiche les nombres que Peter doit compter.

Règles:

• La combinaison et la position de l'indicateur doivent être des arguments distincts.
• L'entrée peut être soit à partir de l'invite de commande, soit sous forme d'arguments de fonction.
• La sortie doit être imprimée à l'écran / autrement affichée (pas dans un fichier)
• Supposons que la position de départ n'est pas la même que le premier nombre et que les trois nombres de la combinaison sont uniques
• C'est la serrure montrée dans l'image ci-dessous, avec des nombres possibles: 0-39.

Instructions:

Pour ouvrir le verrou ci-dessous, vous devez suivre un ensemble d'instructions:

1. Vous devez connaître votre code. Supposons que ce soit (38, 16, 22) pour l'instant.
2. Tournez le cadran 3 fois vers la droite (en passant trois fois le numéro de départ), puis arrêtez-vous lorsque le premier numéro (38) s'aligne avec l'indicateur
3. Tournez le cadran d'un tour complet vers la gauche, en passant le premier chiffre, et arrêtez-vous lorsque le deuxième chiffre (16) s'aligne avec l'indicateur.
4. Tournez la molette vers la droite et arrêtez-vous lorsque le troisième numéro (22) s'aligne avec l'indicateur
5. Tirez le verrou vers le bas

Exemple:

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

Les règles de golf à code standard s'appliquent.

Les solutions publiées plus tard peuvent toujours gagner si elles sont plus courtes que la réponse de Dennis.

CJam, 52 39 octets

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

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

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 octets

Suppose que l'indicateur est passé en arg0 et le combo est passé en arg1, arg2 et arg3 sur la ligne de commande ...

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 octets

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]

Essayez-le en ligne!

Comment?

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 octets

Ça fait si longtemps. Mais il se passe également beaucoup de choses.

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

Essayez-le en ligne!

Je pense que je peux mieux concaténer certaines parties dans ma dernière ligne, mais je suis encore nouveau dans le golf de code et je ne sais pas comment aborder cette combinaison de liste de manière courte.

Des idées pour améliorer cela?

Haskell , 135 112 octets

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

Essayez-le en ligne!

23 octets enregistrés grâce à Laikoni