Выведите 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 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Пояснение: Математически вычисляет смещения между каждой цифрой. Древесный уголь индексируется 0 (таким образом, ⊕чтобы вывести ), поэтому формулы для горизонтального и вертикального смещения следующие:$1 \ldots 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 байт, спасибо Арно за умную идею :)
• еще 3 байта после идеи Арно, чтобы не обрабатывать начальные 1цифры специально

Идея здесь состоит в том, чтобы хранить цифры всех чисел только в том порядке, в котором они нужны. Требуется дополнительная информация: количество новых строк, которые нужно добавить, и количество пробелов впереди.

Максимальное количество строк новой строки 3, поэтому для этого нам нужно 2 бита, а максимальное количество пробелов - 23поэтому достаточно 5 бит. Поэтому для каждой цифры, которую нужно напечатать, мы можем сжать эту информацию в одном «управляющем байте».

Таким образом, данные для этого решения занимают ровно 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}/

Попробуйте онлайн!

Ответ Порт-Арно, пока я не смогу придумать что-нибудь более короткое.

R , 75 68 байт

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

Попробуйте онлайн!

Сжатые цифры позиции. Сделал это, потратив много времени, пытаясь придумать тригонометрический ответ (см. Историю изменений).

Вдохновленный этим другим ответом R купить J. Doe - upvote!

Сохранено 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 с ответом SVG .

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)

Попробуйте онлайн!

бред , 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

Редкий пример, когда текст достаточно повторяющийся, чтобы программа для мозгового отрыва была вдвое меньше, чем длина вывода в 1,6 раза!

2 байта сохранены по предложению Джо Кинга: >>>>>>-->[<]>-

3 байта сохраняются путем перемещения третьего 20-значного downcounter от крайнего правого кода 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));

Попробуйте онлайн!

Это жестко закодированная сжатая строка. Я не мог найти решение короче, чем это!

Пайк , 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)

бред , 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 байт

Порт Арнаулда Javascript ответ

-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 для непосредственного включения непечатаемых символов) благодаря Джонатану Фречу .
• -4 байта, заменяя деление на смену и злоупотребляя тем фактом, что на многих системах (например, на той, на которой размещается TIO), sizeof(wchar_t) == sizeof(int)- не будет работать на windows :) Спасибо ErikF за идею.

Попробуйте онлайн!

Это порт моей общей идеи от 6502 раствора до C. Это немного модифицирована: Вместо того , чтобы иметь флаг для ведущей 1, символ печатается в виде десятичной дроби, вычитая 48, так что 10 - 12 кодируются как :для <.

Атташе , 69 байт

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Попробуйте онлайн!

Это кодирует каждый цикл пробелов как NTS[count of spaces]:; NTSэто встроенная функция от числового до короткого, которая позволяет выражать числа в виде строк. Например, NTS[95] = $R1и NTS[170297] = $XQO. STNявляется инверсией этого встроенного.

Этот ответ заменяет ( ReplaceF) все вхождения букв ( /\l/) во входных данных на результат функции sp&`*@STN, которая сначала декодирует букву, а затем повторяется sp(пробел) столько раз.

Swift , 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 пробелов и т. Д. nS преобразуются в новые строки. Все остальные символы печатаются как есть.

Запустите его онлайн здесь (спасибо, mbomb007)

Чистый Баш , 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)].

Баш, 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 байт благодаря овсу и герману л.

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 цифрами .