Hôm nay trong khi chơi với những đứa trẻ của tôi, tôi nhận thấy rằng một món đồ chơi đơn giản trong công viên đã che giấu một thách thức.

Bánh xe có một hình tam giác chỉ vào một số, nhưng cũng có ba vòng tròn trỏ đến các số mỗi 90 độ so với số đầu tiên. Vì thế:

Thử thách (thực sự đơn giản)

Cho một số nguyên từ 1 đến 12 (một số được chỉ bởi tam giác) ở bất kỳ dạng nào có thể chấp nhận được, đầu ra cũng ở bất kỳ dạng nào có thể chấp nhận và sắp xếp ba số được chỉ bởi các vòng tròn (các số cứ 90 độ).

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy có thể là đoạn mã ngắn nhất cho mọi ngôn ngữ sẽ giành chiến thắng!

Python 3 , 33 byte

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

Hãy thử trực tuyến!

Python 2 , 35 byte

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

Hãy thử trực tuyến!

Thạch , 8 byte

12Rṙ’m3Ḋ

Một liên kết đơn âm lấy một số và trả về một danh sách các số.

Hãy thử trực tuyến! hoặc xem tất cả các trường hợp .

Làm sao?

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 byte

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

Hãy thử trực tuyến!

MATL , 9 byte

I:I*+12X\

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào 4như một ví dụ.

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 byte

Cảm ơn @Giuseppe vì đã tiết kiệm một byte!

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

Hãy thử trực tuyến!

APL + THẮNG, 13byte

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

Giải trình:

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

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

Hãy thử trực tuyến!

JavaScript (ES6), 29 byte

Tương tự như câu trả lời của xnor .

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

Bản giới thiệu

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 byte

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

Hãy thử trực tuyến!

Chức năng ẩn danh khá đơn giản.

Trước tiên chúng tôi tạo một mảng gồm [1:12 1:12]- vì vậy hai bản sao của bộ số đầy đủ. Sau đó, chúng tôi lập chỉ mục để chọn các giá trị của x+3, x+6, x+9, đâu xlà đầu vào số.

Octave được lập chỉ mục 1, vì vậy chúng ta chỉ cần chọn các phần tử mảng dựa trên đầu vào (mặc dù thành thật mà nói, chỉ mục 0 sẽ sử dụng cùng số byte ở đây).

Điều này dường như sử dụng một phương thức duy nhất cho các câu trả lời khác ở chỗ bằng cách có hai bản sao của mảng, chúng ta không phải bọc các chỉ số bằng modulo.

Befunge-93, 20 19 18 byte

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

Hãy thử trực tuyến!

Giải trình

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. 

Điều này phụ thuộc vào hành vi cụ thể đối với trình thông dịch tham chiếu: ở cuối tệp, &toán tử trả về giá trị cuối cùng được đọc. Đó là lý do tại sao chúng ta có thể đọc lại giờ một cách an toàn từ stdin trên mỗi lần lặp của vòng lặp.

APL (Dyalog) , 12 byte

1+12|2 5 8∘+

Hãy thử trực tuyến!

Japt, 11 byte

3ÆU±3 uC ªC

Thử nó

Giải trình

Đầu vào ngầm định của số nguyên U. Tạo một mảng 3 phần tử ( 3Æ) và, cho mỗi phần tử, tăng U3 ( U±3), modulo bằng 12 ( uC) và, bởi vì 12%12=0, trả về kết quả HOẶC 12 ( ªC).

Brain-Flak , 84 byte

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

Hãy thử trực tuyến!

Ít nhất tôi đã đánh bại giải pháp mặt của Doorknob ...

Giải trình:

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

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

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

Bình thường , 12 byte

%R12+LQ*R3S3    

Hãy thử trực tuyến!

SOGL V0.12 , 9 byte

3{3+:6«‰P

Hãy thử nó ở đây!

Sạch sẽ , 44 byte

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

Hãy thử trực tuyến!

Pushy , 12 byte

258s{K+12%h_

Hãy thử trực tuyến!

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

Một thay thế cho cùng một số byte:

12R{:{;$...#

Hãy thử trực tuyến!

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 byte

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

Hãy thử trực tuyến!

Về cơ bản chỉ là một cổng của nhiều câu trả lời khác cho C #.

K (oK) , 11 byte

Dung dịch:

1+12!2 5 8+

Hãy thử trực tuyến!

Ví dụ:

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

Giải trình:

Đây là giải pháp đầu tiên xuất hiện trong tâm trí. Có thể không phải là tốt nhất hoặc ngắn nhất.

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 byte

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

Đây là lần đầu tiên tôi chơi golf mã, vì vậy với kinh nghiệm thiếu kinh nghiệm của tôi, có lẽ tôi chưa tìm được giải pháp tốt nhất, nhưng tôi cần bắt đầu ở đâu đó, phải không?

Dùng thử trực tuyến hoặc thử tất cả các trường hợp

Perl 6 , 23 byte

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

Hãy thử trực tuyến!

PHP, 37 + 1 byte

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

Chạy như ống với -nRhoặc thử trực tuyến .

mặt , 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

Điều này chỉ đơn giản là thêm hai, mod bằng 12, thêm một và in. Sau đó, nó làm điều đó thêm hai lần nữa.

Phiên bản đã bình luận:

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

Hãy thử trực tuyến! (Dòng mới được yêu cầu trên TIO do lỗi đã được sửa trong phiên bản mới hơn của khuôn mặt.)

Forth (gforth) , 39 byte

Đầu vào được lấy từ ngăn xếp và đầu ra được đặt trên ngăn xếp

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

Hãy thử trực tuyến!

Giải trình

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

-2 byte nhờ Laikoni.

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

Hãy thử trực tuyến!

Không độc đáo lắm, không ...

Swift , 30 byte

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

Hãy thử trực tuyến!

Cổng của nhiều câu trả lời khác cho Swift

Ngôn ngữ Wolfram (Mathicala) 35 byte

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

Các khẳng định trên, trong ký hiệu infix, những gì có thể được thể hiện rõ ràng hơn như

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

RotateLeftxoay Range[12], dãy 1,2, ... 12, sang trái theo số đầu vào. Slot[1]hoặc #giữ số đầu vào, n.

Ví dụ: với n = 4,

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

trả về danh sách

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

Take...{3,9,3} trả về mọi phần tử thứ ba trong danh sách đó từ vị trí 3 đến vị trí 9, cụ thể là

{7, 10, 1}

Batch Windows, 137 125 111 68 byte

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

Cảng của add value to input and mod 12 + 1

Perl 5 , 30 byte

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

Hãy thử trực tuyến!

PowerShell , 30 byte

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

Hãy thử trực tuyến!

Cổng của các câu trả lời khác (ví dụ: câu trả lời Python 2 của xnor). Hồ-hum.