Hoy, mientras jugaba con mis hijos, noté que un juguete aparentemente simple en el parque ocultaba un desafío.

La rueda tiene un triángulo que apunta a un número, pero también tiene tres círculos que apuntan a los números cada 90 grados desde el primero. Asi que:

Desafío (realmente simple)

Dado un número entero entre 1 y 12 (el que señala el triángulo) en cualquier forma aceptable, emite también en cualquier forma aceptable y ordena los tres números señalados por los círculos (los que están cada 90 grados).

Casos de prueba

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

Este es el código de golf , ¡así que puede ganar el código más corto para cada idioma!

Python 3 , 33 bytes

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

Pruébalo en línea!

Python 2 , 35 bytes

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

Pruébalo en línea!

Jalea , 8 bytes

12Rṙ’m3Ḋ

Un enlace monádico que toma un número y devuelve una lista de números.

Pruébalo en línea! o ver todos los casos .

¿Cómo?

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 bytes

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

Pruébalo en línea!

MATL , 9 bytes

I:I*+12X\

Pruébalo en línea!

Explicación

Considere la entrada 4como un ejemplo.

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 bytes

¡Gracias a @Giuseppe por guardar un byte!

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

Pruébalo en línea!

APL + WIN, 13bytes

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

Explicación:

⎕ 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 bytes

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

Pruébalo en línea!

JavaScript (ES6), 29 bytes

Similar a la respuesta de xnor .

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

Manifestación

let f =

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

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

Octava , 25 bytes

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

Pruébalo en línea!

Función anónima bastante simple.

Primero creamos una matriz de [1:12 1:12]- entonces dos copias del conjunto de números completo. Luego indexamos para seleccionar los valores de x+3, x+6, x+9, donde xestá la entrada numérica.

Octave está indexada en 1, por lo que simplemente podemos seleccionar los elementos de la matriz en función de la entrada (aunque, para ser sincero, indexar en 0 usaría la misma cantidad de bytes aquí).

Esto parece usar un método que es único para las otras respuestas, ya que al tener dos copias de la matriz, no tenemos que ajustar los índices usando el módulo.

Befunge-93, 20 19 18 bytes

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

Pruébalo en línea!

Explicación

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. 

Esto se basa en el comportamiento específico del intérprete de referencia: al final del archivo, el &operador devuelve el último valor que se leyó. Es por eso que podemos volver a leer con seguridad la hora de stdin en cada iteración del bucle.

APL (Dyalog) , 12 bytes

1+12|2 5 8∘+

Pruébalo en línea!

Japt, 11 bytes

3ÆU±3 uC ªC

Intentalo

Explicación

Entrada implícita de entero U. Genere una matriz de 3 elementos ( 3Æ) y, para cada elemento, incremente Uen 3 ( U±3), módulo en 12 ( uC) y, como 12%12=0, devuelva el resultado OR 12 ( ªC).

Brain-Flak , 84 bytes

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

Pruébalo en línea!

Al menos superé la solución facial de Doorknob ...

Explicación:

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

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

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

Pyth , 12 bytes

%R12+LQ*R3S3    

Pruébalo en línea!

SOGL V0.12 , 9 bytes

3{3+:6«‰P

Pruébalo aquí!

Limpio , 44 bytes

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

Pruébalo en línea!

Pushy , 12 bytes

258s{K+12%h_

Pruébalo en línea!

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 bytes

Una alternativa para el mismo número de bytes:

12R{:{;$...#

Pruébalo en línea!

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 bytes

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

Pruébalo en línea!

Esencialmente solo un puerto de muchas de las otras respuestas a C #.

K (oK) , 11 bytes

Solución:

1+12!2 5 8+

Pruébalo en línea!

Ejemplos:

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

Explicación:

Esta fue la primera solución que me vino a la mente. Puede que no sea el mejor ni el más corto.

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 bytes

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

Esta es la primera vez que hago golf de código, así que con mi falta de experiencia, probablemente no haya encontrado la mejor solución, pero necesito comenzar en algún lado, ¿verdad?

Pruébelo en línea o pruebe todos los casos

Perl 6 , 23 bytes

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

Pruébalo en línea!

PHP, 37 + 1 bytes

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

Ejecutar como tubería con -nRo probarlo en línea .

cara , 96 94 bytes

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

Esto simplemente agrega dos, mods por 12, agrega uno más e imprime. Luego lo hace dos veces más.

Versión comentada:

(%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 )

Pruébalo en línea! (La nueva línea final se requiere en TIO debido a un error que se ha corregido en una versión más reciente de face).

Adelante (gforth) , 39 bytes

La entrada se toma de la pila y la salida se coloca en la pila

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

Pruébalo en línea!

Explicación

 : 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 bytes

-2 bytes gracias a Laikoni.

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

Pruébalo en línea!

No muy original, no ...

Rápido , 30 bytes

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

Pruébalo en línea!

Puerto de muchas otras respuestas a Swift

Wolfram Language (Mathematica) 35 bytes

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

Lo anterior afirma, en notación infija, lo que se puede expresar más claramente como

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

RotateLeftgira Range[12], la secuencia 1,2, ... 12, hacia la izquierda por el número de entrada. Slot[1]o #contiene el número de entrada, n.

Por ejemplo, con n = 4,

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

devuelve la lista

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

Take...{3,9,3} devuelve cada tercer elemento en esa lista desde la posición 3 a la posición 9, es decir

{7, 10, 1}

Lote de Windows, 137125111 68 bytes

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

Puerto del add value to input and mod 12 + 1

Perl 5 , 30 bytes

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

Pruébalo en línea!

PowerShell , 30 bytes

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

Pruébalo en línea!

Puerto de las otras respuestas (por ejemplo, la respuesta de xnor's Python 2). Ho-hum