Aujourd'hui, en jouant avec mes enfants, j'ai remarqué qu'un jouet apparemment simple dans le parc cachait un défi.

La roue a un triangle qui pointe vers un nombre, mais aussi trois cercles qui pointent vers les nombres tous les 90 degrés par rapport au premier. Alors:

Défi (vraiment simple)

Étant donné un entier compris entre 1 et 12 (celui pointé par le triangle) sous n'importe quelle forme acceptable, sortez également sous n'importe quelle forme acceptable et ordonnez les trois nombres pointés par les cercles (ceux tous les 90 degrés).

Cas de test

In       Out
1        4, 7, 10
2        5, 8, 11
3        6, 9, 12
4        7, 10, 1
5        8, 11, 2
6        9, 12, 3
7        10, 1, 4
8        11, 2, 5
9        12, 3, 6
10       1, 4, 7
11       2, 5, 8
12       3, 6, 9

C'est le code-golf , donc le code le plus court pour chaque langue gagne!

Python 3 , 33 octets

lambda n:{*range(n%3,13,3)}-{n,0}

Essayez-le en ligne!

Python 2 , 35 octets

lambda n:[(n+c)%12+1for c in 2,5,8]

Essayez-le en ligne!

Gelée , 8 octets

12Rṙ’m3Ḋ

Un lien monadique prenant un numéro et renvoyant une liste de numéros.

Essayez-le en ligne! ou voir tous les cas .

Comment?

12Rṙ’m3Ḋ - Link: number, n   e.g. 5
12       - literal twelve         12
  R      - range                  [1,2,3,4,5,6,7,8,9,10,11,12]
    ’    - decrement n            4
   ṙ     - rotate left            [5,6,7,8,9,10,11,12,1,2,3,4]
      3  - literal three          3
     m   - modulo slice           [5,8,11,2]
       Ḋ - dequeue                [8,11,2]

Python 2 , 35 octets

lambda n:(range(1,13)*2)[n+2:n+9:3]

Essayez-le en ligne!

MATL , 9 octets

I:I*+12X\

Essayez-le en ligne!

Explication

Considérez l'entrée 4comme un exmaple.

I:     % Push [1 2 3]
       % STACK: [1 2 3]
I      % Push 3
       % STACK: [1 2 3], 3
*      % Multiply, element-wise
       % STACK: [3 6 9]
+      % Add implicit input, element-wise
       % STACK: [7 10 13]
12     % Push 12
X\     % 1-based modulus. Implicit display
       % STACK: [7 10 1]

R ,  29  28 octets

Merci à @Giuseppe d'avoir enregistré un octet!

function(n)(n+1:3*3-1)%%12+1

Essayez-le en ligne!

APL + WIN, 13 octets

(⎕⌽⍳12)[3×⍳3]

Explication:

⎕ Prompt for screen input of indicated time t

⍳12 Create a vector of integers from 1 to 12

⌽ Rotate the vector by t elements front to back

[3×⍳3] Select 3rd, 6th and 9th elements.

C (gcc) , 48 octets

i;f(n){for(i=4;--i;printf("%d ",n%12?:12))n+=3;}

Essayez-le en ligne!

JavaScript (ES6), 29 octets

Similaire à la réponse de xnor .

n=>[2,5,8].map(k=>(n+k)%12+1)

Démo

let f =

n=>[2,5,8].map(k=>(n+k)%12+1)

for(n = 1; n <= 12; n++) {
  console.log(n + ' -> ' + f(n));
}

Octave , 25 octets

@(x)[a=1:12 a](3+x:3:9+x)

Essayez-le en ligne!

Fonction anonyme assez simple.

Nous créons d'abord un tableau de [1:12 1:12]- donc deux copies de l'ensemble de nombres complet. Ensuite, nous indexons pour sélectionner les valeurs de x+3, x+6, x+9, où xest le nombre entré.

L'octave est indexé 1, nous pouvons donc simplement sélectionner les éléments du tableau en fonction de l'entrée (bien que pour être honnête, l'index 0 utiliserait le même nombre d'octets ici).

Cela semble utiliser une méthode qui est unique aux autres réponses en ce sens qu'en ayant deux copies du tableau, nous n'avons pas à encapsuler les indices à l'aide de modulo.

Befunge-93, 20 19 18 octets

852<_@#:.+1%+66+&p

Essayez-le en ligne!

Explication

852                   Push 8, 5 and 2 onto the stack - the offsets we're going to add.
   <                  Reverse direction, and start the main loop.
852                   Push 2, 5, and 8 onto the stack, but we don't actually want these.
                 p    So we use a "put" operation to drop the top three values.
                &     Read the hour from stdin.
               +      Add it to the topmost offset.
         +1%+66       Mod 12 and add 1 to get it in the range 1 to 12.
        .             Then output the result to stdout.
    _@#:              Exit if the next offset is zero (i.e. nothing more on the stack).
   <                  Otherwise start the main loop again. 

Cela s'appuie sur un comportement propre à l'interpréteur de référence: en fin de fichier, l' &opérateur renvoie la dernière valeur lue. C'est pourquoi nous pouvons relire en toute sécurité l'heure de stdin à chaque itération de la boucle.

APL (Dyalog) , 12 octets

1+12|2 5 8∘+

Essayez-le en ligne!

Japt, 11 octets

3ÆU±3 uC ªC

Essayez-le

Explication

Saisie implicite d'entier U. Générez un tableau à 3 éléments ( 3Æ) et, pour chaque élément, incrémentez Ude 3 ( U±3), modulo de 12 ( uC) et, car 12%12=0, retournez le résultat OU 12 ( ªC).

Brain-Flak , 84 octets

(()()()){({}<(()(){})(((()()()){}){}<>){(({})){({}[()])<>}{}}<>(([{}]{})<>)>[()])}<>

Essayez-le en ligne!

Au moins, j'ai battu la solution pour le visage de Doorknob ...

Explication:

LOOP 3 TIMES: (()()()){({}<

  n += 2:
   (()(){})
  push 12:
   (((()()()){}){}<>)
  n mod 12 + 1; pushing to both stacks:
   {(({})){({}[()])<>}{}}<>(([{}]{})<>)

END LOOP: >[()])}<>

Pyth , 12 octets

%R12+LQ*R3S3    

Essayez-le en ligne!

SOGL V0.12 , 9 octets

3{3+:6«‰P

Essayez-le ici!

Nettoyer , 44 octets

import StdEnv
@n=[(n+i)rem 12+1\\i<-[2,5,8]]

Essayez-le en ligne!

Pushy , 12 octets

258s{K+12%h_

Essayez-le en ligne!

258            \ Push 258                            
   s           \ Split into digits, yielding [2, 5, 8]
    {K+        \ Add input to each
       12%     \ Modulo each by 12
          h    \ Increment each
           _   \ Print (space separated)

12 octets

Une alternative pour le même nombre d'octets:

12R{:{;$...#

Essayez-le en ligne!

12R            \ Push range(1, 12), inclusive
   {: ;        \ Input times do:
     {         \   Rotate left
       $       \ While there are items on stack:
        ...    \   Pop the top three
           #   \   Print top item

C # (.NET Core) , 42 octets

h=>new[]{(2+h)%12+1,(5+h)%12+1,(8+h)%12+1}

Essayez-le en ligne!

Essentiellement juste un portage de nombreuses autres réponses à C #.

K (oK) , 11 octets

Solution:

1+12!2 5 8+

Essayez-le en ligne!

Exemples:

1+12!2 5 8+1
4 7 10
1+12!2 5 8+2
5 8 11
1+12!2 5 8+3
6 9 12
1+12!2 5 8+4
7 10 1

Explication:

Ce fut la première solution qui m'est venue à l'esprit. Peut-être pas le meilleur ou le plus court.

1+12!2 5 8+ / the solution
     2 5 8+ / add 2, 5 and 8 to the input
  12!       / apply modulo 12 to the results
1+          / add 1

GolfScript, 46 octets

~13,1>:x?:y;0:i;x y 3+12%=x y 6+12%=x y 9+12%=

C'est la première fois que je fais du golf de code, donc avec mon manque d'expérience, je n'ai probablement pas trouvé la meilleure solution, mais je dois commencer quelque part, non?

Essayez-le en ligne ou essayez tous les cas

Perl 6 , 23 octets

{map ($_+*)%12+1,2,5,8}

Essayez-le en ligne!

PHP, 37 + 1 octets

while($i++<3)echo(~-$argn+=3)%12+1,_;

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

face , 96 94 octets

(%d
@)\$*,c'$ooiim%*m1*6%+%%%11m!*mn*m~*3!m&!r!&!is!&$pn3!:L+nn1+nn1%nn%+nn1p~>$inw~>~o-!!1?!L

Cela ajoute simplement deux, mods par 12, ajoute un de plus et imprime. Ensuite, il le fait encore deux fois.

Version commentée:

(%d
@)

\$*,c'$ooii     ( store format string in $, ip in *, get stdin/out )
m%*m1*6%+%%%11  ( initialize constants, %=12, 1=1 )
m!*mn*m~*       ( malloc space for a counter, input var, and length )
3!m&!r!&!i      ( read into & )
s!&$pn          ( scan into n )
3!:L            ( start of main loop, executed thrice )
  +nn1+nn1      ( add 2 to n )
  %nn%+nn1      ( mod by 12 and add 1 more )
  p~>$in        ( sprintf n into > )
  w~>~o         ( output to stdout )
  -!!1          ( decrement counter )
?!L             ( conditional jump back to loop start )

Essayez-le en ligne! (La nouvelle ligne de fin est requise sur TIO en raison d'un bug corrigé dans une version plus récente de face.)

Forth (gforth) , 39 octets

L'entrée provient de la pile et la sortie est placée sur la pile

: a 2 + 12 mod 1+ ; : f a dup a dup a ;

Essayez-le en ligne!

Explication

 : a 2 + 12 mod 1+ ; \ helper word to handle adding the hours
    2 +              \ Add 2 to the input
    12 mod           \ get the result modulo 12
    1+               \ add 1

 : f a dup a dup a ; \ word that calculates and outputs the result
    a dup            \ add 3 hours to the input and then duplicate the result
    a dup            \ add 3 hours to the duplicate then duplicate the result
    a                \ add 3 hours to the duplicate 

Haskell , 29 octets

-2 octets grâce à Laikoni.

f n=[mod(n+i)12+1|i<-[2,5,8]]

Essayez-le en ligne!

Pas très original, non ...

Swift , 30 octets

{n in[2,5,8].map{($0+n)%12+1}}

Essayez-le en ligne!

Port de nombreuses autres réponses à Swift

Wolfram Language (Mathematica) 35 octets

Range@12~RotateLeft~#~Take~{3,9,3}&

Ce qui précède affirme, en notation infixe, ce qui peut être exprimé plus clairement

Function[Take[RotateLeft[Range[12],Slot[1]],List[3,9,3]]]

RotateLefttourne Range[12], la séquence 1,2, ... 12, vers la gauche par le numéro d'entrée. Slot[1]ou #détient le numéro d'entrée, n.

Par exemple, avec n = 4,

Function[RotateLeft[Range[12],4]]]

renvoie la liste

{5, 6, 7, 8, 9, 10, 11, 12, 1, 2, 3, 4}

Take...{3,9,3} renvoie chaque troisième élément de cette liste de la position 3 à la position 9, à savoir

{7, 10, 1}

Windows Batch, 137125111 68 octets

@set/ab=(%1+2)%%12+1,c=(%1+5)%%12+1,d=(%1+8)%%12+1
@echo %b% %c% %d%

Port du add value to input and mod 12 + 1

Perl 5 , 30 octets

sub{map{($_+$_[0])%12+1}2,5,8}

Essayez-le en ligne!

PowerShell , 30 octets

param($a)2,5,8|%{($_+$a)%12+1}

Essayez-le en ligne!

Port des autres réponses (par exemple, la réponse Python 2 de xnor). Ho-hum.