[Question]
  [
Display the 12 numbers on a clock face exactly like this:
```
           12            
     11           1      
 10                   2  
9                       3
  8                   4  
      7           5      
            6            
```
To better see the grid, here's one with dots:
```
...........12............
.....11...........1......
.........................
.10...................2..
.........................
.........................
9.......................3
.........................
.........................
..8...................4..
.........................
......7...........5......
............6............
```
Note that the grid is stretched in width by a factor of two to make it look more square. 
Also note that two-digit numbers are aligned with their ones digit in place. The 9 digit should be flush against the left.
Return or print the result as a multiline string (not a list of lines). Any trailing spaces are optional. The final newline also optional.
  
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 40 bytes
```
Ｆ¹²«Ｍ⁻↔⁻¹⁴⊗÷×⁴ι³¦⁸⁻⁴↔⁻⁷÷×⁴﹪⁺³ι¹²¦³Ｐ←⮌Ｉ⊕ι
```
[Try it online!](https://tio.run/##bY7LCsJADEXX@hWzzMC4qBUUXRW7ESyI@AN9pBiYzsi8NuK3j4EqbgwEQpJzOf29db1tdc6jdQKKtRTP5aKxCaEhEz1Unf9MxUaJ2sZO4wAnE2pKNCDcaEIPfCKpRCm5lNhxzwzvfwFbJf5wjR2itnDR/FHOMWzxDZMHtok60MORCbA/4xiUuGJC5xGOrQ/s0juc0AT2ohl55ZxXSb8B "Charcoal – Try It Online") Link is to verbose version of code. Explanation: Computes the offsets between each digit mathematically. Charcoal is 0-indexed (thus the `⊕` to output \$ 1 \ldots 12 \$), so the formulae for the horizontal and vertical offsets are as follows:
$$ \begin{align} \delta x &= \left \lvert 14 - 2 \left \lfloor \frac {4i} 3 \right \rfloor \right \rvert - 8 \\ \delta y &= 4 - \left \lvert 7 - \left \lfloor \frac {4i'} 3 \right \rfloor \right \rvert \end{align} $$
where \$ i' = i + 3 \pmod {12} \$.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 91 bytes
Not a very clever approach, but I've failed to find anything shorter at the moment.
```
_=>`K12
E11K1
A10S2
9W3
B8S4
F7K5
L6`.replace(/[A-Z]/g,c=>''.padEnd(Buffer(c)[0]&31))
```
[Try it online!](https://tio.run/##Dci7CoMwFADQ/X5ITaBGo30OERTskm4OhYpoyENaggmx7e@nLmc4b/ETqwwv/0kXp3Q0LI6smjgtoKWUU4Ca5l0BANdHudlcugPA7cyPcD9NJGhvhdQo6@v0OWTzXrIqSYgXql0Uar7G6IAk7vNhV1KMo3TL6qwm1s3IoC3@ "JavaScript (Node.js) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~39~~ ~~33~~ 31 bytes
Thanks to *Magic Octopus Urn* for saving 6 bytes!
### Code
```
6xsG12N-N•°£•NèØú«тR∞Nè¶×]\6».c
```
Some 33 byte alternatives:
```
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
```
Uses the [**05AB1E** encoding](https://github.com/Adriandmen/05AB1E/blob/master/docs/code-page.md). [Try it online!](https://tio.run/##MzBNTDJM/f/frKLY3dDIT9fvUcOiQxsOLQZSfodXHJ5xeNeh1Rebgh51zANyD207PD02xuzQbr3k//8B "05AB1E – Try It Online")
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) (C64), 82 76 73 bytes
```
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 bytes, thanks to [Arnauld](https://codegolf.stackexchange.com/questions/170297/display-a-clock-face/170339?noredirect=1#comment411339_170319) for the clever idea :)
* another -3 bytes after Arnauld's idea not to treat leading `1` digits specially
The idea here is to only store the digits of all the numbers in the order they are needed. Additional info required is the number of newlines to prepend and the number of spaces in front.
The maximum number of newlines is `3`, so we need 2 bits for this, and the maximum number of spaces is `23`, therefore 5 bits are enough. Therefore, for each digit to print, we can squeeze this info in a single "control byte".
So, the data for this solution takes exactly 30 bytes: 15 single digits and 15 associated "control bytes".
### [Online demo](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22clockface.prg%22:%22data:;base64,AMCiDr04wCkDqKkNICXAvTjASkqoqSAgJcC9KcAg0v/KEOFgINL/iBD6YDY1NzQ4MzkyMDExMTEyMTEsGkwLXANMAAYsABUALA==%22%7D,%22vice%22:%7B%22-autostart%22:%22clockface.prg%22%7D%7D)
Usage: `SYS49152` to start.
**Commented disassembly**:
```
         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
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~76 74~~ 70 bytes
```
"K12
E11K1
A10S2
9W3
B8S4
F7K5
L6"~~say S:g{<:Lu>}=" "x$/.ord-64
```
[Try it online!](https://tio.run/##K0gtyjH7/1/J29CIy9XQ0NuQi8vR0CDYiIuLyzLcGEg6WQSbcHG5mXubcvmYKdXVFSdWKgRbpVfbWPmU2tXaKikoVajo6@UXpeiamfz/756fmGPFpYAAQGMhtCGyIBeXgqGBAiYAW6uAHYAco6BggUXGhAtqozmSoCmyKxTMAA "Perl 6 – Try It Online")
Port of Arnauld's answer until I can come up with something shorter.
[Answer]
# HTML + JavaScript (Canvas), 13 + 161 = 174 bytes
Arbitrary canvas positioning uses 6 bytes.
```
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 grid for comparison:
```
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>
```
---
## Explanation of Positioning Formula
See my [JavaScript with SVG answer](https://codegolf.stackexchange.com/a/170350/47097).
[Answer]
# Java ~~8~~ 11, ~~141~~ 138 bytes
```
v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.print(x<59?" ".repeat(x-48):(char)(x>76?10:x-17));}
```
[Try it online](https://tio.run/##ZZDNbsIwEITvPMUqJ1siEUkbqEkLaugPrVRfkHqhHNxgaGhwIttJg1CePd2U3HrxeFfr2W98EJVwD9vvNsmEMfAmUnUeAKTKSr0TiQTelQBVnm4hIe@dVDTCXjPAw1hh0wQ4KLiDtnJn512uSSU01FOHBfGCh3GMyrkf3zPmLzjnr4yFD6jBCzYeOR8vWfDE2dWz4@2ljU9WGkLp6mSsPHp5ab1CIw6pb0M217KQwhIHnGHtXt/QKUm@hKaknk3Gc380rV1/QmnUtFFHV5SfGdL1kH8RjhiQrCw67tcbEPSSTnkJUWWW/Qt2mYR@bV8Zq4dIBOKYl8r2FlraUitQ8qd/RLprR7e@zG2ohzYZ/ilxPkbOEF36dU37Cw) (NOTE: `String.repeat(int)` is emulated as `repeat(String,int)` for the same byte-count, because Java 11 isn't on TIO yet.)
Explanation is similar as below, but it uses `" ".repeat(x-48)` for the spaces instead of format with `"%"+(x-48)+"s"`.
---
# Java 8, 141 bytes
```
v->{for(var x:"92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G".getBytes())System.out.printf("%"+(x>58?"c":x-48+"s"),x>76?10:x>58?x-17:"");}
```
[Try it online.](https://tio.run/##LY9Na4NAEIbv@RXDQmGXVKm2Jlmlhpp@Q@cS6KX0sN2swdRocNfFEPztdk1zmZd5B4bn2QkrvN3md5Cl0Bo@RFGdJgBFZVSTC6kAxxXA1sUGJP0cw7LEdf3EDW2EKSQgVHAPg/XSU1431IoGupjwMFthlGUuEYPsgfNghYjvnEePLsM3Vzwhzl55@Iz89oX4W2Wyo1GaMrY@aqP2ft0a/9A4nJySKzKlXRotlkSSuPPuFlOiCbvu0vlsGdzE51PnBfOYEJb0QzICHtqf0gFeOM8We@dI18Y93X59g2D/gpUvadWW5cWtH/4A)
**Explanation:**
```
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
```
**Further explanation `92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G`:**
* All the digits will be replaced with that amount of spaces. (For 11 spaces it's therefore `92`.)
* All 'N' are new-lines
* All ['A','J'] are clock digits ([0,9])
[Answer]
# [R](https://www.r-project.org/), ~~75~~ 68 bytes
```
write("[<-"(rep("",312),utf8ToInt('*`®÷ĥĹĚä—M
'),1:12),1,25)
```
[Try it online!](https://tio.run/##K/r/v7wosyRVQynaRldJoyi1QENJScfY0EhTp7QkzSIk3zOvRENdK@HQusPbjyw9svPIrMNLDk33ledR19QxtAIpM9QxMtX8/x8A "R – Try It Online")
Compressed the digits positions.
Did this after spending lots of time trying to come up with a trigonometric answer (see history of edits).
Inspired by [this other R answer](https://codegolf.stackexchange.com/a/170366/80010) buy J.Doe - upvote it ! 
Saved 7 bytes thanks to J.Doe.
[Answer]
# [Python 2](https://docs.python.org/2/), 97 bytes
```
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)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/Py2/SCFTITNPoSgxLz1Vw1zTqtw2MalYw1g3U9O6oCgzr0RdVStFXVXDULeuXKtcx9AIKKEDFTMy0TXW0irXNQJKZGpqaZTbGAPlYvLUtXIz8zQydUyBav//BwA "Python 2 – Try It Online")
Computes all spacings and newlines in the loop
[Answer]
# R, ~~168~~ ~~159~~ 125 bytes
The naive solution of writing the numbers at the prescribed points in a text matrix. Points are stored as UTF-8 letters decoded via `utf8ToInt`
```
"!"=utf8ToInt
write("[<-"(matrix(" ",25,13),cbind(!"LMFGSBCWAYCWGSM",!"AABBBDDDGGJJLLM")-64,-64+!"ABAAAA@BICHDGEF"),1,25,,"")
```
Dropped 9 bytes with JayCe's suggestion to use `write` and avoid defining the matrix.
Dropped another 34 bytes with JayCe's storage suggestion.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 32 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
⁶ẋ“¿×¿ Œ4ç4Œ!¿Ø‘ż“øn0œ’Œ?D¤Fs25Y
```
A full program which prints the result.
**[Try it online!](https://tio.run/##AUIAvf9qZWxsef//4oG24bqL4oCcwr/Dl8K/IMWSNMOnNMWSIcK/w5jigJjFvOKAnMO4bjDFk@KAmcWSP0TCpEZzMjVZ//8 "Jelly – Try It Online")**
### How?
(I have not yet thought of/found anything shorter than `“¿×¿ Œ4ç4Œ!¿Ø‘` which seems long to me for this part - bouncing / base-decompression / increments, nothing seems to save!)
```
⁶ẋ“¿×¿ Œ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
```
[Answer]
## Haskell, ~~88~~ 87 bytes
```
f=<<"k12{e11k1{{a10s2{{{9w3{{{b8s4{{f7k5{l6"
f c|c>'z'="\n"|c>'9'=' '<$['a'..c]|1<2=[c]
```
The encode-spaces-as-letters method (first seen in [@Arnauld's answer](https://codegolf.stackexchange.com/a/170298/34531)) in Haskell. Using `{` and expanding it to `\n` is one byte shorter than using `\n` directly.
[Try it online!](https://tio.run/##Fc1NCsIwEEDhvacIQZiVxYm/hcQTuHPZdhGHpkpiCKYiOD27sW4e3@7dbPZ9CGUQRrTFGa2lR8U9okdmi@usmLl@b@Zej3nL7A5@x2EvF07QRCf4gJFtlH/WYECAXjZgoaqom1Ar01BXHvYe50F6jZfxeY5iKF9ywQ65rCilHw "Haskell – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), 96 bytes
```
||format!(r"{:13}
     11{:12}
 10{:20}
9{:24}
  8{:20}
{:7}{:12}
{:13}",12,1,2,3,4,7,5,6)
```
[Try it online!](https://tio.run/##LYvBDoIwEETv@xVLT22yB7agaA0fw8EmJFBNLael316LOKc3kzdx@6TiA67THLRBgeWZ0OOIZd/9K65TanRU4rjLgEeYa7EZALkVZ9tKcK/QH4B4@2/ihnyKv68itsRkqaOeBrrQ1ZQHvOMc0hIaraQa6LUxkMsX "Rust – Try It Online")
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~240~~ 235 bytes
```
++++++++++[>++>+>+++>+++++>++>++[<]>-]>>>++...........>-.+.<<.>.....>-..<...........>.<<..>.>.-.>-[<<.>>-]<++.<<...>>+++++++.>>+++[<<<.>>>-]<<------.<<...>..>+++++.<<<-[>>.<<-]>>>----.<<..>......>+++.<...........>--.<<.>............>+.
```
[Try it online!](https://tio.run/##VY7dCoAwCIUfSPQJ5LzI6KKCIIIugp5/HW3rxzlxnm/qdIzrvpzzVqs8ViACHsmbkV58gA4AU3sNamLuhv4y/6ohMcKUWgmOPVzyCwW0iXdGPYAgXNMaRr8xAloQXXOTB0Ebl8xvO32X6zWxWi8 "brainfuck – Try It Online")
**Commented code**
```
++++++++++                              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
```
A rare example where the text is repetitive enough that the brainfuck program is less than ~~twice~~ 1.6 times the length of the output!
2 bytes saved by suggestion from Jo King: `>>>>>>-` -> `[<]>-`
3 bytes saved by moving the third 20-place downcounter from far right of the ascii codes `10 30 50` to immediately to the left of them. Saves `<<>>` when filling the gap between `8` and `4` but adds 1 byte to the line `>>>++` .
**Original version**
```
++++++++++                              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
```
[Answer]
# [PHP](http://www.php.net/), 97 bytes
```
<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));
```
[Try it online!](https://tio.run/##K8go@P/fxt42vSozLy0nsSRVIymxONXMJD4lNTk/JVUj1NDZ0dHAN8snPaOk0NMxu9I3PCfSPTM93THXt9Qn08THKbzc0cg/Pc/T29kpKDLKtdLM0yOwKDfY0zs3wjfDu8rRUVPT@v9/AA "PHP – Try It Online")
This is a hard coded compressed string. I couldn't find a solution shorter than this!
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 125 109 105 bytes
```
x,*d=L"<;1:293847564
0P`P
05";main(i){for(;i=d[12];printf("%*d",i/4,*d++-48))for(x=i&3;x--;)puts("");}
```
* -16 bytes (-3 for better loop arrangement, -13 for directly including the non-printable chars) thanks to [Jonathan Frech](https://codegolf.stackexchange.com/questions/170297/display-a-clock-face#comment411318_170339).
* -4 bytes by replacing a division for a shift and abusing the fact that on many systems (like the one hosting TIO), `sizeof(wchar_t) == sizeof(int)` -- won't work on windows :) Thanks [ErikF](https://codegolf.stackexchange.com/questions/170297/display-a-clock-face#comment411343_170339) for the idea.
[Try it online!](https://tio.run/##S9ZNT07@/79CRyvF1kfJxtrQysjS2MLE3NTMRNaAL4A9gT9AzsBUyTo3MTNPI1OzOi2/SMM60zYl2tAo1rqgKDOvJE1DSVUrRUknU98EaIi2tq6JhaYmSFmFbaaasXWFrq61ZkFpSbGGkpKmde3//wA "C (gcc) – Try It Online")
This is a port of my general idea from [the 6502 solution](https://codegolf.stackexchange.com/a/170319/71420) to C. It's a bit modified: Instead of having a flag for a leading `1`, the character is printed as a decimal by subtracting 48, so 10 - 12 are encoded as `:` to `<`.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 145 137 125 bytes
Only the tab positions are hard-coded: all the line spacings and clock values are generated in the loop.
Thanks again to ceilingcat for the suggestions.
```
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;}
```
[Try it online!](https://tio.run/##PU47C8IwGNz9FTEiJE3ig/qgxioFBxfdHKQ4SNrql9oHTXQp/e21dRAO7gXHKfFQqh1Brl7vKEZbYyMoJs9dC1zzVCZEPe@VY2mdFBUBfy1BCGn9LM5MbIllpqwgtwmxHI@dqANmrjPUHJ@PhwCH@iZWS75iwHFwulz/gQDK5zOe@prBdEFZSrUPO3ffFRuQTdttouwOOfkUEFFUDxDqjyATet5Ndi4hhvZcvq35yab9Ag "C (gcc) – Try It Online")
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 37 bytes
```
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
```
[Try it here!](https://pyke.catbus.co.uk/?code=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&input=&warnings=0&hex=1) (raw bytes)
```
;25Dt_t+Foh2.DR}t*12%12|`R-)s
```
[Try it here!](https://pyke.catbus.co.uk/?code=%3B25Dt_t%2BFoh2.DR%7Dt%2a12%2512%7C%60R-%29s&input=%5B13%2C+19%2C+12%2C+34%2C+20%2C+53%2C+24%5D&warnings=1&hex=0) (Human readable)
```
                              - 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)
```
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~315~~ 313 bytes
*saved 2 bytes thanks to [ovs](https://codegolf.stackexchange.com/users/64121/ovs)!*
```
++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+++++++>+><<<...........>>.<<<<.>.>.....>>..<<...........>>.<<<..>.>>.>.<<<...................<<.>...>>++.<.......................<<<.>>...>..>-.<...................<<<<.>>>..>......>-.<...........<<<<<.>>>>.>............>-.
```
[Try it online!](https://tio.run/##bY5LCoAwDEQPFDonKHMRcaGCIIILwfPXJDVKpVMa8nkTMp/TdqzXspciqoEWcxrpWfPZ1jmksJm8GdPaqe3IKVQan0iYH9T31OgAMMCY1h3yBcaKoDevTPbtRjKhv8YZ4jnmz@UA4lq8WCk3 "brainfuck – Try It Online")
all in one code block:
```
++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+
++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+
++++++>+><<<...........>>.<<<<.>.>.....>>..<<
...........>>.<<<..>.>>.>.<<<................
...<<.>...>>++.<.......................<<<.>>
...>..>-.<...................<<<<.>>>..>.....
.>-.<...........<<<<<.>>>>.>............>-.
```
[Answer]
# Powershell, ~~94~~ ~~88~~ 82 bytes
Direct [Powershell format operator](https://ss64.com/ps/syntax-f-operator.html). `{i,w}` means a placeholder for a parameter with index `i`, width of the placeholder is `w` with right align.
```
"{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 bytes
Port of [Arnauld's](https://codegolf.stackexchange.com/users/58563/arnauld) [Javascript answer](https://codegolf.stackexchange.com/a/170298/80745)
*-6 bytes thanks to @AdmBorkBork*
```
[RegEx]::Replace("K12
E11K1
A10S2
9W3
B8S4
F7K5
L6",'[A-Z]',{' '*("$args"[0]-64)})
```
To better see the grid, use `'.'` instead `' '`.
[Answer]
# JavaScript with SVG, 188 bytes
Arbitrary line height of 120% uses 4 bytes.
```
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 grid for comparison:
```
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)
```
---
## Explanation of Positioning Formula
Let `f(x) = round(sin(x * π/6) * 6)`.
Assuming the origin is the center of the clock, the grid coordinates of the right-most digit of any given clock number `x` is
[`f(x) * 2`, `f(9 - x)`].
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/Attache), 69 bytes
```
{ReplaceF["l12
f11l1
b10t2
9x3
c8t4
g7l5
m6",/"\\l",sp&`*@STN]}
```
[Try it online!](https://tio.run/##SywpSUzOSP2fpmBl@786KLUgJzE51S1aKcfQiCvN0DDHkIsrydCgxIiLi8uywhhIJluUmHBxpZvnmHLlminp6CvFxOQo6RQXqCVoOQSH@MXW/g8oyswrUbCpUUiLjv0PAA "Attache – Try It Online")
This encodes each run of spaces as: `NTS[count of spaces]`; `NTS` is the "numeric to short" builtin, which allows numbers to be expressed as strings. E.g., `NTS[95] = $R1` and `NTS[170297] = $XQO`. `STN` is the inverse of this builtin.
This answer replaces (`ReplaceF`) all occurences of letters (`/\l/`) in the input with the result of the function `sp&`*@STN`, which firsts decodes the letter and then repeats `sp` (a space) that many times.
[Answer]
# [Swift](https://swift.org), ~~178~~ 165 bytes
~~`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)`~~
Based on what Downgoat posted, I've reduced this to 165 bytes:
`print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map{let x=Int($0.value);return x==110 ?"\n":(x>64 ?String(repeating:" ",count:x-65):"($0)")}.joined())`
Expanded out, with `$0` converted to a named variable:
`print("L12nF11L1nnB10T2nnn9X3nnnC8T4nnG7L5nM6".unicodeScalars.map { c in
 let x = Int(c.value)
 return x == 110 ? "\n" : (x>64 ? String(repeating:" ", count: x-65) : "(c)")
}.joined())`
The input string is encoded as follows: Uppercase letters (`A-Z`) represent blocks of spaces, offset by 65. So `A` means 0 spaces, `B` means 1 space, the first `L` means 11 spaces, etc. `n`s are converted to newlines. All other characters are printed as-is.
Run it online [here](https://tio.run/##DY1BC4IwGIb/yhgdNqjhTK0WJhQUgZ3y0MHL0BUL@5S5lRD99rXLy8NzeN7xo@828X4wGizBJY/hyHnJAfY8qmIA2NyWYQ/rKgE4rcoULhlmDnTTt@rayE6akb3k8O2URVN@DpVZxN6yc4pujbLOQNA55xEqcA1YkGmXJai42vD4IEYNStpAAiM8b3oHVkyLLKUC1yFEMf2xZ69BtYRS7/8) (thanks, mbomb007)
[Answer]
# vim, 103 bytes
```
25a <ESC>r30r9O0i <C-v><ESC>15l2xA <C-v><ESC><ESC>0"aDddqbYp<C-x>e<C-a>q2@a@b4@a@b6@aggqbYP<C-a>e<C-x>q@axr 2hr2@b4@a@b6@ayyjpr lr yyj2p2j2p2jp
```
`<ESC>` is 0x1b, `<C-a>` is 0x01, `<C-x>` is 0x18, and `<C-v>` is 0x16.
This includes all trailing spaces because I didn't notice they were optional until I'd finished for the additional challenge.
## Annotated
```
25a <ESC>r30r9                            # create the 9...3 line
o0i <C-v><ESC>15l2xA <C-v><ESC><ESC>"a0D  # create macro a that moves 2 spaces from the middle to the ends
                                          # 15 is a magic number that lets the same macro work for the 6 and 12 lines
dd                                        # delete empty line
qb                                        # record macro b to...
  Yp                                      #    duplicate line (down)
  <C-x>e<C-a>                             #    adjust numbers
q
2@a                                       # adjust spacing for line 8..4
@b4@a                                     # create line 7..5
@b6@a                                     # create line 6
gg                                        # move cursor to first line
qb                                        # record macro b to...
  YP                                      #    duplicate line (up)
  <C-a>e<C-x>                             #    adjust numbers
q
@axr 2hr2                                 # adjust spacing for 2-digit numbers
@b4@a                                     # 11..1
@b6@a                                     # 12
yyjpr lr yy                               # add a line of all spaces below 12, and copy to default register
j2p2j2p2jp                                # add the rest of the blank lines
```
[Try it online!](https://tio.run/##K/v/38g0UUG6yNigyNLfIFNBTNrQNMeowhHIkDZQSnRJSSlMiiyQSGUsNHJIdEgyARFmDonp6UDhAMZUiUKHxIoiBaOMIiOEZGVlVkGRQk6RApBhVGAExgX//wMA "V (vim) – Try It Online")
[Answer]
# [Red](http://www.red-lang.org), 151 bytes
```
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]]
```
[Try it online!](https://tio.run/##PY3RCoMwDEV/5dIf0LRu3X5jr6WDronMMVSK/9@lToT7kHNIbopwfQiHWMelSMrvkPBCBsdADmRBxngQ7WMDjfoeVvPnZ2d63GEHuFM43NrGcFx4@FZwgXZem4thLdO8ochnmeawJu6@Mm76OuEERo6x1h8 "Red – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~112~~ ~~88~~ 87 bytes
A solution using string interpolation.
```
print(f'''{12:13}
{11:7}{1:12}
 10{2:20}
9{3:24}
  8{4:20}
{7:7}{5:12}
{6:13}''')
```
[**Try it online!**](https://tio.run/##JYwxDoAgEAR7XkGHdtyBovcgow0SQ2M2vP0U7SaTyZS77mcOquU6ch025xyIhUIzIJLUQELcjLHkwcL@RbMiCMdO1i6Iv0Xq9fTVmPvhfY2qDw "Python 3 – Try It Online")
*-25 bytes thanks to ovs and Herman L.*
[Answer]
# Pure [Bash](https://www.gnu.org/software/bash/), 123
`printf` does the heavy-lifting here:
```
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}"
```
[Try it online!](https://tio.run/##HYzNCoQwDITvPsVQ6mVBNK3rz8E38VLFxb2kyypexGeviTBD5suQTGFbU@LBoEJQm@z3//L@QXFE5K9NNI78tORBDi2IdBIsQzYVnMiyEKGHq@Ef8Oi0qSW2euTw1g9NtsxrhLFnLMtwmZRu "Bash – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 135 123 110 bytes
This uses a simple encoding where any `c` between `'a'` and `'z'` represents `c-'a'+1` repeated spaces, `'`'` represents a newline, and all other characters are left unchanged.
```
f(i){char*s="k12`e11k1``a10s2```9w3```b8s4``f7k5`l6`";for(;i=*s;s++)i>96?printf("%*s",i-96,""):putchar(i%86);}
```
[Try it online!](https://tio.run/##FczRDoIgFIDhe5@CsbkB6hZWJDHrVQ6xsDPKHNi6cD472c1/9e13zeBczp4hX9zDRpF6GmQLdymDBLByl1oA0N/91luXDgD@FI7wVECNf0dmsBfJpKrieNHqOkUcZ89oKRKtsdGqppSfp8/8nzMsO8XNmjdDXhZHxslSEOIZN8Wafw "C (gcc) – Try It Online")
[Answer]
# T-SQL, 132 bytes
```
PRINT SPACE(11)+'12
     11           1
 10'+SPACE(20)+'2
9'+SPACE(23)+'3
  8'+SPACE(19)+'4
      7           5
            6'
```
Only 12 bytes shorter than the trivial solution (`PRINT` of the entire string as-is).
Found a variation I like that is much longer (~~235~~ 226 bytes), but much more SQL-like:
```
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` breaks it into rows at the commas, and `PARSENAME` splits each row at the dots. The 1st and 3rd are used for how many spaces to print, the 2nd and 4th are used for what to display.
(line breaks in this one are just for readability)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 116 bytes
```
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/.//}
```
[Try it online!](https://tio.run/##K0gtyjH7/z@30iHRNlpJQUGpokLB0DgWTFprqMTbFmTqm2lpa6tYOyRGG2jXmGlpGOoZ6uol5xdrWsP52nrFmXmasbZpuSUKQLVWCkqqRsVKmiBTjIAa7ez0svIz84CUWnVxYqVCsL6evn7t//8A "Perl 6 – Try It Online")
(Ta @JoKing for saving 26 bytes)
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 142 bytes
```
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
```
[Try it online!](https://tio.run/##Rc1BC4IwGIDhe7/iQzxsq76xCV6GsP/QccyYWjQwJ1uBIv72RRB0eQ/P5Z1vcaxzfq7aNcaYSp4qaZcFRPWruocIAlFI2MprU7Ydmz2vlXYmhvc0QM2IOGMfElV/OGLyE7WNKaDsCgxxSPhyfiSS2v2wJbfChbfI@U7QMMUs9o@YKHxn2uX8AQ "Perl 6 – Try It Online")
I wanted to do something... different. So this one calculates the positions of all the digits, via pairs of characters, strips off the initial space and prints the lines.
Easily modifiable for different parameters, e.g. a [45 character wide version with 17 digits](https://tio.run/##Tc1BC8IgGIDhe79Chge1@sJv1Q4y8H@IhduKhDWHFmyM/XYj6NDlPTyXd7zF/pzzc9auNsaUuCvRThM5nn5V9xCJBJAVWei1ppdGoBj9QVZKOxPDe@gIomByD21IXP3JFpIfuK1NQWhTQIhdgpfzPUNu180Cyc0rAyOUsNA@YuLk@9Iu5w8).
]