Hiển thị 12 số trên mặt đồng hồ chính xác như thế này:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Để nhìn rõ hơn lưới, đây là một dấu chấm:

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

Lưu ý rằng lưới được kéo dài theo chiều rộng theo hệ số hai để làm cho nó trông vuông hơn.

Cũng lưu ý rằng các số có hai chữ số được căn chỉnh với chữ số của chúng tại chỗ. 9 chữ số nên được đặt ngược về bên trái.

Trả về hoặc in kết quả dưới dạng một chuỗi nhiều dòng (không phải là danh sách các dòng). Bất kỳ dấu cách là tùy chọn. Dòng mới cuối cùng cũng là tùy chọn.

Than , 40 byte

Ｆ¹²«Ｍ⁻↔⁻¹⁴⊗÷×⁴鳦⁸⁻⁴↔⁻⁷÷×⁴﹪⁺³ι¹²¦³Ｐ←⮌Ｉ⊕ι

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải thích: Tính toán các độ lệch giữa mỗi chữ số theo toán học. Than được lập chỉ mục 0 (do đó, ⊕đầu ra ), do đó, các công thức cho các độ lệch ngang và dọc như sau:$1 \ldots 12$

trong đó .$i' = i + 3 \pmod {12}$

JavaScript (Node.js) , 91 byte

Không phải là một cách tiếp cận rất thông minh, nhưng tôi đã không tìm thấy bất cứ điều gì ngắn hơn vào lúc này.

_=>`K12
E11K1

A10S2


9W3


B8S4

F7K5
L6`.replace(/[A-Z]/g,c=>''.padEnd(Buffer(c)[0]&31))

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

05AB1E , 39 33 31 byte

Cảm ơn Magic Octopus Urn đã lưu 6 byte!

Mã

6xsG12N-N•°£•NèØú«тR∞Nè¶×]\6».c

Một số lựa chọn thay thế 33 byte:

711ćŸā•Σ°w•₂вú‚øJƵt3в¶×‚ø»6xŠ».c¦
6xsŸ5L•Σ°w•₂вúõ¸ì‚ζJï2Ý«ƶ×)ø».c
6xsG¶12N-N•Θ{©•₂вNèú«ƵB∞Nè¶×]6J.c
6xsG12N-N•Θ{©•₂вNèú«тR∞Nè¶×]6s».c

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Mã máy 6502 (C64), 82 76 73 byte

00 C0 A2 0E BD 38 C0 29 03 A8 A9 0D 20 25 C0 BD 38 C0 4A 4A A8 A9 20 20 25 C0
BD 29 C0 20 D2 FF CA 10 E1 60 20 D2 FF 88 10 FA 60 36 35 37 34 38 33 39 32 30
31 31 31 31 32 31 31 2C 1A 4C 0B 5C 03 4C 00 06 2C 00 15 00 2C

• -6 byte, cảm ơn Arnauld vì ý tưởng thông minh :)
• -3 byte khác sau ý tưởng của Arnauld không xử lý các 1chữ số hàng đầu đặc biệt

Ý tưởng ở đây là chỉ lưu trữ các chữ số của tất cả các số theo thứ tự chúng cần thiết. Thông tin bổ sung cần thiết là số lượng dòng mới để trả trước và số lượng khoảng trắng ở phía trước.

Số lượng dòng mới tối đa là 3, vì vậy chúng tôi cần 2 bit cho điều này và số lượng không gian tối đa là 23, do đó 5 bit là đủ. Do đó, đối với mỗi chữ số để in, chúng ta có thể ép thông tin này trong một "byte điều khiển".

Vì vậy, dữ liệu cho giải pháp này cần chính xác 30 byte: 15 chữ số đơn và 15 "byte điều khiển" liên quan.

Bản demo trực tuyến

Cách sử dụng: SYS49152để bắt đầu.

Nhận xét tháo gỡ :

         00 C0                          ; load address
.C:c000  A2 0E       LDX #$0E           ; table index, start from back (14)
.C:c002   .mainloop:
.C:c002  BD 38 C0    LDA .control,X     ; load control byte
.C:c005  29 03       AND #$03           ; lowest 3 bits are number of newlines
.C:c007  A8          TAY                ; to Y register for counting
.C:c008  A9 0D       LDA #$0D           ; load newline character
.C:c00a  20 25 C0    JSR .output        ; repeated output subroutine
.C:c00d  BD 38 C0    LDA .control,X     ; load control byte
.C:c010  4A          LSR A              ; and shift by two positions for ...
.C:c011  4A          LSR A              ; ... number of spaces
.C:c012  A8          TAY                ; to Y register for counting
.C:c013  A9 20       LDA #$20           ; load space character
.C:c015  20 25 C0    JSR .output        ; repeated output subroutine
.C:c018  BD 29 C0    LDA .digits,X      ; load current digit
.C:c01b  20 D2 FF    JSR $FFD2          ; output
.C:c01e  CA          DEX                ; decrement table index
.C:c01f  10 E1       BPL .mainloop      ; still positive -> repeat
.C:c021  60          RTS                ; and done.
.C:c022   .outputloop:
.C:c022  20 D2 FF    JSR $FFD2          ; output a character
.C:c025   .output:
.C:c025  88          DEY                ; decrement counting register
.C:c026  10 FA       BPL .outputloop    ; still positive -> branch to output
.C:c028  60          RTS                ; leave subroutine
.C:c029   .digits:
.C:c029  36 35 37 34 .BYTE "6574"
.C:c02d  38 33 39 32 .BYTE "8392"
.C:c031  30 31 31 31 .BYTE "0111"
.C:c035  31 32 31    .BYTE "121"
.C:c038   .control:
.C:c038  31 2C 1A 4C .BYTE $31,$2C,$1A,$4C
.C:c03c  0B 5C 03 4C .BYTE $0B,$5C,$03,$4C
.C:c040  00 06 2C 00 .BYTE $00,$06,$2C,$00
.C:c044  15 00 2C    .BYTE $15,$00,$2C

Perl 6 , 76 74 byte

$_="K12
E11K1

A10S2


9W3


B8S4

F7K5
L6";say S:g/<:Lu>/{" "x$/.ord-64}/

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

Câu trả lời của cảng Arnauld cho đến khi tôi có thể đưa ra một cái gì đó ngắn hơn.

R , 75 68 byte

write("[<-"(rep("",312),utf8ToInt('*`®÷ĥĹĚä—M'),1:12),1,25)

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

Nén các vị trí chữ số. Đã làm điều này sau khi dành nhiều thời gian cố gắng đưa ra câu trả lời lượng giác (xem lịch sử chỉnh sửa).

Lấy cảm hứng từ câu trả lời R khác này mua J.Doe - upvote nó!

Đã lưu 7 byte nhờ J.Doe.

HTML + JavaScript (Canvas), 13 + 161 = 174 byte

Định vị canvas tùy ý sử dụng 6 byte.

with(C.getContext`2d`)with(Math)for(font='9px monospace',textAlign='end',f=x=>round(sin(x*PI/6)*6)*measureText(0).width*2,x=13;--x;)fillText(x,f(x)+80,f(9-x)+80)

<canvas id=C>

Với lưới để so sánh:

with(C.getContext`2d`)with(Math){
    for(font='9px monospace',textAlign='end',f=x=>round(sin(x*PI/6)*6)*measureText(0).width*2,x=13;--x;)fillText(x,f(x)+80,f(9-x)+80)
    for(globalAlpha=0.2,y=-6;y<=6;y++)fillText('.'.repeat(25),6*measureText('.').width*2+80,y*measureText(0).width*2+80)
}

<canvas id=C>

Giải thích về công thức định vị

Xem JavaScript của tôi với câu trả lời SVG .

Java 8 11, 141 138 byte

v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.print(x<59?" ".repeat(x-48):(char)(x>76?10:x-17));}

Dùng thử trực tuyến (LƯU Ý: String.repeat(int)được mô phỏng như repeat(String,int)cho cùng một số byte, vì Java 11 chưa có trên TIO.)

Giải thích tương tự như dưới đây, nhưng nó sử dụng " ".repeat(x-48)cho các khoảng trắng thay vì định dạng với "%"+(x-48)+"s".

Java 8, 141 byte

v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.printf("%"+(x>58?"c":x-48+"s"),x>76?10:x>58?x-17:"");}

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

Giải trình:

v->{                        // Method with empty unused parameter and no return-type
  for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())
                            //  Loop over the bytes of the above String:
    System.out.printf("%"+  //   Print with format:
     (x>58?                 //    If the character is a letter / not a digit:
       "c"                  //     Use "%c" as format
      :                     //    Else:
       x-48+"s"),           //     Use "%#s" as format, where '#' is the value of the digit
     x>76?                  //    If the byte is 'N':
      10                    //     Use 10 as value (newline)
     :x>58?                 //    Else-if the byte is not a digit:
      x-17                  //     Use 48-58 as value (the 0-9 numbers of the clock)
     :                      //    Else:
      "");}                 //     Use nothing, because the "%#s" already takes care of the spaces

Giải thích thêm 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Tất cả các chữ số sẽ được thay thế bằng số lượng khoảng trắng đó. (Đối với 11 không gian, do đó 92.)
• Tất cả 'N' là dòng mới
• Tất cả ['A', 'J'] là các chữ số đồng hồ ([0,9])

R, 168 159 125 byte

Giải pháp ngây thơ của việc viết các số tại các điểm quy định trong một ma trận văn bản. Điểm được lưu trữ dưới dạng các chữ cái UTF-8 được giải mã quautf8ToInt

"!"=utf8ToInt
write("[<-"(matrix(" ",25,13),cbind(!"LMFGSBCWAYCWGSM",!"AABBBDDDGGJJLLM")-64,-64+!"ABAAAA@BICHDGEF"),1,25,,"")

Bỏ 9 byte với đề xuất của JayCe để sử dụng writevà tránh xác định ma trận.

Giảm 34 byte khác với đề xuất lưu trữ của JayCe.

Haskell, 88 87 byte

f=<<"k12{e11k1{{a10s2{{{9w3{{{b8s4{{f7k5{l6"
f c|c>'z'="\n"|c>'9'=' '<$['a'..c]|1<2=[c]

Phương thức encode-space-as-Letters (lần đầu tiên nhìn thấy trong câu trả lời của @ Arnauld ) trong Haskell. Sử dụng {và mở rộng nó \nngắn hơn một byte so với sử dụng \ntrực tiếp.

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

Rust , 96 byte

||format!(r"{:13}
     11{:12}

 10{:20}


9{:24}


  8{:20}

{:7}{:12}
{:13}",12,1,2,3,4,7,5,6)

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

Brainfuck , 240 235 byte

++++++++++[>++>+>+++>+++++>++>++[<]>-]>>>++...........>-.+.<<.>.....>-..<...........>.<<..>.>.-.>-[<<.>>-]<++.<<...>>+++++++.>>+++[<<<.>>>-]<<------.<<...>..>+++++.<<<-[>>.<<-]>>>----.<<..>......>+++.<...........>--.<<.>............>+.

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

Mã nhận xét

++++++++++                              Put 10 in cell 0
[>++>+>+++>+++++>++>++[<]>-]            Loop 10 times incrementing to leave 0 20 10 30 50 20 20 in memory 
>>>++                                   30 plus 2 = 32 (ascii space)
...........>-.+.                        print 11spaces followed by 12 (ascii 49 50)
<<.>.....>-..<...........>.             print 1newline 5spaces 11 11spaces 1 
<<..>.>.-.>-[<<.>>-]<++.                print 2newlines 1space 10 19spaces 2
<<...>>+++++++.>>+++[<<<.>>>-]<<------. print 3newlines         9 23spaces 3
<<...>..>+++++.<<<-[>>.<<-]>>>----.     print 3newlines 2spaces 8 19spaces 4
<<..>......>+++.<...........>--.        print 2newlines 6spaces 7 11spaces 5
<<.>............>+.                     print 1newline  12spaces 6

Một ví dụ hiếm hoi trong đó văn bản đủ lặp đi lặp lại rằng chương trình brainfuck nhỏ hơn hai lần 1,6 lần chiều dài của đầu ra!

2 byte được lưu theo đề xuất từ ​​Jo King: >>>>>>-->[<]>-

3 byte được lưu bằng cách di chuyển bộ đếm xuống 20 vị trí thứ ba từ ngoài cùng bên phải của mã ascii 10 30 50sang ngay bên trái của chúng. Lưu <<>>khi điền vào khoảng trống giữa 8và 4thêm 1 byte vào dòng >>>++.

Phiên bản gốc

++++++++++                              Put 10 in cell 0
[>+>+++>+++++>++>++>++<<<<<<-]          Loop 10 times incrementing to leave 0 10 30 50 20 20 20 in memory 
>>++                                    30 plus 2 = 32 (ascii space)
...........>-.+.                        print 11spaces followed by 12 (ascii 49 50)
<<.>.....>-..<...........>.             print 1newline 5spaces 11 11spaces 1 
<<..>.>.-.>-[<<.>>-]<++.                print 2newlines 1space 10 19spaces 2
<<...>>+++++++.>>+++[<<<.>>>-]<<------. print 3newlines         9 23spaces 3
<<...>..>+++++.>>>-[<<<<.>>>>-]<<<----. print 3newlines 2spaces 8 19spaces 4
<<..>......>+++.<...........>--.        print 2newlines 6spaces 7 11spaces 5
<<.>............>+.                     print 1newline  12spaces 6

Python 2 , 97 byte

for i in range(7):w=abs(3-i);print'%*d'%(1-~w*w,12-i),'%*d'%(24-3**w-2*w,i)*(w<3),'\n'*min(i,5-i)

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

Tính toán tất cả các khoảng cách và dòng mới trong vòng lặp

Thạch , 32 byte

⁶ẋ“¿×¿ Œ4ç4Œ!¿Ø‘ż“øn0œ’Œ?D¤Fs25Y

Một chương trình đầy đủ in kết quả.

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

Làm sao?

(Tôi chưa nghĩ đến / tìm thấy bất cứ điều gì ngắn hơn so với phần “¿×¿ Œ4ç4Œ!¿Ø‘này dường như dài đối với tôi - phần nảy / giải nén cơ sở / gia tăng, dường như không có gì để lưu!)

⁶ẋ“¿×¿ Œ4ç4Œ!¿Ø‘ż“øn0œ’Œ?D¤Fs25Y - Main Link: no arguments
⁶                                - space character
  “¿×¿ Œ4ç4Œ!¿Ø‘                 - code-page indices list = [11,17,11,32,19,52,23,52,19,33,11,18]
 ẋ                               - repeat (vectorises) -> [' '*11, ' '*17, ...]
                          ¤      - nilad followed by link(s) as a nilad:
                 “øn0œ’          -   base 250 number = 475699781
                       Œ?        -   first natural number permutation which would be at
                                 -   index 475699781 if all permutations of those same
                                 -   natural numbers were sorted lexicographically
                                 -   = [12,11,1,10,2,9,3,8,4,7,5,6]
                         D       -   to decimal lists = [[1,2],[1,1],[1],[1,0],[2],[9],[3],[8],[4],[7],[5],[6]]
                ż                - zip together = [[' '*11, [1,2]], [' '*17, [1,1]], ...]
                           F     - flatten = [' ',' ',...,1,2,' ',' ',...,1,1,...]
                            s25  - split into chunks of 25 (trailing chunk is shorter)
                               Y - join with new line characters
                                 - implicit print

C (gcc) , 145 137 125 byte

Chỉ các vị trí tab được mã hóa cứng: tất cả các khoảng cách dòng và giá trị đồng hồ được tạo trong vòng lặp.

Cảm ơn một lần nữa để trần nhà cho những gợi ý.

i,j,k;f(char*t){for(i=7;i--;t=memset(t+sprintf(t,"%*d%*d"+3*!j,"NHDA"[j]-65,6+i,"AMUY"[j]-65,6-i),10,k=j+i/4)+k)j=i>3?6-i:i;}

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

PHP , 97 byte

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

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

Đây là một chuỗi nén mã hóa cứng. Tôi không thể tìm ra giải pháp nào ngắn hơn thế này!

Pyke , 37 byte

3B 32 35 75 07 0d 13 0c 22 14 35 18 44 74 5F 74 2B 46 6F 68 32 C4 52 7D 74 2A 31 32 25 31 32 7C 60 52 2D 29 73

Hãy thử nó ở đây! (byte thô)

;25Dt_t+Foh2.DR}t*12%12|`R-)s

Hãy thử nó ở đây! (Con người có thể đọc được)

                              - o = 0
;25                           - set line width to 25 characters
                              -      `[13, 19, 12, 34, 20, 53, 24]`
                              -       (In hex version, encoded in base 256, regular version in input field)
    t_t                       -     reversed(^[1:])[1:]
   D   +                      -    ^^ + ^
        Foh2.DR}t*12%12|`R-)  -   for i in ^:
         o                    -            o++
          h                   -           ^+1
           2.DR               -          divmod(^, 2)
               }t             -         (remainder*2)-1
                 *            -        quotient * ^
                  12%         -       ^ % 12
                     12|      -      ^ or 12 (12 if 0 else ^)
                        `     -     str(^)
                         R-   -    ^.rpad(i) (prepend spaces such that length i)
                            s -  sum(^)
                              - output ^ (with newlines added)

Brainfuck , 315 313 byte

tiết kiệm được 2 byte nhờ vào ovs !

++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+++++++>+><<<...........>>.<<<<.>.>.....>>..<<...........>>.<<<..>.>>.>.<<<...................<<.>...>>++.<.......................<<<.>>...>..>-.<...................<<<<.>>>..>......>-.<...........<<<<<.>>>>.>............>-.

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

tất cả trong một khối mã:

++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+
++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+
++++++>+><<<...........>>.<<<<.>.>.....>>..<<
...........>>.<<<..>.>>.>.<<<................
...<<.>...>>++.<.......................<<<.>>
...>..>-.<...................<<<<.>>>..>.....
.>-.<...........<<<<<.>>>>.>............>-.

Powershell, 94 88 82 byte

Toán tử định dạng Powershell trực tiếp . {i,w}có nghĩa là một trình giữ chỗ cho một tham số có chỉ mục i, chiều rộng của trình giữ chỗ wcó căn lề phải.

"{11,13}
{10,7}{0,12}

 10{1,20}


9{2,24}


  8{3,20}

{6,7}{4,12}
{5,13}"-f1..12

Powershell, 88 byte

Câu trả lời Javascript của cảng Arnauld

-6 byte nhờ @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

F7K5
L6",'[A-Z]',{' '*("$args"[0]-64)})

Để nhìn rõ hơn lưới, sử dụng '.'thay thế ' '.

C (gcc) , 125 109 105 byte

x,*d=L"<;1:2938475640P`P05";main(i){for(;i=d[12];printf("%*d",i/4,*d++-48))for(x=i&3;x--;)puts("");}

• -16 byte (-3 để sắp xếp vòng lặp tốt hơn, -13 cho trực tiếp bao gồm cả các ký tự không in được) nhờ Jonathan Frech .
• -4 byte bằng cách thay thế một bộ phận cho một ca và lạm dụng thực tế là trên nhiều hệ thống (như một TIO lưu trữ), sizeof(wchar_t) == sizeof(int)- sẽ không hoạt động trên windows :) Cảm ơn ErikF vì ý tưởng này.

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

Đây là một cổng trong ý tưởng chung của tôi từ giải pháp 6502 cho C. Nó được sửa đổi một chút: Thay vì có một cờ cho một đầu 1, ký tự được in dưới dạng thập phân bằng cách trừ 48, vì vậy 10-12 được mã hóa :thành <.

Tùy viên , 69 byte

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

g7l5
m6",/"\\l",sp&`*@STN]}

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

Điều này mã hóa từng lần chạy của không gian là : NTS[count of spaces]; NTSlà nội dung "từ số đến ngắn", cho phép các số được thể hiện dưới dạng chuỗi. Ví dụ, NTS[95] = $R1và NTS[170297] = $XQO. STNlà nghịch đảo của nội dung này.

Câu trả lời này thay thế ( ReplaceF) tất cả các lần xuất hiện của các chữ cái ( /\l/) trong đầu vào bằng kết quả của hàm sp&`*@STN, trước tiên giải mã chữ cái và sau đó lặp lại sp(một khoảng trắng) nhiều lần.

Swift , 178 165 byte

var b="";for c in"L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6"{let i=c.unicodeScalars.first!.value;if c=="n"{b+="\n"}else if i>64{for _ in 0..<(i-65){b+=" "}}else{b+="(c)"}};print(b)

Dựa trên những gì mà Downgoat đã đăng, tôi đã giảm xuống còn 165 byte:

print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map{let x=Int($0.value);return x==110 ?"\n":(x>64 ?String(repeating:" ",count:x-65):"($0)")}.joined())

Mở rộng ra, với $0chuyển đổi thành một biến có tên:

print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map { c in let x = Int(c.value) return x == 110 ? "\n" : (x>64 ? String(repeating:" ", count: x-65) : "(c)") }.joined())

Chuỗi đầu vào được mã hóa như sau: Chữ in hoa ( A-Z) đại diện cho các khối khoảng trắng, được bù bởi 65. Vì vậy, Acó nghĩa là 0 khoảng trắng, Bcó nghĩa là 1 khoảng trắng, đầu tiên Lcó nghĩa là 11 khoảng trắng, v.v ... nđược chuyển đổi thành dòng mới. Tất cả các ký tự khác được in nguyên trạng.

Chạy nó trực tuyến tại đây (cảm ơn, mbomb007)

Bash tinh khiết , 123

printf không nâng vật nặng ở đây:

n=" 0 a 0 a"
printf -vo %*s%*s\\n 0 a 13 12 7 11 12 1 $n 3 10 20 2$n$n 1 9 24 3$n$n 3 8 20 4$n 7 7 12 5 13 6
echo "${o//a}"

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

Màu đỏ , 151 byte

foreach[a b c d][13 12 1""7 11 12 1 1""1""3 10 20 2 1""1"^/"0 9 24 3 1""1"^/"3 8 20 4 1""1""7 7 12 5 13 6 1""][print rejoin[pad/left b a pad/left d c]]

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

JavaScript với SVG, 188 byte

Chiều cao dòng tùy ý 120% sử dụng 4 byte.

with(Math)for(s='<pre><svg viewBox=-8-8+16+16 style=font-size:1;text-anchor:end>',f=x=>round(sin(x*PI/6)*6),x=13;--x;)s+=`<text x=${f(x)*2}ch y=${f(9-x)*1.2}>${x}</text>`
document.write(s)

Với lưới để so sánh:

with(Math)for(s='<pre><svg viewBox=-8-8+16+16 style=font-size:1;text-anchor:end>',f=x=>round(sin(x*PI/6)*6),x=13;--x;)s+=`<text x=${f(x)*2}ch y=${f(9-x)*1.2}>${x}</text>`
for(y=-6;y<=6;y++)s+=`<text x=12ch y=${y*1.2} style=fill:#0002>${'.'.repeat(25)}</text>`
document.write(s)

Giải thích về công thức định vị

Hãy để f(x) = round(sin(x * π/6) * 6).

Giả sử gốc tọa độ là tâm của đồng hồ, tọa độ lưới của chữ số bên phải nhất của bất kỳ số đồng hồ đã cho nào xlà [ f(x) * 2, f(9 - x)].

Bash, 225 byte

s=(12 0 6 11 0 0 2 19 0 0 0 0 1 23 0 0 0 0 3 19 0 0 7 11 13 0)
n=(12 11 1 10 2 9 3 8 4 7 5 6) j=0;for i in {0..25};{
[ ${s[i]} = 0 ]||{ printf %${s[i]}s " ";echo -n ${n[j]}
j=$((j+1));};[ $((i%2)) -gt 0 ]&&echo;}|sed 's/ //'

Khó chịu, điều này dài hơn giải pháp ngây thơ khi chỉ in mỗi dòng trong một vòng lặp (132 ký tự nếu sử dụng các tabstops).

Python 3 , 112 88 87 byte

Một giải pháp sử dụng phép nội suy chuỗi.

print(f'''{12:13}
{11:7}{1:12}

 10{2:20}


9{3:24}


  8{4:20}

{7:7}{5:12}
{6:13}''')

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

-25 byte nhờ vào ovs và Herman L.

C (gcc) , 135 123 110 byte

Điều này sử dụng một mã hóa đơn giản trong đó bất kỳ cgiữa 'a'và 'z'đại diện cho c-'a'+1không gian lặp lại, '`'đại diện cho một dòng mới và tất cả các ký tự khác được giữ nguyên.

f(i){char*s="k12`e11k1``a10s2```9w3```b8s4``f7k5`l6`";for(;i=*s;s++)i>96?printf("%*s",i-96,""):putchar(i%86);}

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

T-SQL, 132 byte

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

Chỉ ngắn hơn 12 byte so với giải pháp tầm thường (PRINT của toàn bộ chuỗi nguyên trạng).

Tìm thấy một biến thể tôi thích đó dài hơn nhiều ( 235 226 byte), nhưng giống SQL hơn nhiều:

SELECT CONCAT(SPACE(PARSENAME(value,4)),PARSENAME(value,3),
              SPACE(PARSENAME(value,2)),PARSENAME(value,1))
FROM STRING_SPLIT('11.1..2,5.11.11.1,. .. ,1.10.20.2,. .. ,. .. ,.9.23.3,
                   . .. ,. .. ,2.8.19.4,. .. ,6.7.11.5,12.6.. ',',')

STRING_SPLITchia nó thành các hàng tại dấu phẩy và PARSENAMEchia từng hàng tại các dấu chấm. Thứ 1 và thứ 3 được sử dụng cho số lượng không gian để in, thứ 2 và thứ 4 được sử dụng cho những gì cần hiển thị.

(ngắt dòng trong phần này chỉ để dễ đọc)

Perl 6 , 116 byte

my@a=["  "xx 13]xx 13;($_=pi/6*++$;@a[0+|6*(1.1-.cos);0+|6*(1.1+.sin)]=fmt ++$: "%2s")xx 12;@a>>.join>>.&{say S/.//}

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

(Ta @JoKing để lưu 26 ​​byte)

Perl 6 , 142 byte

my@a=[[[32,32]xx 13]xx 13];for 1..12 {$_=$^b*pi/6;@a[round 6*(1-.cos);round 6*(1+.sin)]=[" $b".ords.tail(2)]}
{say S/^.//}(.[*;*].chrs) for @a

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

Tôi đã từng muốn làm một cái gì đó khác. Vì vậy, cái này sẽ tính toán vị trí của tất cả các chữ số, thông qua các cặp ký tự, loại bỏ khoảng trống ban đầu và in các dòng.

Dễ dàng sửa đổi cho các tham số khác nhau, ví dụ: phiên bản rộng 45 ký tự với 17 chữ số .