Output the hours at 90 degrees

Question

Today while playing with my kids I noticed that an apparently simple toy in the park hid a challenge.

The wheel has a triangle that points to a number, but also has three circles that point to the numbers every 90 degrees from the first one. So:

Challenge (really simple)

Given an integer between 1 and 12 (the one pointed by the triangle) in any acceptable form, output also in any acceptable form and order the three numbers pointed by the circles (the ones every 90 degrees).

Test cases

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

This is code-golf, so may the shortest code for every language win!

Answer 1

Python 3, 33 bytes

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

Try it online!

---

Python 2, 35 bytes

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

Try it online!

Answer 2

Jelly, 8 bytes

12Rṙ’m3Ḋ

A monadic link taking a number and returning a list of numbers.

Try it online! or see all cases.

How?

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]

Answer 3

Python 2, 35 bytes

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

Try it online!

Answer 4

MATL, 9 bytes

I:I*+12X\

Try it online!

Explanation

Consider input 4 as an 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]

Answer 5

R,  29  28 bytes

Thanks to @Giuseppe for saving a byte!

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

Try it online!

Answer 6

APL+WIN, 13bytes

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

Explanation:

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

Answer 7

C (gcc), 48 bytes

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

Try it online!

Answer 8

JavaScript (ES6), 29 bytes

Similar to xnor's answer.

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

Demo

let f =

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

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

Answer 9

Octave, 25 bytes

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

Try it online!

Fairly simple anonymous function.

We first create an array of [1:12 1:12] - so two copies of the full number set. Then we index in to select the values of x+3, x+6, x+9, where x is the number input.

Octave is 1-indexed, so we can simply select the array elements based on the input (although to be honest 0-indexed would use the same number of bytes here).

This seems to use a method that is unique to the other answers in that by having two copies of the array, we don't have to wrap the indices using modulo.

Answer 10

Befunge-93, 20 19 18 bytes

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

Try it online!

Explanation

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. 

This relies on behaviour specific to the reference interpreter: on end-of-file, the & operator returns the last value that was read. That's why we can safely re-read the hour from stdin on each iteration of the loop.

Answer 11

APL (Dyalog), 12 bytes

1+12|2 5 8∘+

Try it online!

Answer 12

05AB1E, 8 bytes

ƵžS+12%>

At the time of writing this, this submission has the lowest score submitted. Technically I am winning!

Try it online!

How?

ƵžS                   # Push the list [2, 5, 8]
   +                  # Add the input to each number
    12%               # Mod each result by 12
       >              # Increment each
                      # And print the ending list implicitly!

See this tip of Kevin to know why Ƶž is 258!

Answer 13

SOGL V0.12, 9 bytes

3{3+:6«‰P

Try it Here!

Answer 14

Clean, 44 bytes

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

Try it online!

Answer 15

C# (.NET Core), 42 bytes

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

Try it online!

Essentially just a port of many of the other answers to C#.

Answer 16

Japt, 11 bytes

3ÆU±3 uC ªC

Try it

---

Explanation

Implicit input of integer U. Generate a 3 element array (3Æ) and, for each element, increment U by 3 (U±3), modulo by 12 (uC) and, because 12%12=0, return the result OR 12 (ªC).

Answer 17

K (oK), 11 bytes

Solution:

1+12!2 5 8+

Try it online!

Examples:

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

Explanation:

This was the first solution that came to mind. Might not be the best or shortest.

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

Answer 18

GolfScript, 46 bytes

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

This is the first time I'm doing code golf, so with my lack of experience I've probably not found the best solution, but I need to start somewhere, right?

Try it online or try all cases

Answer 19

Brain-Flak, 84 bytes

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

Try it online!

At least I beat Doorknob's face solution...

Explanation:

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

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

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

Answer 20

Pyth, 12 bytes

%R12+LQ*R3S3    

Try it online!

Answer 21

Wolfram Language (Mathematica) 20 bytes

Mod[#+{3,6,9},12,1]&

The normal modulus operation, threaded over a list, offset by 1.

Try it online!

Answer 22

Vyxal, 8 bytes

⁺ẇf+12%›

Try it online! (All test cases)

Port of SunnyMoon's 05AB1E solution

How it works:

⁺ẇf+12%›
⁺ẇ        The number 258
  f       ...as a list of digits ⟨ 2 | 5 | 8 ⟩
   +      Add the input to each
    12%   Mod-12 each
       ›  Increment each
          (implicit output)

Answer 23

Thunno 2, 8 bytes

ṇɗd+12%⁺

Try it online!

Explanation

ṇɗd+12%⁺  # Implicit input
ṇɗ        # Push compressed integer 258
  d+      # Add [2,5,8] to input
    12%   # Mod each by 12
       ⁺  # Increment each
          # Implicit output

Answer 24

Nekomata, 9 bytes

12Rᶠ{-Z3¦

Attempt This Online!

12Rᶠ{-Z3¦
12R         [1,2,...,12]
   ᶠ{       Filter by
     -          Subtract the input
      Z         Check if the result is non-zero
       3¦       Check if the result is divisible by 3

---

Nekomata, 10 bytes

258¢D+12%→

Attempt This Online!

258¢D+12%→
258¢D       Decimal digits of 258
     +      Add
      12%   Modulo 12
         →  Increment

Answer 25

Piet + ascii-piet, 45 bytes (5×18=90 codels)

tAaaqreeumccsqqqijlVa rbiqaaueljnvea?_ t?B tt

Try Piet online!

My looping template is getting weirder and weirder... :P

inN 4    [n 4]; force toggle CC at the exit of 4 region
Loop:
  dup CC+    [n flag] switch CC on 3rd iteration so it will exit after the loop
  2 1 roll   [flag n]
  2 +        [flag n+2]
  3 dup dup * + %  [flag (n+2)%12]
  1 + d outN [flag next_n] compute and print the next number
  1 outC     [flag next_n] print the separator (ASCII 1)
  2 1 roll   [next_n flag]
  2 /        [next_n flag/2] divide flag by 2; flag becomes odd after two loops

Answer 26

Piet + ascii-piet, 62 bytes (46×2=92 codels)

TABdDTvVvVnNNFJAQUiIiIIAeEeEuUUMTJBCSBvVvVNMLnNnNfFFVBQIMEiCcc

Try Piet online!

Answer 27

Pushy, 12 bytes

258s{K+12%h_

Try it 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 bytes

An alternative for the same byte count:

12R{:{;$...#

Try it 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

Answer 28

Haskell, 29 bytes

-2 bytes thanks to Laikoni.

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

Try it online!

Not very original, no...

Answer 29

Swift, 30 bytes

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

Try it online!

Port of many other answers to Swift

Answer 30

Wolfram Language (Mathematica) 35 bytes

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

The above asserts, in infix notation, what can be expressed more clearly as

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

RotateLeft rotates Range[12], the sequence 1,2,...12, leftward by the input number. Slot[1] or # holds the input number, n.

For example, with n = 4,

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

returns the list

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

Take...{3,9,3} returns every third element in that list from position 3 through position 9, namely

{7, 10, 1}