แสดงตัวเลข 12 ตัวบนหน้าปัดนาฬิกาแบบนี้

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

หากต้องการดูกริดให้ดีขึ้นนี่คือจุดที่มีจุด:

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

โปรดทราบว่ากริดยืดความกว้างออกเป็นสองส่วนเพื่อให้ดูกว้างขึ้น

โปรดทราบว่าตัวเลขสองหลักนั้นสอดคล้องกับตัวเลขในตำแหน่ง ตัวเลข 9 หลักควรอยู่ด้านซ้ายมือ

ส่งคืนหรือพิมพ์ผลลัพธ์เป็นสตริงหลายบรรทัด (ไม่ใช่รายการของบรรทัด) ช่องว่างต่อท้ายใด ๆ เป็นตัวเลือก บรรทัดใหม่สุดท้ายยังเป็นตัวเลือก

ถ่าน 40 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย: คำนวณออฟเซ็ตระหว่างแต่ละหลักทางคณิตศาสตร์ Charcoal มีการจัดทำดัชนี 0 (ดังนั้น⊕ไปยังเอาต์พุต ) ดังนั้นสูตรสำหรับออฟเซ็ตแนวนอนและแนวตั้งจึงเป็นดังนี้:$1 \ldots 12$

ที่{12}$i' = i + 3 \pmod {12}$

JavaScript (Node.js) , 91 ไบต์

ไม่ใช่วิธีที่ฉลาดมาก แต่ฉันไม่สามารถหาอะไรที่สั้นกว่านี้ได้ในขณะนี้

_=>`K12
E11K1

A10S2


9W3


B8S4

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

ลองออนไลน์!

05AB1E , 39 33 31 ไบต์

ขอบคุณMagic Octopus Urnสำหรับการบันทึก 6 ไบต์!

รหัส

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

ทางเลือก 33 ไบต์:

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

ใช้05AB1Eเข้ารหัส ลองออนไลน์!

รหัสเครื่อง 6502 (C64), 82 76 73 ไบต์

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 ไบต์ขอบคุณArnauldสำหรับไอเดียที่ฉลาด :)
• อีก -3 ไบต์หลังจากความคิดของ Arnauld ที่จะไม่ปฏิบัติกับ1ตัวเลขนำหน้าเป็นพิเศษ

แนวคิดในที่นี้คือเก็บเฉพาะตัวเลขของตัวเลขทั้งหมดตามลำดับที่ต้องการ ข้อมูลเพิ่มเติมที่ต้องการคือจำนวนบรรทัดใหม่ที่จะเติมและจำนวนช่องว่างด้านหน้า

จำนวนบรรทัดใหม่ที่สุดคือ3ดังนั้นเราต้องการ 2 บิตสำหรับสิ่งนี้และจำนวนช่องว่างสูงสุดคือ235 บิตจึงเพียงพอ ดังนั้นเพื่อให้ตัวเลขแต่ละหลักพิมพ์เราสามารถบีบข้อมูลนี้ใน "ไบต์ควบคุม" เดียว

ดังนั้นข้อมูลสำหรับโซลูชันนี้ใช้เวลา 30 ไบต์: 15 หลักเดียวและ 15 "ไบต์การควบคุม" ที่เกี่ยวข้อง

การสาธิตออนไลน์

การใช้งาน: SYS49152เพื่อเริ่มต้น

ความคิดเห็นถอดแยกชิ้นส่วน :

         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 ไบต์

$_="K12
E11K1

A10S2


9W3


B8S4

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

ลองออนไลน์!

คำตอบของ Port of Arnauld จนกว่าฉันจะได้สิ่งที่สั้นกว่า

R , 75 68 ไบต์

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

ลองออนไลน์!

บีบอัดตำแหน่งตัวเลข ทำสิ่งนี้หลังจากใช้เวลามากในการพยายามหาคำตอบเกี่ยวกับวิชาตรีโกณมิติ (ดูประวัติการแก้ไข)

แรงบันดาลใจจากคำตอบ R อื่น ๆซื้อ J.Doe - โหวตขึ้น!

บันทึกแล้ว 7 ไบต์ขอบคุณ J.Doe

HTML + JavaScript (Canvas), 13 + 161 = 174 ไบต์

การวางตำแหน่งผืนผ้าใบโดยพลการใช้ 6 ไบต์

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>

ด้วยตารางสำหรับการเปรียบเทียบ:

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>

คำอธิบายของสูตรการจัดตำแหน่ง

ดูของฉันJavaScript กับคำตอบ

Java 8 11, 141 138 ไบต์

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

ลองใช้ออนไลน์ (หมายเหตุ: String.repeat(int)ถูกเลียนแบบrepeat(String,int)เหมือนกับจำนวนไบต์เดียวกันเนื่องจาก Java 11 ยังไม่ได้อยู่ใน TIO)

คำอธิบายที่คล้ายกันดังต่อไปนี้ แต่จะใช้สำหรับพื้นที่แทนรูปแบบด้วย" ".repeat(x-48)"%"+(x-48)+"s"

Java 8, 141 ไบต์

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

ลองออนไลน์

คำอธิบาย:

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

คำอธิบายเพิ่มเติม92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• ตัวเลขทั้งหมดจะถูกแทนที่ด้วยจำนวนช่องว่างนั้น (สำหรับช่องว่าง 11 ช่อง92)
• 'N' ทั้งหมดเป็นบรรทัดใหม่
• ทั้งหมด ['A', 'J'] เป็นตัวเลขนาฬิกา ([0,9])

R, 168 159 125 ไบต์

การแก้ปัญหาไร้เดียงสาของการเขียนตัวเลขที่จุดที่กำหนดในเมทริกซ์ข้อความ คะแนนจะถูกจัดเก็บตามตัวอักษร UTF-8 ที่ถอดรหัสผ่านutf8ToInt

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

ลดขนาด 9 ไบต์ด้วยคำแนะนำของ JayCe เพื่อใช้writeและหลีกเลี่ยงการกำหนดเมทริกซ์

ลดลงอีก 34 ไบต์ด้วยคำแนะนำการจัดเก็บของ JayCe

Haskell, 88 87 ไบต์

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

วิธีการเข้ารหัสช่องว่างเป็นตัวอักษร (เห็นเป็นครั้งแรกในคำตอบของ @ Arnauld ) ใน Haskell การใช้{และขยายให้\nเป็นหนึ่งไบต์สั้นกว่าการใช้\nโดยตรง

ลองออนไลน์!

สนิม 96 ไบต์

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

 10{:20}


9{:24}


  8{:20}

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

ลองออนไลน์!

brainfuck , 240 235 ไบต์

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

ลองออนไลน์!

แสดงความคิดเห็นรหัส

++++++++++                              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

ตัวอย่างที่หายากซึ่งข้อความนั้นซ้ำซากพอที่โปรแกรม brainfuck มีความยาวน้อยกว่าสองเท่า 1.6 เท่าของเอาต์พุต!

2 ไบต์บันทึกโดยคำแนะนำจาก Jo King: >>>>>>-->[<]>-

บันทึก 3 ไบต์ด้วยการย้าย downcounter 20 อันดับที่สามจากด้านขวาสุดของรหัส ascii 10 30 50ไปทางซ้ายทันที บันทึก<<>>เมื่อกรอกช่องว่างระหว่าง8และ4แต่เพิ่ม 1 >>>++ไบต์กับสาย

รุ่นเดิม

++++++++++                              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 ไบต์

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)

ลองออนไลน์!

คำนวณการเว้นวรรคและการขึ้นบรรทัดใหม่ทั้งหมดในลูป

เยลลี่ 32 ไบต์

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

โปรแกรมเต็มรูปแบบที่พิมพ์ผลลัพธ์

ลองออนไลน์!

อย่างไร?

(ฉันยังไม่ได้คิดว่า / พบอะไรที่สั้นไปกว่า“¿×¿ Œ4ç4Œ!¿Ø‘ที่ฉันคิดว่าในส่วนนี้ - การตีกลับ / การบีบอัดฐาน / เพิ่มขึ้นไม่มีอะไรน่าจะช่วยได้!)

⁶ẋ“¿×¿ Œ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 ไบต์

เฉพาะตำแหน่งแท็บเท่านั้นที่มีการกำหนดรหัสยาก: การเว้นระยะบรรทัดและค่านาฬิกาทั้งหมดถูกสร้างขึ้นในลูป

ขอขอบคุณอีกครั้งเพื่อขอคำแนะนำ

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;}

ลองออนไลน์!

PHP , 97 ไบต์

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

ลองออนไลน์!

นี่คือสตริงที่บีบอัดที่เข้ารหัสยาก ฉันไม่พบวิธีแก้ปัญหาที่สั้นกว่านี้!

Pyke , 37 ไบต์

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

ลองที่นี่! (ไบต์ดิบ)

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

ลองที่นี่! (มนุษย์อ่านได้)

                              - 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 ไบต์

บันทึก 2 ไบต์ด้วยovs !

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

ลองออนไลน์!

ทั้งหมดในหนึ่งบล็อกรหัส:

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

Powershell, 94 88 82 ไบต์

โดยตรงดำเนินการรูปแบบ Powershell {i,w}หมายถึงตัวยึดตำแหน่งสำหรับพารามิเตอร์ที่มีดัชนีiความกว้างของตัวยึดตำแหน่งที่wมีการจัดชิดขวา

"{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 ไบต์

คำตอบจาวาสคริปต์ของ Port of Arnauld

-6 ไบต์ขอบคุณ @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

ที่ดีกว่าการดูตารางการใช้งานแทน'.'' '

C (gcc) , 125 109 105 ไบต์

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 ไบต์ (-3 สำหรับการจัดห่วงดีกว่า -13 โดยตรงรวมทั้งตัวอักษรที่ไม่พิมพ์) ขอบคุณที่โจนาธาน Frech
• -4 ไบต์โดยแทนที่ส่วนสำหรับการเปลี่ยนแปลงและใช้ความจริงที่ว่าในหลาย ๆ ระบบ (เช่นเดียวกับที่โฮสต์ TIO) sizeof(wchar_t) == sizeof(int)- จะไม่ทำงานบน windows :) ขอบคุณErikFสำหรับแนวคิดนี้

ลองออนไลน์!

นี่คือพอร์ตของความคิดทั่วไปของฉันจากการแก้ปัญหาที่ 6502ซีเป็นบิตที่แก้ไข: แทนที่จะมีธงเพื่อนำ1ตัวอักษรที่จะถูกพิมพ์เป็นทศนิยมโดยการลบ 48 ดังนั้น 10-12 จะถูกเข้ารหัสเพื่อ:<

ทูต , 69 ไบต์

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

ลองออนไลน์!

สิ่งนี้จะเข้ารหัสการเว้นวรรคแต่ละช่องดังนี้: NTS[count of spaces]; NTSคือ builtin "ตัวเลขถึงสั้น" ซึ่งอนุญาตให้แสดงตัวเลขเป็นสตริง เช่นและNTS[95] = $R1 เป็นสิ่งที่ตรงกันข้ามของ builtin นี้NTS[170297] = $XQOSTN

คำตอบนี้แทนที่ ( ReplaceF) ทั้งหมดที่เกิดขึ้นของตัวอักษร ( /\l/) ในการป้อนข้อมูลด้วยผลลัพธ์ของฟังก์ชั่นsp&`*@STNซึ่งก่อนอื่นถอดรหัสตัวอักษรแล้วทำซ้ำsp(ช่องว่าง) ที่หลายต่อหลายครั้ง

สวิฟต์ , 178 165 ไบต์

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)

จากสิ่งที่ Downgoat โพสต์ฉันได้ลดขนาดนี้เป็น 165 ไบต์:

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

ขยายออกโดย$0แปลงเป็นตัวแปรที่มีชื่อ:

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

สตริงอินพุตมีการเข้ารหัสดังนี้: ตัวอักษรตัวพิมพ์ใหญ่ ( A-Z) แทนบล็อกของช่องว่างชดเชยด้วย 65 ดังนั้นAหมายถึง 0 ช่องว่างBหมายถึง 1 ช่องว่างแรกLหมายถึง 11 ช่องว่างแรกหมายถึง 11 ช่องว่าง ฯลฯns ถูกแปลงเป็นบรรทัดใหม่ ตัวละครอื่น ๆ ทั้งหมดจะถูกพิมพ์ตามที่เป็น

เปิดใช้ออนไลน์ได้ที่นี่ (ขอบคุณ mbomb007)

Pure Bash , 123

printf การยกของหนักที่นี่หรือไม่:

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}"

ลองออนไลน์!

สีแดง 151 ไบต์

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]]

ลองออนไลน์!

JavaScript พร้อม SVG, 188 ไบต์

ความสูงของเส้นโดยพลการ 120% ใช้ 4 ไบต์

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)

ด้วยตารางสำหรับการเปรียบเทียบ:

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)

คำอธิบายของสูตรการจัดตำแหน่ง

f(x) = round(sin(x * π/6) * 6)ให้

สมมติว่าจุดเริ่มต้นเป็นจุดศูนย์กลางของนาฬิกาพิกัดกริดของตัวเลขหลักขวาสุดของหมายเลขนาฬิกาที่กำหนดxคือ [ f(x) * 2, f(9 - x)]

Bash, 225 ไบต์

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/ //'

น่ารำคาญนี่เป็นวิธีที่ยาวเกินกว่าความไร้เดียงสาของการพิมพ์แต่ละบรรทัดในลูป (132 ตัวอักษรถ้าใช้แท็บสต็อป)

Python 3 , 112 88 87 ไบต์

วิธีแก้ไขโดยใช้การแก้ไขสตริง

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

 10{2:20}


9{3:24}


  8{4:20}

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

ลองออนไลน์!

-25 ไบต์ขอบคุณสำหรับ ovs และ Herman L.

C (gcc) , 135 123 110 ไบต์

วิธีนี้ใช้การเข้ารหัสอย่างง่าย ๆ ที่ใด ๆcระหว่าง'a'และ'z'หมายถึงc-'a'+1ช่องว่างซ้ำ'`'หมายถึงการขึ้นบรรทัดใหม่และตัวละครอื่น ๆ ทั้งหมดจะไม่เปลี่ยนแปลง

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

ลองออนไลน์!

T-SQL, 132 ไบต์

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

มีขนาดสั้นกว่าโซลูชันเพียงเล็กน้อย 12 ไบต์เท่านั้น ( PRINTของทั้งสตริงตามที่เป็นอยู่)

พบรูปแบบที่ฉันชอบที่ยาวกว่า ( 235 226 ไบต์) แต่คล้ายกับ SQL มากขึ้น:

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_SPLITแบ่งมันเป็นแถวที่เครื่องหมายจุลภาคและPARSENAMEแยกแต่ละแถวที่จุด วันที่ 1 และ 3 จะถูกใช้สำหรับจำนวนช่องว่างที่จะพิมพ์ส่วนที่ 2 และ 4 จะถูกใช้สำหรับสิ่งที่จะแสดง

(ตัวแบ่งบรรทัดในอันนี้มีไว้เพื่อให้สามารถอ่านได้)

Perl 6 , 116 ไบต์

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/.//}

ลองออนไลน์!

(Ta @JoKing สำหรับการบันทึก 26 ไบต์)

Perl 6 , 142 ไบต์

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

ลองออนไลน์!

ฉันต้องการทำบางสิ่ง ... แตกต่าง ดังนั้นอันนี้คำนวณตำแหน่งของตัวเลขทั้งหมดผ่านคู่ของตัวอักษรแถบปิดช่องว่างเริ่มต้นและพิมพ์บรรทัด

สามารถปรับเปลี่ยนได้อย่างง่ายดายสำหรับพารามิเตอร์ที่แตกต่างกันเช่น45 ตัวอักษรรุ่นกว้าง 17 หลัก