Emette le ore a 90 gradi

26

Oggi mentre giocavo con i miei figli ho notato che un giocattolo apparentemente semplice nel parco nascondeva una sfida.

Orologio

La ruota ha un triangolo che punta a un numero, ma ha anche tre cerchi che indicano i numeri ogni 90 gradi dal primo. Così:

Sfida (davvero semplice)

Dato un numero intero compreso tra 1 e 12 (quello indicato dal triangolo) in qualsiasi forma accettabile, emette anche in qualsiasi forma accettabile e ordina i tre numeri indicati dai cerchi (quelli ogni 90 gradi).

Casi 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

Questo è code-golf , quindi può vincere il codice più breve per ogni lingua!

code-golf  integer  clock 
— Charlie
fonte
Possiamo prendere l'input come 0-indicizzato? Come 0 -> 4, 7, 10?
— Mr. Xcoder,
8
@ Mr.Xcoder mi dispiace, questa volta ho intenzione di dire di no.
— Charlie,
3
È questa la quarta sfida ora basata su alcune attività che coinvolgono i tuoi figli? : P
— FlipTack,
3
@FlipTack Forse abbiamo bisogno di un tag ispirato ai bambini;)
— Steadybox
6
@FlipTack Ho perso il conto. :-) Ma dato che ho trascorso la maggior parte del mio tempo libero con i miei figli, indovina da dove viene la mia ispirazione ...
— Charlie,

Risposte:

9

Gelatina , 8 byte

12Rṙ’m3Ḋ

Un collegamento monadico che prende un numero e restituisce un elenco di numeri.

Provalo online! o vedi tutti i casi .

Come?

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]
— Jonathan Allan
fonte
Soluzione alternativa: 12Rṙm-3Ḋ(output in ordine inverso)
— user202729
6

MATL , 9 byte

I:I*+12X\

Provalo online!

Spiegazione

Considera l'input 4come un esempio.

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]
— Luis Mendo
fonte
5

APL + WIN, 13 byte

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

Spiegazione:

⎕ 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.
— Graham
fonte
Abbastanza pulito. Mi piace l'approccio di rotazione indicizzata
— Uriel il
4

JavaScript (ES6), 29 byte

Simile alla risposta di xnor .

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

dimostrazione

Mostra snippet di codice

— Arnauld
fonte
Mi ero n=>[3,6,9].map(v=>(v+n)%12)quindi reso conto che restituisce 0, non 12 ...
— ericw31415
@ ericw31415 In realtà, il mio primo approccio era n=>[3,6,9].map(v=>(v+n)%12||12)(ma sono 31 byte).
— Arnauld il
4

Ottava , 25 byte

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

Provalo online!

Funzione anonima abbastanza semplice.

Per prima cosa creiamo un array di [1:12 1:12]- quindi due copie del set di numeri completo. Quindi indicizziamo per selezionare i valori di x+3, x+6, x+9, dove si xtrova il numero inserito.

Octave ha un indice 1, quindi possiamo semplicemente selezionare gli elementi dell'array in base all'input (anche se, per essere onesti, un indice 0 userebbe qui lo stesso numero di byte).

Questo sembra usare un metodo che è unico per le altre risposte in quanto avendo due copie dell'array, non dobbiamo avvolgere gli indici usando il modulo.

— Tom Carpenter
fonte
Molto bello, ma l'approccio mod "noioso" è più breve! Provalo online!
— Giuseppe,
@Giuseppe lol, sono sicuro di aver provato a usare mode non potrei accorciarlo. Molto bene! Sentiti libero di pubblicare come risposta.
— Tom Carpenter,
3

Befunge-93, 20 19 18 byte

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

Provalo online!

Spiegazione

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.

Ciò si basa sul comportamento specifico dell'interprete di riferimento: alla fine del file, l' &operatore restituisce l'ultimo valore letto. Ecco perché possiamo rileggere in sicurezza l'ora da stdin su ogni iterazione del ciclo.

— James Holderness
fonte
Neat. Non sapevo &fatto che
— Jo Re
3
@JoKing Tecnicamente è un bug nell'interprete, un altro effetto collaterale correlato che &può anche essere usato come una sorta di generatore di numeri casuali una tantum . Ciò è meno affidabile, tuttavia, poiché dipende dal compilatore utilizzato per crearlo. Al momento sta lavorando su TIO, ma c'è stato un tempo in cui Dennis è passato a una versione diversa di gcc e abbiamo perso quella funzionalità per un po '.
— James Holderness,
2

Japt, 11 byte

3ÆU±3 uC ªC

Provalo

Spiegazione

Input implicito di numero intero U. Genera un array di 3 elementi ( 3Æ) e, per ogni elemento, incrementa Udi 3 ( U±3), modulo di 12 ( uC) e, perché 12%12=0, restituisce il risultato OR 12 ( ªC).

— ispido
fonte
2

Brain-Flak , 84 byte

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

Provalo online!

Almeno ho battuto la soluzione per il viso di Doorknob ...

Spiegazione:

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

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

END LOOP: >[()])}<>
— Megatom
fonte
1

Pushy , 12 byte

258s{K+12%h_

Provalo online!

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 byte

Un'alternativa per lo stesso conteggio byte:

12R{:{;$...#

Provalo online!

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

K (oK) , 11 byte

Soluzione:

1+12!2 5 8+

Provalo online!

Esempi:

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

Spiegazione:

Questa è stata la prima soluzione che mi è venuta in mente. Potrebbe non essere il migliore o il più breve.

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
— streetster
fonte
1

GolfScript, 46 byte

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

Questa è la prima volta che sto giocando a code golf, quindi con la mia mancanza di esperienza probabilmente non ho trovato la soluzione migliore, ma devo iniziare da qualche parte, giusto?

Provalo online o prova tutti i casi

— QunSyBer
fonte
Ciao, benvenuto nel sito! Sembra una bella prima risposta :) Sfortunatamente, non so nulla di golfscript, ma potresti essere in grado di ottenere alcuni suggerimenti qui
— DJMcMayhem
1

faccia , 96 94 byte

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

Questo aggiunge semplicemente due, mod di 12, ne aggiunge uno in più e stampa. Quindi lo fa altre due volte.

Versione commentata:

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

Provalo online! (La nuova riga finale è richiesta su TIO a causa di un bug che è stato corretto in una versione più recente di Face.)

— Maniglia
fonte
La creazione di una variabile che contiene il valore 3 m3*33consente di sostituire le tre +nn1s con una +nn3 tio.run/…
— Kritixi Lithos
@Cowsquack Nota che l'output nel tuo link è errato.
— Maniglia della porta
1

Forth (gforth) , 39 byte

L'input viene prelevato dallo stack e l'output viene inserito nello stack 

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

Provalo online!

Spiegazione

 : 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
— reffu
fonte
0

Wolfram Language (Mathematica) 35 byte

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

Quanto sopra afferma, in notazione infettiva, ciò che può essere espresso più chiaramente come

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

RotateLeftruota Range[12], la sequenza 1,2, ... 12, verso sinistra dal numero di input. Slot[1]o #contiene il numero di input, n.

Ad esempio, con n = 4, 

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

ritorna l'elenco 

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

Take...{3,9,3} restituisce ogni terzo elemento in tale elenco dalla posizione 3 alla posizione 9, vale a dire

{7, 10, 1}
— DavidC
fonte
— user202729
0

Lotto di Windows, 137125111 68 byte

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

Porto del add value to input and mod 12 + 1

— stevefestl
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.