Wyświetl tarczę zegara

39

Wyświetl 12 cyfr na tarczy zegara dokładnie tak:

           12            
     11           1      

 10                   2  


9                       3


  8                   4  

      7           5      
            6            

Aby lepiej zobaczyć siatkę, oto jedna z kropkami:

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

Zauważ, że siatka jest rozciągnięta na szerokość dwa razy, aby wyglądała bardziej kwadratowo.

Należy również pamiętać, że liczby dwucyfrowe są wyrównane z cyframi na miejscu. Cyfra 9 powinna być wyrównana do lewej.

Zwróć lub wydrukuj wynik jako ciąg wielowierszowy (nie listę wierszy). Wszelkie spacje końcowe są opcjonalne. Ostateczna nowa linia jest również opcjonalna.

xnor
źródło

Odpowiedzi:

25

Węgiel drzewny , 40 bajtów

F¹²«M⁻↔⁻¹⁴⊗÷×⁴鳦⁸⁻⁴↔⁻⁷÷×⁴﹪⁺³ι¹²¦³P←⮌I⊕ι

Wypróbuj online! Link jest do pełnej wersji kodu. Objaśnienie: Oblicza przesunięcia między każdą cyfrą matematycznie. Węgiel drzewny jest indeksowany 0 (a więc do wyjścia ), więc wzory dla przesunięć poziomych i pionowych są następujące:112

δx=|1424i3|8δy=4|74i3|

gdzie .i=i+3(mod12)

Neil
źródło
22

JavaScript (Node.js) , 91 bajtów

Niezbyt sprytne podejście, ale w tej chwili nie znalazłem nic krótszego.

_=>`K12
E11K1

A10S2


9W3


B8S4

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

Wypróbuj online!

Arnauld
źródło
4
Uwielbiam używać Buffer () jako alternatywy dlacharCodeAt()
Downgoat
1
@Downgoat Zastanawiam się, czy powinniśmy mieć Porady dotyczące gry w golfa w pytaniu Node.js dotyczące funkcji specyficznych dla Node. Nie jestem jednak pewien, czy warto.
Arnauld,
Może dodać osobną odpowiedź, która zawiera wszystkie funkcje specyficzne dla węzła, lub przynajmniej listę łączącą wszystkie różne odpowiedzi?
15

05AB1E , 39 33 31 bajtów

Dzięki Magic Octopus Urn za uratowanie 6 bajtów!

Kod

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

Około 33 bajtów alternatywnych:

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

Wykorzystuje kodowanie 05AB1E . Wypróbuj online!

Adnan
źródło
Niezła odpowiedź! Lubię używać ÿz .V, bardzo oryginalny! I zabawne, jak kiedyś 12¤dostałeś oba 12i 2na stosie. Prawdopodobnie bym właśnie użył 12Y, ale myślę, że to nie ma znaczenia, ponieważ oba mają po 12 i 2 na stosie. Gdybym spróbował tego wyzwania w 05AB1E, skończyłbym znacznie wyżej pod względem liczby bajtów. Chyba wciąż mam wiele do nauczenia się. ;)
Kevin Cruijssen
@KevinCruijssen O tak, zapomniałem Y. To byłaby łatwiejsza opcja, hahaha.
Adnan
Nie wiem, czy naprawiam 6 na mniej niż 6 bajtów: 6xsŸ5L•δ;Ì’•2ôúð.ø‚ζJ012∞S¶×‚ζJ.cale możesz tu coś z tego skorzystać.
Magic Octopus Urn
1
@MagicOctopusUrn Niezła sztuczka z zamkiem, nie myślałem o tym.
Adnan,
1
@ adnan 6xŠ»też się wspiera , nigdy bym o tym nie pomyślał.
Magic Octopus Urn
10

Kod maszynowy 6502 (C64), 82 76 73 bajty

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 bajtów, dzięki Arnauldowi za sprytny pomysł :)
  • kolejne -3 bajty po pomyśle Arnaulda, aby nie traktować 1specjalnie cyfr wiodących

Chodzi o to, aby przechowywać cyfry wszystkich liczb w kolejności, w jakiej są potrzebne. Wymagane dodatkowe informacje to liczba nowych wierszy do dodania i liczba spacji z przodu.

Maksymalna liczba znaków nowej linii wynosi 32 bity, a maksymalna liczba spacji to 235 bitów. Dlatego dla każdej cyfry do wydrukowania możemy wycisnąć tę informację w jednym „bajcie kontrolnym”.

Tak więc dane dla tego rozwiązania zajmują dokładnie 30 bajtów: 15 pojedynczych cyfr i 15 powiązanych „bajtów kontrolnych”.

Demo online

Zastosowanie: SYS49152na początek.

Skomentowany demontaż :

         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
Felix Palmen
źródło
2
Czy można zapisać 2 bajty za pomocą podprogramu JSR $FFD2 / DEY / BNE loop / LDA .control,X / RTSwywołującego zarówno znaki nowego wiersza, jak i spacje? Myślę, że będzie to +10 bajtów długości i zapisanie -12 bajtów w głównym kodzie.
Arnauld,
1
Właściwie myślę, że możesz zaoszczędzić więcej bajtów, jeśli podprogram działa, JSR $FFD2 / DEY / BPL loop / LDA .control,X / RTSa punktem wejścia jest DEY. W ten sposób nie musisz testować 0kodu głównego.
Arnauld
Dzięki fajny pomysł, edytuję później. To ostatnie jednak nie działa, potrzebuję skrzynki, która pomija całą pętlę.
Felix Palmen,
1
Jeśli Y = 0, DEY / BPL / RTSnastąpi natychmiastowe zakończenie bez przetwarzania JSR $FFD2. (Należy pamiętać, że w tym schemacie punktem wejścia podprogramu musi być DEY.)
Arnauld
1
@Arnauld po dość eksperymentach, myślę, że najkrótszym jest utrzymanie podprogramu przy użyciu twojej sugestii przechowywania wszystkich cyfr :)
Felix Palmen
6

Perl 6 , 76 74 bajtów

$_="K12
E11K1

A10S2


9W3


B8S4

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

Wypróbuj online!

Odpowiedź Portu Arnaulda, dopóki nie wymyślę czegoś krótszego.

Jo King
źródło
6

R , 75 68 bajtów

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

Wypróbuj online!

Skompresowane pozycje cyfr. Zrobił to po spędzeniu dużo czasu próbując znaleźć odpowiedź trygonometryczną (patrz historia zmian).

Zainspirowany inną odpowiedzią R. Kup J.Doe - głosuj!

Zaoszczędź 7 bajtów dzięki J.Doe.

JayCe
źródło
68 bajtów - zmieniono skrót, aby uniknąć arytmetyki i zmieniono writewywołanie, aby użyć domyślnego separatora.
J.Doe
1
@ J.Doe W ten sposób ma to większy sens. Oczywiście, że nie udokumentowałem mojego golfa, nie mam pojęcia, dlaczego w ogóle
wykonałem zawiły
5

HTML + JavaScript (Canvas), 13 + 161 = 174 bajty

Arbitralne pozycjonowanie obszaru roboczego zajmuje 6 bajtów.

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>

Z siatką do porównania:

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>


Objaśnienie wzoru pozycjonowania

Zobacz mój JavaScript z odpowiedzią SVG .

darrylyeo
źródło
8
Nie sądzę, żeby to się liczyło, ponieważ ponieważ jest to sztuka ASCII, powinniśmy wygenerować dokładny strumień bajtów określony w wyzwaniu, podczas gdy renderuje obraz, który wygląda jak wyjście.
Downgoat
5

Java 8 11, 141 138 bajtów

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

Wypróbuj online (UWAGA: String.repeat(int)jest emulowany jak repeat(String,int)dla tej samej liczby bajtów, ponieważ Java 11 nie jest jeszcze w TIO).

Wyjaśnienie jest podobne do poniższego, ale wykorzystuje " ".repeat(x-48)spacje zamiast formatować za pomocą "%"+(x-48)+"s".


Java 8, 141 bajtów

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

Wypróbuj online.

Wyjaśnienie:

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

Dalsze wyjaśnienie 92BCN5BB92BNN1BA991CNNNJ995DNNN2I991ENN6H92FN93G:

  • Wszystkie cyfry zostaną zastąpione taką ilością spacji. (Dlatego dla 11 spacji 92.)
  • Wszystkie „N” są znakami nowej linii
  • Wszystkie [„A”, „J”] są cyframi zegarowymi ([0,9])
Kevin Cruijssen
źródło
5

R, 168 159 125 bajtów

Naiwne rozwiązanie polegające na zapisywaniu liczb w wyznaczonych punktach w matrycy tekstowej. Punkty są przechowywane jako litery UTF-8 dekodowane za pomocąutf8ToInt

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

Usunięto 9 bajtów z sugestią JayCe, aby używać writei unikać definiowania macierzy.

Usunięto kolejne 34 bajty z sugestią JayCe dotyczącą przechowywania.

J.Doe
źródło
Witaj w PPCG! Myślę, że kropki mają pomóc w wizualizacji wzoru, ale nie stanowią części wyniku.
Jonathan Frech,
Witamy w PPCG! możesz zapisać niektóre bajty, które nie definiują mi nie używają write: TIO . PS: nie musisz dołączać linku TIO do swojej odpowiedzi, ale ładnie formatuje odpowiedź, patrz ikona linku na górze strony TIO.
JayCe,
Możesz przechowywać punkty w ciągu i przeciążać !operatora, aby dostać się do 125 znaków . Naprawdę fajne rozwiązanie!
JayCe,
5

Haskell, 88 87 bajtów

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

Metoda kodowania spacji jako liter (po raz pierwszy zobaczona w odpowiedzi @ Arnaulda ) w Haskell. Używanie {i rozwijanie go \njest o jeden bajt krótsze niż \nbezpośrednie.

Wypróbuj online!

nimi
źródło
5

pieprzenie mózgu , 240 235 bajtów

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

Wypróbuj online!

Skomentowany 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

Rzadki przykład, w którym tekst jest wystarczająco powtarzalny, że program pieprzenia mózgu jest mniej niż dwa razy 1,6 razy dłuższy niż wynik!

2 bajty zapisane według sugestii Jo Kinga: >>>>>>-->[<]>-

3 bajty zaoszczędzone poprzez przeniesienie trzeciego 20-miejscowego licznika w dół z skrajnie prawej strony kodów ascii 10 30 50bezpośrednio na lewo od nich. Oszczędność <<>>przy wypełnianiu luki między 8i 4, ale dodaje 1 bajt do linii >>>++.

Orginalna wersja

++++++++++                              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
Level River St
źródło
4

Python 2 , 97 bajtów

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)

Wypróbuj online!

Oblicza wszystkie odstępy i znaki nowej linii w pętli

TFeld
źródło
4

Galaretka , 32 bajty

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

Pełny program, który drukuje wynik.

Wypróbuj online!

W jaki sposób?

(Jeszcze nie pomyślałem / nie znalazłem nic krótszego niż to, “¿×¿ Œ4ç4Œ!¿Ø‘co wydaje mi się długie w tej części - odbijanie / dekompresja / przyrosty, nic nie wydaje się oszczędzać!)

⁶ẋ“¿×¿ Œ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
Jonathan Allan
źródło
LOL Jestem właściwie zaskoczony, że to naiwne podejście.
Erik the Outgolfer,
4

C (gcc) , 145 137 125 bajtów

Tylko pozycje tabulatorów są zakodowane na stałe: wszystkie odstępy między wierszami i wartości zegara są generowane w pętli.

Jeszcze raz dziękuję sufitowi za sugestie.

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

Wypróbuj online!

ErikF
źródło
Zaproponuj "\r\7\3"[j]zamiast"NHDA"[j]-65
ceilingcat
3

PHP , 97 bajtów

<?=gzinflate(base64_decode(U1CAA0MjLghtqIAkyMWlYGiggAmMuLi4LBWwA2OgnIKCBRYZEy6IHQrmSIKmXMhKzAA));

Wypróbuj online!

Jest to mocno skompresowany ciąg znaków. Nie mogłem znaleźć rozwiązania krótszego niż to!

Noc 2
źródło
Czy możesz umieścić skompresowany ciąg binarny w pliku źródłowym i pominąć kod_dostowy_64? Próbowałem tego i pojawia się komunikat „gzinflate (): błąd danych”, ale może to być możliwe, jeśli plik źródłowy został napisany za pomocą edytora szesnastkowego zamiast edytora tekstowego.
bdsl,
@ bdsl faktycznie tak robiłem wcześniej i nie potrzebujesz edytora HEX, możesz po prostu użyć samego PHP file_put_contents($path, '<?=gzinflate("'.gzdeflate($clockString,9).'");');, ale nie jestem pewien, jak opublikować kod z danymi binarnymi w nim. Taki plik ma 70 bajtów.
Noc 2
3

Pyke , 37 bajtów

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

Wypróbuj tutaj! (surowe bajty)

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

Wypróbuj tutaj! (Czytelny dla człowieka)

                              - 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)
niebieski
źródło
3

pieprzenie mózgu , 315 313 bajtów

zapisane 2 bajty dzięki ovs !

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

Wypróbuj online!

wszystko w jednym bloku kodu:

++++[>++++<-]>[>+++>+++>+++>+++>>++>+++>+++>+
++<<<<<<<<<-]>+++++>++++>+++>++>++++++++++>>+
++++++>+><<<...........>>.<<<<.>.>.....>>..<<
...........>>.<<<..>.>>.>.<<<................
...<<.>...>>++.<.......................<<<.>>
...>..>-.<...................<<<<.>>>..>.....
.>-.<...........<<<<<.>>>>.>............>-.
Conor O'Brien
źródło
Możesz użyć ++++[>++++<-]>dla 16 na początku.
ovs
@ovs Ah, oczywiście, dziękuję !!
Conor O'Brien,
Lol, masz ><w swoim kodzie
Jo King
3

PowerShell, 94 88 82 bajtów

Bezpośredni operator formatu PowerShell . {i,w}oznacza symbol zastępczy parametru z indeksem i, szerokość symbolu zastępczego jest wwyrównana do prawej.

"{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 bajtów

Odpowiedź JavaScript na Port of Arnauld

-6 bajtów dzięki @AdmBorkBork

[RegEx]::Replace("K12
E11K1

A10S2


9W3


B8S4

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

Aby lepiej zobaczyć siatkę, użyj '.'zamiast tego ' '.

mazzy
źródło
1
Dlaczego nie pomnożenie ciągu zamiast .PadLeft88 bajtów - Wypróbuj online!
AdmBorkBork,
To sprytne zastosowanie -f. Dołącz linki do Wypróbuj online! aby inni mogli zobaczyć, jak działa Twój kod?
AdmBorkBork,
Mam This site can’t be reachedtylko błąd . Przepraszam.
mazzy
Ach, szkoda. To dobry zasób. :-(
AdmBorkBork
Zgadzam się. Dzięki.
mazzy
3

C (gcc) , 125 109 105 bajtów

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 bajtów (-3 dla lepszego uporządkowania pętli, -13 dla bezpośredniego włączenia znaków niedrukowalnych) dzięki Jonathanowi Frechowi .
  • -4 bajty, zastępując podział na zmianę i nadużywając faktu, że na wielu systemach (takich jak ten obsługujący TIO), sizeof(wchar_t) == sizeof(int)- nie będzie działał na Windowsie :) Dzięki ErikF za pomysł.

Wypróbuj online!

Jest to część mojego ogólnego pomysłu z rozwiązania 6502 na C. Jest to nieco zmodyfikowane: Zamiast flagi na początku 1, znak jest drukowany po przecinku przez odjęcie 48, więc 10-12 jest zakodowanych co :do tego <.

Felix Palmen
źródło
1
109 bajtów .
Jonathan Frech,
@JonathanFrech ładny pętla przegrupowanie, zastanawiam się, jak brakowało mi, że jednym: o Ale naprawdę nie spodziewałem gcc, aby zaakceptować znaki niedrukowalne w źródle :)
Felix Palmen
Dopóki postać może być reprezentowana w UTF-8, jest to technicznie akceptowalne przez kompilator. To, czy jest to dobra rzecz, zależy raczej od tego, co robisz :-)
ErikF,
Mówiąc o Unicode, możesz zaoszczędzić 3 bajty, używając szerokich znaków: Wypróbuj online!
ErikF,
1
Dlatego lubię gry w golfa kodowego: nadużywam UB i używam tych „rzeczy, których nie powinieneś robić”, które zbierasz z czasem!
ErikF,
2

Attache , 69 bajtów

{ReplaceF["l12
f11l1

b10t2


9x3


c8t4

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

Wypróbuj online!

To koduje każdy ciąg spacji jako NTS[count of spaces]:; NTSjest wbudowanym „numerycznym do krótkiego”, który umożliwia wyrażanie liczb jako ciągów znaków. Na przykład, NTS[95] = $R1i NTS[170297] = $XQO. STNjest odwrotnością tego wbudowanego.

Ta odpowiedź zastępuje ( ReplaceF) wszystkie wystąpienia liter ( /\l/) na wejściu wynikiem funkcji sp&`*@STN, która najpierw dekoduje literę, a następnie powtarza sp(spację) wiele razy.

Conor O'Brien
źródło
2

Szybki , 178 165 bajtów

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)

Na podstawie tego, co napisał Downgoat, zmniejszyłem to do 165 bajtów:

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

Rozwinięty, $0przekształcony w nazwaną zmienną:

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ńcuch wejściowy jest kodowany w następujący sposób: Wielkie litery ( A-Z) oznaczają bloki spacji, przesunięte o 65. AOznacza to 0 spacji, B1 spację, pierwsze L11 spacji itp. nS są konwertowane na znaki nowej linii. Wszystkie pozostałe znaki są drukowane w obecnej postaci.

Uruchom tutaj online (dzięki, mbomb007)

Ezekiel Elin
źródło
Witamy w PPCG! Wielu z nas korzysta z funkcji Wypróbuj online (TIO), aby tłumacze online umieścili w odpowiedziach hiperłącze do programu. Oto odpowiedź: tio.run/##JY1BC4IwGIb/yvpOSjScqRW2DgV1sVMeOgQx14SBfMacdhB/…
mbomb007
Oto golf twojej odpowiedzi, który ma 172 bajty. Zamiast tego używa funkcji: {"L12NF11L1NNB10T2NNN9X3NNNC8T4NNG7L5NM6".unicodeScalars.map({(c)->String in let x=c.value;return x==78 ? "\n" : x>64 ?String(repeating:" ",count:x-65) : "\(c)"}).joined()}(swift 3 ( -swift-version 3po repl), ponieważ wygląda na to, że odrzucił 4 szybkie odejmowanie)
Downgoat
@Downgoat Zmniejszyłem go o kolejne 3 bajty i dostosowałem do Swift 4. Zobacz zaktualizowany post.
Ezekiel Elin,
2

Pure Bash , 123

printf wykonuje tutaj podnoszenie ciężarów:

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

Wypróbuj online!

Cyfrowa trauma
źródło
1

Czerwony , 151 bajtów

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

Wypróbuj online!

Galen Iwanow
źródło
1

JavaScript z SVG, 188 bajtów

Dowolna wysokość linii wynosząca 120% wykorzystuje 4 bajty.

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)

Z siatką do porównania:

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)


Objaśnienie wzoru pozycjonowania

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

Zakładając, że początek jest środkiem zegara, współrzędne siatki najbardziej prawej cyfry danego numeru zegara xto [ f(x) * 2, f(9 - x)].

darrylyeo
źródło
1

Bash, 225 bajtów

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

Irytujące jest to dłuższe niż naiwne rozwiązanie polegające na drukowaniu każdego wiersza w pętli (132 znaki w przypadku korzystania z tabstops).

crystalgecko
źródło
Czy tr -d \<space>(gdzie <space>jest znak spacji) działałoby zamiast podstawienia sed?
Kritixi Lithos
@ Cowsquack niestety nie tr -d\ byłoby równoważnesed 's/ //g'
crystalgecko
1

Python 3 , 112 88 87 bajtów

Rozwiązanie wykorzystujące interpolację łańcuchów.

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

 10{2:20}


9{3:24}


  8{4:20}

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

Wypróbuj online!

-25 bajtów dzięki ovs i Hermanowi L.

mbomb007
źródło
A jeśli użyjesz ciągu formatującego Hermans , możesz uzyskać go do ~ 85 bajtów.
ovs
Jeszcze jeden bajt z {11:7}.
ovs
1

C (gcc) , 135 123 110 bajtów

Wykorzystuje to proste kodowanie, w którym dowolne cpomiędzy 'a'i 'z'reprezentuje c-'a'+1powtarzające się spacje, '`'reprezentuje nowy wiersz, a wszystkie pozostałe znaki pozostają niezmienione.

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

Wypróbuj online!

Curtis Bechtel
źródło
Zaproponuj *s=L"...";f(i){zamiastf(i){char*s="...";
ceilingcat
1

T-SQL, 132 bajty

PRINT SPACE(11)+'12
     11           1

 10'+SPACE(20)+'2


9'+SPACE(23)+'3


  8'+SPACE(19)+'4

      7           5
            6'

Tylko 12 bajtów krótszych niż trywialne rozwiązanie (PRINT całego łańcucha bez zmian).

Znalazłem wariant, który podoba mi się, jest znacznie dłuższy ( 235 226 bajtów), ale znacznie bardziej podobny do 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 dzieli go na wiersze w przecinkach i PARSENAME dzieli każdy wiersz na kropki. 1. i 3. są używane do określenia liczby spacji do wydrukowania, 2. i 4. są używane do wyświetlania.

(podział wiersza w tym jest tylko dla czytelności)

BradC
źródło
1

Perl 6 , 116 bajtów

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

Wypróbuj online!

(Ta @JoKing za zapisanie 26 bajtów)

Perl 6 , 142 bajtów

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

Wypróbuj online!

Chciałem zrobić coś ... innego. Więc ten oblicza pozycje wszystkich cyfr, za pomocą par znaków, usuwa początkową spację i drukuje linie.

Łatwo modyfikowalny dla różnych parametrów, np. Wersja o szerokości 45 znaków z 17 cyframi .

Phil H
źródło
116 bajtów
Jo King
@JoKing: Ta, wkleiłem to i stworzyłem wiki.
Phil H