Saat yüzündeki 12 sayıyı tam olarak şöyle göster:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Izgarayı daha iyi görebilmek için işte noktalar:

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

Kılavuzun daha kare görünmesi için genişlik olarak iki kat gerildiğini unutmayın.

Ayrıca, iki basamaklı sayıların, kendi basamakları ile aynı hizada olduğuna dikkat edin. 9 hane sola yaslanmalıdır.

Sonucu çok satırlı bir dize olarak döndürün veya yazdırın (satır listesi değil). Her sondaki boşluk isteğe bağlıdır. Son satır da isteğe bağlı.

Kömür , 40 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama: Her hane arasındaki ofsetleri matematiksel olarak hesaplar. Kömür 0 indekslidir (bu nedenle⊕ kadar çıktı ), bu nedenle yatay ve dikey ofset formülleri aşağıdaki gibidir:$1 \ldots 12$

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

JavaScript (Node.js) , 91 bayt

Çok akıllıca bir yaklaşım değil, şu anda daha kısa bir şey bulamadım.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Çevrimiçi deneyin!

05AB1E , 39 33 31 bayt

6 bayt kaydettiğiniz için Magic Octopus Urn'a teşekkürler !

kod

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

Bazı 33 bayt alternatifler:

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 kodlamasını kullanır . Çevrimiçi deneyin!

6502 makine kodu (C64), 82 76 73 bayt

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 bayt, akıllıca bir fikir için Arnauld için teşekkürler :)
• Arnauld'un öncü 1hanelere özel olarak davranmama fikrinden sonraki -3 bayt

Buradaki fikir, tüm sayıların rakamlarını yalnızca gerekli sırayla kaydetmektir. Gereken ek bilgi, hazırlanacak yeni satır sayısı ve öndeki alan sayısıdır.

Maksimum yeni satır sayısı 3, bunun için 2 bit'e ihtiyacımız var ve maksimum alan sayısı 23, bu nedenle 5 bit yeterli. Bu nedenle, her basamağın basılması için bu bilgiyi tek bir "kontrol baytında" sıkıştırabiliriz.

Bu nedenle, bu çözüm için veriler tam olarak 30 bayt alır: 15 tek basamak ve 15 ilişkili "kontrol baytı".

Çevrimiçi demo

Kullanımı: SYS49152başlamak için.

Yorum yapılan sökme :

         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 bayt

$_="K12
E11K1

A10S2


9W3


B8S4

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

Çevrimiçi deneyin!

Daha kısa bir şey bulana kadar Arnauld Limanı'nın cevabı.

R , 75 68 bayt

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

Çevrimiçi deneyin!

Rakam konumlarını sıkıştırın. Bunu, çok fazla zaman harcadıktan sonra trigonometrik bir cevap bulmaya çalıştım (düzenlemelerin geçmişine bakın).

Bu diğer R yanıtından esinlenildi Satın Al J.Doe - Oy ver!

J.Doe sayesinde 7 byte kurtarıldı.

HTML + JavaScript (Tuval), 13 + 161 = 174 bayt

Rasgele tuval konumlandırma, 6 bayt kullanır.

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>

Karşılaştırma için ızgara ile:

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>

Konumlandırma Formülünün Açıklaması

JavaScript'imi SVG cevabı ile gör .

Java 8 11, 141 138 bayt

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

Online Deneyin (NOT: String.repeat(int)olarak taklit edilir repeat(String,int). Java 11 henüz TIO olmadığı için, aynı bayt sayım için)

Açıklama aşağıdakine benzer, ancak " ".repeat(x-48)format yerine boşluklar için kullanılır "%"+(x-48)+"s".

Java 8, 141 bayt

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

Çevrimiçi deneyin.

Açıklama:

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

Daha fazla açıklama 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

• Tüm rakamlar bu boşluklarla değiştirilecektir. (Bu nedenle 11 boşluk için 92.)
• Tüm 'N' yeni çizgilerdir
• Tüm ['A', 'J'] saat haneleridir ([0,9])

R, 168 159 125 bayt

Bir metin matrisinde belirtilen noktalardaki sayıları yazmanın saf çözümü. Noktalar, kodu çözülmüş UTF-8 harfleri olarak saklanır.utf8ToInt

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

Kullanmak writeve matrisi tanımlamaktan kaçınmak için JayCe'nin önerisi ile 9 bayt düştü .

JayCe'nin depolama önerisi ile 34 bayt daha düştü.

Haskell, 88 87 bayt

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

Haskell'de encode-spaces-letters-as yöntemi (ilk olarak @ Arnauld'un cevabında görüldü ). Kullanmak {ve genişletmek \n, \ndoğrudan kullanmaktan bir bayt daha kısadır .

Çevrimiçi deneyin!

Pas , 96 bayt

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

 10{:20}


9{:24}


  8{:20}

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

Çevrimiçi deneyin!

brainfuck , 240 235 bayt

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

Çevrimiçi deneyin!

Yorumlanan kod

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

Metnin, beyin fırtınası programının çıktının uzunluğunun 1.6 katından iki kat daha az olduğu yeterince tekrarlandığı nadir bir örnek !

Jo King'den öneriyle kaydedilen 2 bayt: >>>>>>-->[<]>-

Üçüncü 20 yerdeki alt tezgahı ascii kodlarının en sağından 10 30 50hemen soluna hareket ettirerek 3 bayt kaydedildi . Kaydeder <<>>arasındaki boşluğu doldururken 8ve 4ancak hattına 1 bayt ekler >>>++.

Orijinal versiyon

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

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)

Çevrimiçi deneyin!

Döngüdeki tüm boşlukları ve yeni satırları hesaplar

Jöle , 32 bayt

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

Sonucu basan tam bir program.

Çevrimiçi deneyin!

Nasıl?

( “¿×¿ Œ4ç4Œ!¿Ø‘Bu kısım için benim için uzun sürecek olandan daha kısa bir şey düşünmedim / bulamadım - zıplayan / üs-dekompresyon / artışlar, hiçbir şey kurtarılmıyor!)

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

Yalnızca sekme konumları kodlanmıştır: tüm satır boşlukları ve saat değerleri döngüde oluşturulur.

Önerileriniz için ceilingcat için tekrar teşekkürler.

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

Çevrimiçi deneyin!

PHP , 97 bayt

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Çevrimiçi deneyin!

Bu, kodlanmış bir sıkıştırılmış dizgedir. Bundan daha kısa bir çözüm bulamadım!

Pyke , 37 bayt

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

Burada dene! (ham bayt)

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

Burada dene! (İnsan tarafından okunabilir)

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

ovs sayesinde 2 bayt kurtardı !

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

Çevrimiçi deneyin!

hepsi bir kod bloğunda:

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

Powershell, 94 88 82 bayt

Doğrudan Powershell format operatörü . {i,w}İndeksli bir parametre iiçin yer tutucusu, yer tutucunun genişliği ise wdoğru hizalamalıdır.

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

Arnauld Limanı'nın Javascript cevabı

@AdmBorkBork sayesinde -6 bayt

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Izgarayı daha iyi görmek için, '.'yerine kullanın ' '.

C (gcc) , 125 109 105 bayt

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

• Jonathan Frech sayesinde -16 bayt (daha iyi döngü düzenlemesi için -3, doğrudan yazdırılamayan karakterleri dahil etmek için -13) .
• -4 byte, bir vardiya için bir bölümü değiştirerek ve birçok sistemde ( TIO'yu barındıran gibi) gerçeği kötüye kullanarak sizeof(wchar_t) == sizeof(int)- pencerelerde çalışmaz :) Bu fikir için ErikF'e teşekkür edin .

Çevrimiçi deneyin!

Bu benim genel fikrin bir liman 6502 solüsyon O değiştirilmiş biraz C'ye: Yerine lider için bir bayrak sahip 1, karakter, böylece 10, 48 çıkarılarak ondalık olarak basılır - 12 olarak kodlanmıştır :için <.

Ataşesi , 69 bayt

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Çevrimiçi deneyin!

Bu, her boşluk dizisini şu şekilde kodlar NTS[count of spaces]:; NTSsayıların dizge olarak ifade edilmesini sağlayan "kısadan sayısal" yerleşimidir. Örneğin, NTS[95] = $R1ve NTS[170297] = $XQO. STNbu yerleşimin tersidir.

Bu cevap , girdideki ReplaceFharflerin ( /\l/) tüm fonksiyonlarını yerine getirir ( sp&`*@STNilk önce harfi çözer) ve sonra tekrar eder sp(boşluk).

Swift , 178 165 bayt

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'ın yayınladığı şeye göre, bunu 165 bayta indirdim:

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

Genişletilmiş, $0adlandırılmış bir değişkene dönüştürülmüş olarak:

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

Giriş dizesi şu şekilde kodlanır: Büyük harfler ( A-Z), 65 ile kaymış boşluk bloklarını temsil eder. Böylece A0 boşluk, B1 boşluk, ilk Laraç 11 boşluk, vb. nS yeni satırlara dönüştürülür. Diğer tüm karakterler olduğu gibi yazdırılır.

Burada çevrimiçi çalıştırın (teşekkürler, mbomb007)

Saf Bash , 123

printf burada ağır kaldırma yapar:

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

Çevrimiçi deneyin!

Kırmızı , 151 bayt

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

Çevrimiçi deneyin!

SVG ile JavaScript, 188 bayt

% 120 rasgele satır yüksekliği 4 bayt kullanır.

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)

Karşılaştırma için ızgara ile:

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)

Konumlandırma Formülünün Açıklaması

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

Kökenin saatin merkezi olduğunu varsayarsak, herhangi bir saat numarasının en sağındaki hanenin ızgara koordinatları x[ f(x) * 2, f(9 - x)] 'dir.

Bash, 225 bayt

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

Can sıkıcı bir şekilde, bu, her bir çizgiyi bir ilmekle yazdırmanın naif çözümünden daha uzundur (tabtapları kullanıyorsanız 132 karakter).

Python 3 , 112 88 87 bayt

Dize enterpolasyonu kullanan bir çözüm.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Çevrimiçi deneyin!

Ovs ve Herman L. sayesinde -25 bayt

C (gcc) , 135 123 110 bayt

Bu, yinelenen boşluklar carasında herhangi birinin olduğu 'a've 'z'temsil ettiği, yeni bir satırı temsil ettiği ve diğer tüm karakterlerin değişmeden kaldığı basit bir kodlama kullanır .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);}

Çevrimiçi deneyin!

T-SQL, 132 bayt

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

Önemsiz çözümden yalnızca 12 bayt daha kısadır ( PRINTolduğu gibi dizenin tamamı için).

Beğendiğim bir varyasyon buldum çok daha uzun ( 235 226 bytes), fakat çok daha fazla SQL benzeri:

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_SPLITvirgüllerde satırlara PARSENAMEbölünür ve her satırı noktalara böler. 1. ve 3. baskı kaç alan yazdırılır, 2. ve 4. basım gösterilmek için kullanılır.

(bu satırdaki satır sonları sadece okunabilirlik içindir)

Perl 6 , 116 bayt

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

Çevrimiçi deneyin!

(26 bayt kaydetmek için Ta @JoKing)

Perl 6 , 142 bayt

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

Çevrimiçi deneyin!

Bir şey yapmak istedim ... farklı. Böylece bu, tüm rakamların konumlarını, karakter çiftleri aracılığıyla hesaplar ve başlangıç ​​alanından çıkar ve satırları yazdırır.

Farklı parametreler için kolayca değiştirilebilir, örneğin 17 basamaklı 45 karakterlik bir versiyon .