Tampilkan 12 angka pada tampilan jam persis seperti ini:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Untuk melihat kisi-kisi dengan lebih baik, inilah satu dengan titik-titik:

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

Perhatikan bahwa kisi direntangkan lebar dengan faktor dua untuk membuatnya terlihat lebih persegi.

Perhatikan juga bahwa angka dua digit disejajarkan dengan angka yang ada di tempatnya. Angka 9 harus rata terhadap kiri.

Kembalikan atau cetak hasilnya sebagai string multiline (bukan daftar garis). Setiap ruang tambahan adalah opsional. Baris terakhir juga opsional.

Arang , 40 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan: Menghitung offset antara setiap digit secara matematis. Arang diindeks 0 (dengan demikian ⊕untuk output ), jadi rumus untuk offset horizontal dan vertikal adalah sebagai berikut:$1 \ldots 12$

di mana .$i' = i + 3 \pmod {12}$

JavaScript (Node.js) , 91 byte

Bukan pendekatan yang sangat pintar, tetapi saya gagal menemukan sesuatu yang lebih pendek saat ini.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Cobalah online!

05AB1E , 39 33 31 byte

Terima kasih untuk Magic Octopus Mm karena telah menghemat 6 byte!

Kode

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

Beberapa alternatif 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

Menggunakan penyandian 05AB1E . Cobalah online!

6502 kode mesin (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, terima kasih kepada Arnauld untuk ide pintarnya :)
• lain -3 byte setelah ide Arnauld untuk tidak memperlakukan 1digit utama secara khusus

Idenya di sini adalah hanya menyimpan digit semua angka sesuai urutan yang dibutuhkan. Info tambahan yang diperlukan adalah jumlah baris baru untuk ditambahkan dan jumlah ruang di depan.

Jumlah maksimum baris baru adalah 3, jadi kita perlu 2 bit untuk ini, dan jumlah ruang maksimum adalah 23, oleh karena itu 5 bit sudah cukup. Karenanya, untuk setiap digit yang akan dicetak, kami dapat memeras info ini dalam satu "byte kontrol".

Jadi, data untuk solusi ini membutuhkan tepat 30 byte: 15 digit tunggal dan 15 terkait "byte kontrol".

Demo online

Penggunaan: SYS49152untuk memulai.

Komentar pembongkaran :

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

Cobalah online!

Port of Arnauld menjawab sampai saya dapat menemukan sesuatu yang lebih pendek.

R , 75 68 byte

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

Cobalah online!

Mengompresi posisi digit. Apakah ini setelah menghabiskan banyak waktu untuk mencari jawaban trigonometri (lihat riwayat suntingan).

Terinspirasi oleh jawaban R yang lain ini, beli J. Aduh - perbaiki!

Disimpan 7 byte berkat Joe.

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

Penempatan kanvas secara sewenang-wenang menggunakan 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>

Dengan kisi untuk perbandingan:

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>

Penjelasan tentang Formula Pemosisian

Lihat JavaScript saya dengan jawaban 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));}

Cobalah online (CATATAN: String.repeat(int)diemulasikan repeat(String,int)untuk byte-count yang sama, karena Java 11 belum menggunakan TIO.)

Penjelasannya mirip seperti di bawah ini, tetapi menggunakan " ".repeat(x-48) untuk spasi alih-alih format dengan "%"+(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:"");}

Cobalah online.

Penjelasan:

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

Penjelasan lebih lanjut 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G :

• Semua digit akan diganti dengan jumlah ruang itu. (Karena itu, 11 ruang 92).)
• Semua 'N' adalah baris baru
• Semua ['A', 'J'] adalah digit jam ([0,9])

R, 168 159 125 byte

Solusi naif dari penulisan angka-angka pada titik-titik yang ditentukan dalam matriks teks. Poin disimpan sebagai huruf UTF-8 diterjemahkan melaluiutf8ToInt

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

Turun 9 byte dengan saran JayCe untuk digunakan write dan menghindari mendefinisikan matriks.

Turun 34 byte lagi dengan saran penyimpanan 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]

Metode encode-space-as-letters (pertama kali dilihat pada jawaban @ Arnauld ) di Haskell. Menggunakan{ dan memperluasnya menjadi \nsatu byte lebih pendek daripada menggunakan \nsecara langsung.

Cobalah online!

Karat , 96 byte

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

 10{:20}


9{:24}


  8{:20}

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

Cobalah online!

brainfuck , 240 235 byte

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

Cobalah online!

Kode yang dikomentari

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

Contoh langka di mana teks cukup berulang sehingga program brainfuck kurang dari dua kali 1,6 kali panjang output!

2 byte disimpan oleh saran dari Jo King: >>>>>>-->[<]>-

3 byte disimpan dengan memindahkan downcounter 20-tempat ketiga dari paling kanan kode ascii 10 30 50ke langsung di sebelah kiri mereka. Menghemat <<>>saat mengisi celah di antara 8dan 4tetapi menambahkan 1 byte ke saluran>>>++ .

Versi asli

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

Cobalah online!

Menghitung semua jarak dan baris baru dalam loop

Jelly , 32 byte

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

Program lengkap yang mencetak hasilnya.

Cobalah online!

Bagaimana?

(Saya belum memikirkan / menemukan sesuatu yang lebih pendek daripada “¿×¿ Œ4ç4Œ!¿Ø‘yang tampaknya lama bagi saya untuk bagian ini - memantul / basis-dekompresi / kenaikan, sepertinya tidak ada yang menyelamatkan!)

⁶ẋ“¿×¿ Œ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

Hanya posisi tab yang dikodekan dengan keras: semua jarak garis dan nilai jam dihasilkan dalam loop.

Terima kasih lagi untuk ceilingcat untuk sarannya.

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

Cobalah online!

PHP , 97 byte

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Cobalah online!

Ini adalah string terkompresi kode keras. Saya tidak dapat menemukan solusi yang lebih singkat dari ini!

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

Coba di sini! (byte mentah)

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

Coba di sini! (Dapat dibaca manusia)

                              - 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

disimpan 2 byte berkat ovs !

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

Cobalah online!

semua dalam satu blok kode:

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

Powershell, 94 88 82 byte

Operator format Powershell langsung . {i,w}berarti placeholder untuk parameter dengan indeks i, lebar placeholder adalah wdengan perataan kanan.

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

Port of Javascript jawaban Arnauld

-6 byte terima kasih kepada @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Untuk melihat grid dengan lebih baik, gunakan '.'saja ' '.

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 untuk pengaturan loop yang lebih baik, -13 untuk langsung termasuk karakter yang tidak dapat dicetak) terima kasih kepada Jonathan Frech .
• -4 byte dengan mengganti divisi untuk shift dan menyalahgunakan fakta bahwa pada banyak sistem (seperti TIO hosting), sizeof(wchar_t) == sizeof(int)- tidak akan bekerja di windows :) Terima kasih ErikF untuk idenya.

Cobalah online!

Ini adalah port dari ide umum saya dari solusi 6502 ke C. Ini sedikit dimodifikasi: Alih-alih memiliki bendera untuk memimpin 1, karakter dicetak sebagai desimal dengan mengurangi 48, sehingga 10 - 12 dikodekan :untuk <.

Attache , 69 byte

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Cobalah online!

Ini mengkodekan setiap proses spasi sebagai NTS[count of spaces]:; NTSadalah built-in "numeric to short", yang memungkinkan angka untuk diekspresikan sebagai string. Misalnya, NTS[95] = $R1dan NTS[170297] = $XQO. STNadalah kebalikan dari builtin ini.

Jawaban ini menggantikan ( ReplaceF) semua kemunculan huruf ( /\l/) di input dengan hasil fungsi sp&`*@STN, yang pertama menerjemahkan kode huruf dan kemudian mengulang sp(spasi) yang berkali-kali.

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)

Berdasarkan apa yang diposting Downgoat, saya mengurangi ini menjadi 165 byte:

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

Diperluas, dengan $0dikonversi ke variabel bernama:

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

String input dikodekan sebagai berikut: Huruf besar ( A-Z) mewakili blok spasi, diimbangi dengan 65. Jadi Aberarti 0 spasi, Bberarti 1 spasi, Lsarana pertama 11 spasi, dll. nS dikonversi ke baris baru. Semua karakter lain dicetak apa adanya.

Jalankan online di sini (terima kasih, mbomb007)

Pure Bash , 123

printf jangan angkat berat di sini:

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

Cobalah online!

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

Cobalah online!

JavaScript dengan SVG, 188 byte

Ketinggian garis sewenang-wenang 120% menggunakan 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)

Dengan kisi untuk perbandingan:

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)

Penjelasan tentang Formula Pemosisian

Membiarkan f(x) = round(sin(x * π/6) * 6) .

Dengan asumsi asal adalah pusat jam, koordinat kisi dari digit paling kanan dari setiap nomor jam yang diberikan xadalah [ 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/ //'

Anehnya ini lebih lama dari solusi naif hanya mencetak setiap baris dalam satu lingkaran (132 karakter jika menggunakan tabstops).

Python 3 , 112 88 87 byte

Solusi menggunakan interpolasi string.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Cobalah online!

-25 byte berkat ovs dan Herman L.

C (gcc) , 135 123 110 byte

Ini menggunakan pengodean sederhana di mana ada di cantara 'a'dan 'z'mewakili c-'a'+1ruang berulang, '`'mewakili baris baru, dan semua karakter lainnya dibiarkan tidak berubah.

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

Cobalah online!

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'

Hanya 12 byte lebih pendek dari solusi sepele ( PRINTdari seluruh string apa adanya).

Menemukan variasi yang saya sukai jauh lebih lama ( 235) 226 bytes), tetapi jauh lebih seperti 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 memecahnya menjadi baris di koma, dan PARSENAME membagi setiap baris di titik-titik. Bagian ke-1 dan ke-3 digunakan untuk berapa banyak ruang untuk dicetak, ke-2 dan ke-4 digunakan untuk apa yang akan ditampilkan.

(jeda baris yang satu ini hanya untuk dibaca)

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

Cobalah online!

(Ta @JoKing untuk menghemat 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

Cobalah online!

Saya ingin melakukan sesuatu ... berbeda. Jadi yang satu ini menghitung posisi semua digit, melalui pasangan karakter, menghapus ruang awal dan mencetak garis.

Mudah dimodifikasi untuk parameter yang berbeda, misalnya versi lebar 45 karakter dengan 17 digit .