Wyzwanie jest w rzeczywistości niezwykle proste. Wybierz 5 różnych liter (możesz po prostu wybrać 5, które pozwolą ci najkrótszy kod, jeśli chcesz) i wyślij je do konsoli. Jednak obrót polega na tym, że muszą pochodzić z następującej listy:

 AAA      BBBB       CCCC     DDDD      EEEEE     FFFFF      GGG      H   H
A   A     B   B     C         D   D     E         F         G         H   H
AAAAA     BBBB      C         D   D     EEEE      FFFF      G  GG     HHHHH
A   A     B   B     C         D   D     E         F         G   G     H   H
A   A     BBBB       CCCC     DDDD      EEEEE     F          GGG      H   H


IIIII         J     K   K     L         M   M     N   N      OOO 
  I           J     K  K      L         MM MM     NN  N     O   O
  I           J     KKK       L         M M M     N N N     O   O
  I       J   J     K  K      L         M   M     N  NN     O   O
IIIII      JJJ      K   K     LLLLL     M   M     N   N      OOO 


PPPP       QQQ      RRRR       SSSS     TTTTT     U   U     V   V     W   W
P   P     Q   Q     R   R     S           T       U   U     V   V     W   W
PPPP      Q   Q     RRRR       SSS        T       U   U     V   V     W   W
P         Q  QQ     R  R          S       T       U   U      V V      W W W
P          QQQQ     R   R     SSSS        T        UUU        V        W W 


X   X     Y   Y     ZZZZZ
 X X       Y Y         Z 
  X         Y         Z  
 X X        Y        Z   
X   X       Y       ZZZZZ

Dodatkowe zasady:

• 5 tej samej litery jest niedozwolone, bez powtarzalnych wyborów.
• Każda litera musi użyć stolicy samego siebie jako znaku ascii, aby ją narysować.
• Każda litera wyjściowa musi znajdować się w „tej samej linii” i mieć 5 spacji między każdą literą.
• Możesz wybrać dowolne 5 liter, co pozwoli ci ponownie użyć kodu i zmniejszyć liczbę bajtów. Ustalenie, które litery pozwolą ci to zrobić najskuteczniej, stanowi część wyzwania.
• Dopuszczalne są spacje końcowe.
• Pojedynczy znak nowej linii jest akceptowalny, ale nie więcej niż jeden znak nowej linii.
• To jest golf golfowy, wygrana o najniższej liczbie bajtów.

Przykłady:

ABCDE

 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E    
AAAAA     BBBB      C         D   D     EEEE 
A   A     B   B     C         D   D     E    
A   A     BBBB       CCCC     DDDD      EEEEE

EFLIP

EEEEE     FFFFF     L         IIIII     PPPP 
E         F         L           I       P   P
EEEE      FFFF      L           I       PPPP 
E         F         L           I       P    
EEEEE     F         LLLLL     IIIII     P    

ZWARIOWANY

 CCCC     RRRR       AAA      ZZZZZ     Y   Y
C         R   R     A   A        Z       Y Y 
C         RRRR      AAAAA       Z         Y  
C         R  R      A   A      Z          Y  
 CCCC     R   R     A   A     ZZZZZ       Y  

Nie bój się przesyłać za każdym razem więcej niż jednej odpowiedzi z różnymi literami lub różnymi strategiami, można to osiągnąć na różne sposoby.

Galaretka , 41 bajtów

LICTE

“LICTE”Kż
141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11Ç€ŒṙY

TryItOnline!

Pomysł

Użyj dekodowania długości przebiegu z literami, które mają możliwie podobny środek, z tylko jedną długością przebiegu dla każdej „wartości piksela” na wiersz na literę.

Umieść płaski początek, taki jak „L”, aby uniknąć różnych wartości dekodowania długości przebiegu dla wierszy.

Umieść jedną inną literę (nie można znaleźć 5) trzech środkowych rzędów na końcu, aby najmniejszą różnicę można było dodać arytmetycznie.

Potrzebne wyjście; długości przebiegu; i te przekonwertowane z podstawy 11:

                                                  L,  , I,  , C,  , T,  , E   value
                                                  -------------------------
L         IIIII      CCCC     TTTTT     EEEEE     1, 9, 5, 6, 4, 5, 5, 5, 5   399633415
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
L           I       C           T       EEEE      1,11, 1, 7, 1,11, 1, 7, 4   431646160+4
L           I       C           T       E         1,11, 1, 7, 1,11, 1, 7, 1   431646160+1
LLLLL     IIIII      CCCC       T       EEEEE     5, 5, 5, 6, 4, 7, 1, 7, 5   1179122455

Te trzy wartości 399633415, 431646160oraz 1179122455w bazie 250jako Jelly indeksów strony kodowej są następnie ðƁ ƥ, ȷɓSɠi JrŀṘktóry może być używany do hermetyzacji informacje run-length.

Kod

“LICTE”Kż - Link 1, make a run length encoding for a row of the output: row's run lengths
“LICTE”    - list of characters "LICTE"
       K   - join with spaces   "L I C T E"
        ż  - zip with input     e.g. [['L',1],[' ',9],['I',5],[' ',6],['C',4],[' ',5],['T',5],[' ',5],['E',5]]

141D+“ȷɓSɠ’“ðƁ ƥ“JrŀṘ’jḃ11Ç€ŒṙY - Main link
141D                            - 141 as a decimal list: [1, 4, 1]
     “ȷɓSɠ’                     - 431646160
    +                           - add: [431646161, 431646164, 431646161]
           “ðƁ ƥ“JrŀṘ’          - list [399633415,1179122455]
                      j         - join: [399633415, 431646161, 431646164, 431646161, 1179122455]
                       ḃ11      - convert to bijective base 11: [[1, 9, 5, 6, 4, 5, 5, 5, 5], [1, 11, 1, 7, 1, 11, 1, 7, 1], [1, 11, 1, 7, 1, 11, 1, 7, 4], [1, 11, 1, 7, 1, 11, 1, 7, 1], [5, 5, 5, 6, 4, 7, 1, 7, 5]]
                          Ç€    - call last link (1) as a monad for €ach
                            Œṙ  - run-length decode e.g. [['L',1],[' ',9],['I',5],...]
                                                            -> "L         IIIII..."
                              Y - join with line feeds

Węgiel drzewny , 51 49 bajtów (ECXKI)

Ｇ←⁵↓³→⁴EＭ⁷→Ｇ↑²↗²→⁴CＭ⁶→ＧＨ↘↗³XＭ⁶→ＧＨ↓→↗³KＭ⁸→ＰTIII‖Ｏ↓

Wyjścia

EEEEE      CCCC     X   X     K   K     IIIII
E         C          X X      K  K        I  
EEEE      C           X       KKK         I  
E         C          X X      K  K        I  
EEEEE      CCCC     X   X     K   K     IIIII

Wypróbuj online!

Używając znaków symetrycznych pionowo, rysuje górne połówki, a następnie odbija. Większość z nich korzysta z Polygon ( Ｇ) i PolygonHollow ( ＧＨ), aby narysować serię połączonych segmentów linii o określonym znaku. Iłatwiej można to zrobić za pomocą MultiPrint ( Ｐ), używając Tjako kierunku.

Uwaga: PolygonHollow po prostu rysuje określone segmenty, nie wypełniając ani nie wypełniając wielokąta. Wielokąt wypełni się i wypełni (nie to, czego chcemy), jeśli wielokąt można uzupełnić prostą linią w jednym z ośmiu kierunków kardynalnych lub międzysercowych. W przeciwnym razie zachowuje się jak PolygonHollow, co pozwala zaoszczędzić jeden bajt.

Kolejność znaków została wybrana, aby wymagać tylko ruchów poziomych od punktu końcowego jednego do początku następnego. Oto przebieg kursora:

PowerShell v2 +, 138 128 114 112 106 105 bajtów (LICTD)

"L1    IIIII1 CCCC1TTTTT1DDDD
$("L11 I1  C11 T1  D   D
"*3)LLLLL1IIIII1 CCCC1  T1  DDDD"-replace1,'     '

Chodzi o to, aby zmaksymalizować odstępy między literami, abyśmy mogli uzyskać powtarzane kompresje.

Pożycza sztuczkę deduplikacji w środkowym rzędzie od odpowiedzi Florenta . Zaoszczędzono 6 bajtów dzięki Benowi Owenowi , stosując mnożenie ciągów dla środkowych trzech rzędów, a dodatkowy bajt dzięki Matowi .

Dane wyjściowe wyglądają następująco przy 227 bajtach, dla zmniejszenia 53,7% -

PS C:\Tools\Scripts\golfing> .\5-favorite-letters.ps1
L         IIIII      CCCC     TTTTT     DDDD
L           I       C           T       D   D
L           I       C           T       D   D
L           I       C           T       D   D
LLLLL     IIIII      CCCC       T       DDDD

JavaScript, 110 109 bajtów (chmurka)

` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))

console.log(
` CCCC5L9 OOO6U3U5DDDD
${x=`C9L9O3O5U3U5D3D
`,x+x+x} CCCC5LLLLL6OOO7UUU6DDDD`.replace(/\d/g,c=>" ".repeat(c))
)

Dane wyjściowe to 227 bajtów:

 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

ES6 (JavaScript), 194, 181 bajtów (IGOLF / ANY)

Ten jest długi i nie jest tak naprawdę zoptymalizowany (przynajmniej jeszcze nie), ale można go zmodyfikować, aby wydrukować dowolny konkretny komunikat, zmieniając tylko dane bitmapy.

EDIT: Wymieniłem wewnętrzna zmniejszyć z mapy , użyj bitowe przesunięcie dla obicia

Grał w golfa

[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

Próbny

[0x1f73a1f,0x484610,0x49c61e,0x48c610,0x1f73bf0].map(r=>[0,1,2,3,4].map(p=>('0000'+(r>>(20-p*5)<<5).toString(2)).substr(-10).replace(/(1|0)/g,b=>' IGOLF'[(p+1)*b])).join``).join`\n`

IIIII      GGG       OOO      L         FFFFF     
  I       G         O   O     L         F         
  I       G  GG     O   O     L         FFFF      
  I       G   G     O   O     L         F         
IIIII      GGG       OOO      LLLLL     F         

Teoria

Weź list:

IIIII      
  I        
  I        
  I        
IIIII 

przekonwertować na macierz binarną (bitmapę)

11111
00100
00100
00100
11111

zrób to samo dla pozostałych 4 liter, zeskanuj wiersz, usuwając „górne” 5 bitów z każdego

11111 01110 01110 10000 11111

przekonwertować na ciąg szesnastkowy (tutaj należy użyć base36 lub nawet ASCII do wydruku)

0x1f73a1f

zastosuj ten sam algorytm do innych 4 linii, aby uzyskać mapę bitową.

Renderuj w odwrotnej kolejności.

PHP, 107 104 102 94 86 bajtów

Ok, jestem pewien, że mam teraz najmniejsze możliwe źródło tej metody. Napisałem skrypt do generowania, a następnie gzipowania każdej możliwej kombinacji pięciu liter. Istnieją dwa rozwiązania, które pasują do najkrótszego skompresowanego - LODIC i LDOIC. Idę z tym pierwszym, ponieważ fajniej jest powiedzieć.

Źródło:

<?=gzinflate(base64_decode('81GAA39/fwjDBQggLE8QgDCdgYDLB6EYioGqoRisHkrTSCUIEOtWAA'));

Wynik:

% php foo.php
L          OOO      DDDD      IIIII      CCCC
L         O   O     D   D       I       C
L         O   O     D   D       I       C
L         O   O     D   D       I       C
LLLLL      OOO      DDDD      IIIII      CCCC

05AB1E , 44 bajty

To było zabawne.
Czuję, że muszę wrócić i spróbować pograć w golfa, kiedy będę miał czas.

Wykorzystuje kodowanie CP-1252 .
Zainspirowany carusocomputing za odpowiedź .

ECOIH

‘ÓÑOIHH‘SðýJ3×S•Td<UÕ‘áÓ?¢tWvkÔÚ•S)øü×J3äû»

Wypróbuj online!

Wyjaśnienie

‘ÓÑOIHH‘popycha sznur "ECOOIHH".

SðýJ3×Słączy ciąg przez spacje, trzy razy go powtarza i konwertuje na listę.
Wynikowa lista to ['E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H', 'E', ' ', 'C', ' ', 'O', ' ', 'O', ' ', 'I', ' ', 'H', ' ', 'H'].

•Td<UÕ‘áÓ?¢tWvkÔÚ•popycha numer 564631055513119191317171314619131717500.

S)ø zamyka listę i numer razem.

ü×Jwykonuje parowanie ciągów znaków i łączy je razem.
Wynikiem jest ciąg EEEEE CCCC OOO IIIII H HE C O O I H HEEEE C O O I HHHHH.

3äû»dzieli to na 3 części, dodaje pierwszą i drugą część w odwrotnej kolejności i łączy znak nowej linii.

JavaScript (ES6), 96 bajtów (DIOCL)

`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d))

Chodzi tutaj o to, aby nie tylko identyczne trzy środkowe linie, ale także uczynić pierwszą linię prawie identyczną z ostatnią. Ponieważ są tylko 4 litery, które idealnie pasują do tego opisu CDIO, Ljest następną najlepszą opcją, ponieważ wymaga tylko 4 dodanych znaków na końcu łańcucha.

Podobnie jak w przypadku odpowiedzi Florenta , jest to fragment, który zwraca wynik. Dodaj 3 bajty, jeśli musi to być funkcja.

Testowy fragment kodu

console.log(`${x="DDDD6IIIII6OOO7CCCC5L"}
${y=`D3D7I7O3O5C9L
`,y+y+y+x}LLLL`.replace(/\d/g,d=>" ".repeat(d)))

Bash + coreutils z figletem, 55440 roztworów, 112 106 bajtów każdy

 set H E L P D;for l;do figlet -f banner $l|sed "s/.//3;s/.//5;s/#/$l/g;2d;5d">$l;done;paste $@|expand -t10

Wynik:

HH EEEEE L PPPP DDDD  
HHELPPDD 
HHHHH EEEE L PPPP DD 
HHELPDD 
HH EEEEE LLLLL P DDDD  
                                              

Hej, mamy już program do sztuki ASCII! Transparent czcionki prawie spełnia swoje zadanie, oprócz tego, że wysyła listów 7x7. Hmm, po prostu usuńmy 3 i 5 kolumnę oraz 2 i 5 wiersz i zobaczmy, co daje ...

Okazuje się, że wiele liter zostanie wydrukowanych w wymagany sposób, a mianowicie BDEFHJLPTU Z.

Wystarczy zastąpić argumenty pierwszego zestawu poleceń dowolną kombinacją tych liter, aby nadal uzyskać poprawny wynik! Daje nam to 11 * 10 * 9 * 8 * 7 = 55440 rozwiązań, każde o długości 106 bajtów.

05AB1E , 102 90 89 69 bajtów (EOIXC)

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚúNÏŒº9¨gÚSÞ•34B2ð:2ôvy`×}J3äû»

Wypróbuj online!

Wyjście (230 bajtów):

EEEEE      OOOO     IIIII     X   X      CCCC
E         O    O      I        X X      C    
EEEE      O    O      I         X       C    
E         O    O      I        X X      C    
EEEEE      OOOO     IIIII     X   X      CCCC

69/230 = 70% kompresji

Wyjaśnienie:

Teoria polegała na wybraniu liter pionowo symetrycznych, a następnie zakodowaniu pierwszych 3 linii i ich palindromizacji. Zasadniczo zakodowałem jako {#} z {Letter} w 2 parach bajtów. Jestem pewien, że jest na to lepszy sposób.

•Cv¶ÉH&9;´ß{ø‰¿šq3d$µ_©Û¶«K>Ò±sÒ9ÍÊC4ÊÚîòvÅr葾)jM•34B
                    <decodes to>
"E5 6O4 5I5 5X1 3X1 6C4E1 9O1 4O1 6I1 8X1 1X1 6C1 4E4 6O1 4O1 6I1 9X1 7C1 4"

2ô            # Split into encoded pairs.
  vy   }      # Loop through each letter and number pair.
    `×        # Add the letter X number of times.
       J      # Join together.
        3ä    # Split into 3 parts length.
          û   # Palindromize.
           »  # Print separated by newlines.

-20 bajtów dzięki Emignie, będę na czacie, aby wkrótce zadać kilka pytań;).

JavaScript ES6, 168 bajtów, CHAMP

Możemy przestać szukać facetów, mamy CHAMPtutaj

f=_=>
` C3cHaHdA2dMaMcP3
CgHaHcAaAcMM MMcPaP
CgH4cA4cM M McP3
CgHaHcAaAcMaMcP
 C3cHaHcAaAcMaMcP`.replace(/[a-z\d]/g,(a,i,c)=>+a?c[i-1].repeat(a):' '.repeat(parseInt(a,36)-7))

a.innerHTML = f()

<pre id=a>

Brainf *** 512 411 bajtów

Lepsze ponowne wykonanie:

Ten lepiej radzi sobie z optymalizacją taśmy, poświęcając znaki konfiguracji do drukowania znaków. Taśma w tym wygląda 'C' 'E' ' ' 'F' 'I' 'L' '\n', poprawiając wydajność. Wybrałem je, ponieważ brakuje im wewnętrznych przestrzeni, dzięki czemu nie muszą chodzić tam iz powrotem między postacią a przestrzenią więcej niż to konieczne

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

Jeśli chcesz przeczytać, co robi:

Set the tape with 67,69,32,70,73,76,10
++++++++[>+++++++++>+++++++++>++++>+++++++++>+++++++++>+++++++++>+<<<<<<<-]>----->--->>-->+>++++>++<<<< 
.<<....>>.....<.....>.....>.....<.....>>.....<<.....>>>.>.<<<<<< First Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<<<< Second Line
.>>.........<....>......>....<........>>.<<.......>>>.>.<<<<<< Third Line
.>>.........<.>.........>.<...........>>.<<.......>>>.>.<<<< Fourth Line
.<<....>>.....<.....>.....>.<.........>>.....<<.....>>>..... Fifth Line

Wynik:

 CCCC     EEEEE     FFFFF     IIIII     L
C         E         F           I       L
C         EEEE      FFFF        I       L
C         E         F           I       L
 CCCC     EEEEE     F         IIIII     LLLLL

Poprzednie zgłoszenie:

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

Wybrałem ABCDE, ponieważ znacznie ułatwia to ustawienie taśmy wyjściowej, ale czas i znaki, które zmarnowałem, przechodząc od litery do „” dla całej ujemnej przestrzeni wewnątrz A, B i D oraz umieszczenia myślę, że koniec na końcu taśmy mnie zabił.

Skończyłem z taśmą, która miała wartości, 0 0 'A' 'B' 'C' 'D' 'E' ' ' \na następnie stamtąd wyprowadzała

++++++++[>++++<-]>[>++>++>++>++>++>+<<<<<<-]>+>++>+++>++++>+++++>>++++++++++     This all sets up the tape as 0 0 A B C D E ' ' '\n'
<.<<<<<...>>>>>......<<<<....>>>>.......<<<....>>>.....<<....>>......<.....>>.<<<<<< First Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Second Line
.....>>>>>.....<<<<....>>>>......<<<.>>>.........<<.>>...<<.>>.....<....>>.<<<<<< Third Line
.>>>>>...<<<<<.>>>>>.....<<<<.>>>>...<<<<.>>>>.....<<<.>>>.........<<.>>...<<.>>.....<.>>.<<<<<< Fourth Line
.>>>>>...<<<<<.>>>>>.....<<<<....>>>>.......<<<....>>>.....<<....>>......<..... Last Line

Wynik:

 AAA      BBBB       CCCC     DDDD      EEEEE
A   A     B   B     C         D   D     E
AAAAA     BBBB      C         D   D     EEEE
A   A     B   B     C         D   D     E
A   A     BBBB       CCCC     DDDD      EEEEE

Vim, 116 bajtów 99 bajtów

ELITC

Grał w golfa poniżej 100 z pomocą @DrMcMoylex.

9i59Yo191919171
E L I T CPqqjx:%s/\d/\=repeat('"',submatch(0))
q8@q3bi  Y7w.PP4rE{wl4r 22wl.2x

Zawiera znaki niedrukowalne, więc dodałem je poniżej (styl Vima), abyś mógł je zobaczyć.

9i5^[9^AYo191919171
E L I T C^[Pqqjx:%s/\d/\=repeat('^R"',submatch(0))
q8@q3bi  ^[Y7w.PP4rE{wl4r 22wl.2x

TryItOnline!

Zasadniczo używa tego samego dekodowania, co galaretka. Użyłem liter, w których mógłbym (mam nadzieję) powtórzyć górę na dole, a wszystkie środki byłyby takie same. Po utworzeniu górnych, dolnych i środkowych elementów edytuję znaki, aby je poprawić:

1. Dodaj dwa spacje do I (więcej na ten temat poniżej)
2. Dodaj dwa spacje do litery T.
3. Dodaj pasek litery E.
4. Usuń górną część litery L.
5. Usuń dolną część litery T (i usuń 2 spacje)

Muszę dodać dwie spacje do I, ponieważ nie pozwoliłem na liczby dwucyfrowe (więc nie potrzebowałbym separatora. Prowadzi to do 9 spacji, gdzie potrzebuję 11.

MATL , 49 bajtów

5:lyI&(g84*t0*ytP+g73*yy!qy5XyPl5LY(90*yy!P12-&hc

Wypróbuj online!

To tworzy litery TIHZN:

TTTTT     IIIII     H   H     ZZZZZ     N   N
  T         I       H   H        Z      NN  N
  T         I       HHHHH       Z       N N N
  T         I       H   H      Z        N  NN
  T       IIIII     H   H     ZZZZZ     N   N

Wyjaśnienie

Tjest stosunkowo łatwy do zbudowania od podstaw. Imożna uzyskać zasadniczo jako Tplus jego odbicie pionowe. Hjest Itransponowany. Njest Ztransponowane i odbijane pionowo.

5:        % Push [1 2 3 4 5]
lyI&(     % Write [1 ;2; 3; 4 ;5] in the third column, filling with zeros.
          % This gives the shape of the 'T'
g84*      % Change nonzeros into 84 (ASCII for 'T'). Zeros will be displayed
          % as spaces
t0*       % Duplicate and multiply by zeros. This gives the separator
y         % Duplicate from below: pushes the 'T' again
tP+       % Duplicate, flip vertically, add. Gives the shape of the 'I'
g73*      % Change nonzeros into 73 (ASCII for 'I')
yy        % Duplicate separator and 'I' array
!         % Transpose. Gives the shape of the 'H'
q         % Subtract 1. Transformss 73 into 72 (ASCII for 'H'), and 0 into -1,
          % which will later be changed back into 0 when converting to char
y         % Duplicate separator
5XyP      % Size-5 identity matrix flipped vertically: gives slash of the 'Z'
l5LY(     % Fill first and last rows with ones. Gives the shape of the 'Z'
90*       % Multiply by 90 (ASCII for 'Z')
yy        % Duplicate separator and 'Z' array
!P        % Transpose and flip vertically. Gives shape of the 'N'
12-       % Subtract 12 to yield ASCII code for 'N'. 0 is converted to -12
&h        % Concatenate the nine arrays horizontally
c         % Convert to char. Implicitly display

V , 62 , 53 bajtów

iC±  I· D³ Dµ O³ O¸ Z3ñYp$XñS ´Cµ µIµ ´D· ³O¶ µZYHP

Wypróbuj online!

To daje C I D O Z:

 CCCC     IIIII     DDDD       OOO      ZZZZZ
C           I       D   D     O   O        Z
C           I       D   D     O   O       Z
C           I       D   D     O   O      Z
 CCCC     IIIII     DDDD       OOO      ZZZZZ

Perl, 109 bajtów (ABCDE)

Uwaga : zawiera znaki niedrukowalne, które zostały tu ukryte dla ułatwienia testowania, xxdzrzut poniżej.

$_="\x0e\x1e\x0f\x1e\x1f
\x11\x11\x10\x11\x10
\x1f\x1e\x10\x11\x1e
\x11\x11\x10\x11\x10
\x11\x1e\x0f\x1e\x1f";s!.!(eval'(sprintf"%5b",ord$&)=~y/01/ '.(A..E)[$i++%5].'/r').$"x5!ge;print

Przechowuje binarną reprezentację pozycji liter jako liczbę, a następnie rozpakowuje z powrotem do postaci binarnej, zastępując 0s spacjami is 1si odpowiednią literą, za pomocą odnośnika. Przechowywanie reprezentacji liter jest dość łatwe, ale ich wymiana okazała się trudniejsza niż się spodziewałem. Jestem pewien, że są lepsze sposoby na zrobienie tego, więc mogę kontynuować grę.

Aby ponownie utworzyć plik, uruchom xxd -r > favourite-letter.pl, wklej poniżej i naciśnij Ctrl+ D:

0000000: 245f 3d22 0e1e 0f1e 1f0a 1111 1011 100a  $_="............
0000010: 1f1e 1011 1e0a 1111 1011 100a 111e 0f1e  ................
0000020: 1f22 3b73 212e 2128 6576 616c 2728 7370  .";s!.!(eval'(sp
0000030: 7269 6e74 6622 2535 6222 2c6f 7264 2426  rintf"%5b",ord$&
0000040: 293d 7e79 2f30 312f 2027 2e28 412e 2e45  )=~y/01/ '.(A..E
0000050: 295b 2469 2b2b 2535 5d2e 272f 7227 292e  )[$i++%5].'/r').
0000060: 2422 7835 2167 653b 7072 696e 74         $"x5!ge;print

Stosowanie

perl favourite-letter.pl
 AAA      BBBB       CCCC     DDDD      EEEEE     
A   A     B   B     C         D   D     E         
AAAAA     BBBB      C         D   D     EEEE      
A   A     B   B     C         D   D     E         
A   A     BBBB       CCCC     DDDD      EEEEE     

Python 2, 124 bajty

d,i,o,c,l,s,n='DIOCL \n'
T=d*4+s*6+i*5+s*6+o*3+s*7+c*4+s*5+l
M=d+s*3+d+s*7+i+s*7+o+s*3+o+s*5+c+s*9+l+n
print T+n,M,M,M,T+l*3

Podobne do mojej innej odpowiedzi , ale z lepszymi wyborami liter. Wyprowadza to:

DDDD      IIIII      OOO       CCCC     L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
D   D       I       O   O     C         L
DDDD      IIIII      OOO       CCCC     LLLL

Befunge, 120 bajtów (CKYTF)

Źródło

#&49+14489+56*1449135*44711425*:12p9138*7+:89+:56*55*v_@
-1g05$$_\#!:2#-%#16#\0#/g#20#,g#+*8#4<80\9*2p06%5p05:<^:,g2!%5:

Wynik

  CCCC     K   K     Y   Y     TTTTT     FFFFF
 C         K  K       Y Y        T       F
 C         KKK         Y         T       FFFF
 C         K  K        Y         T       F
  CCCC     K   K       Y         T       F

Wypróbuj online!

W przypadku, gdy ma to znaczenie, powinienem zaznaczyć, że moje wyjście ma wiodące miejsce w każdej linii. Reguły wyraźnie tego nie zabraniały, więc mam nadzieję, że to w porządku. Jeśli nie, proszę uznać to za wpis niekonkurujący.

Wyjaśnienie

Litery tego słowa są kodowane jako prosta sekwencja 25 liczb całkowitych, przy czym każda liczba całkowita jest reprezentacją binarną 5 pikseli. Ponieważ Befunge wymaga wykonania obliczeń w celu utworzenia dowolnej liczby całkowitej większej niż 9, litery zostały wybrane tak, aby zminimalizować liczbę wymaganych obliczeń, i uporządkowane, aby potencjalne powtarzające się wartości mogły być powielane, a nie przeliczane.

Musimy także przechowywać wartość ASCII każdej litery, przesuniętą o 32, w tablicy indeksowanej przez moduł 5 indeksu malejącego (czyli 0 4 3 2 1 ...). Przyczyną przesunięcia o 32 jest to, że wartość można pomnożyć przez bit piksela (1 lub 0), a następnie dodać do 32, aby uzyskać wymaganą spację lub znak.

Ta tablica wartości liter jest przechowywana w pierwszych 5 bajtach kodu, więc jest łatwo dostępna. Wpłynęło to również na wybór liter, ponieważ wartości te musiały mieć znaczenie, gdy interpretowano je jako sekwencję kodu. To jest sekwencja #&49+. W #przeskakuje &i 49+po prostu wypycha 13 na stos, który następnie jest ignorowany.

Rubin, 110 107 102 bajtów (DOCIL)

puts a=?D*4+(t=' '*7)+?O*3+t+?C*4+(s=' '*5)+?I*5+s+?L,['D   D'+s+'O   O'+s+?C+' '*11+?I+t+?L]*3,a+?L*4

Wydruki

DDDD       OOO       CCCC     IIIII     L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
D   D     O   O     C           I       L
DDDD       OOO       CCCC     IIIII     LLLLL

EDYCJA: Zapisano niektóre znaki, unikając joini przenosząc różne rzeczy

Befunge-98 , 109 98 bajtów (FUNGE / ANY)

:5%!2>j#4_;\$&\#;\:0`!#@_:::'@/'@*-\'@/2%*' +,:'@/:2/-'@*-\1+:5%!2>j#4_;' 3k:4k,#;:55*%!2>j#4_;a,;

Wypróbuj online!

Wprowadzanie (115 znaków):

2022 1141 1134 935 2021 102 1141 1262 103 101 998 1141 1390 1639 997 102 1141 1646 1127 101 102 949 1134 935 2021 0

Dane wejściowe to całkowita liczba liczb binarnych w formacie, w aaaaabbbbbbktórym aaaaaodwrócona mapa znaku do wydrukowania (na przykład drugi wiersz w N to NN N, więc maska ​​jest 10011), i bbbbbbto znak ascii do wydrukowania, minus 32 .

Stworzyłem również program befunge-98, aby utworzyć moje dane wejściowe:

4k~44p34p24p14p04p          v
+1.+-**244g4%5\**88_@#`0:&::<

Wypróbuj online!

Dane wyjściowe (255 znaków):

FFFFF     U   U     N   N      GGG      EEEEE     
F         U   U     NN  N     G         E         
FFFF      U   U     N N N     G  GG     EEEE      
F         U   U     N  NN     G   G     E         
F          UUU      N   N      GGG      EEEEE     

(255 - (115 + 98)) / 255 = 16% kompresji

Wyjaśnienie:

:5%!2>j#4_;\$&\#;\:0`!#@_     Get input if it is available, else end program
:::'@/'@*-\'@/2%*' +,         Output the current input character (or a space,
                              if the mask dictates so)
:'@/:2/-'@*-                  Throw away current mask bit
\1+                           Swap loop iterator to top of stack, increment it
:5%!2>j#4_;' *3k:4k,#;        If iterator % 5 == 0, print five spaces
:55*%!2>j#4_;a,;              If iterator % 25 == 0, print newline character

Jest to prawdopodobnie dość golfa; Prawie nigdy nie zastanawiałem się nad potencjalnymi obniżkami.

Teoretycznie może to wydrukować dowolną sekwencję sztuki ascii 5x5.

Dzięki Jamesowi Holdernessowi za pomoc w wydostaniu się z potrójnych cyfr!

C #, 290 279 267 265 bajtów

Edycja: Zapisano 12 bajtów dzięki @milk! I jeszcze 2 dzięki @TheLethalCoder

Gra w golfa:

void F(){string g="     ",h="H   H",A="A   A",B=h+"|"+A;Func<string,string>j=a=>a.Replace("|",g)+"\n";Console.Write(j(" SSSS|"+h+"| AAA |RRRR |PPPP")+j("S    |"+B+"|R   R|P   P")+j(" SSS |HHHHH|AAAAA|RRRR |PPPP")+j("    S|"+B+"|R  R |P")+j("SSSS |"+B+"|R   R|P"));}

Nie golfowany:

public void F()
{
  string g = "     ", h = "H   H", A = "A   A", B = h + "|" + A;
  Func<string, string> j = a => a.Replace("|", g) + "\n";
  Console.Write(j(" SSSS|" + h + "| AAA |RRRR |PPPP") +
  j("S    |" + B + "|R   R|P   P") +
  j(" SSS |HHHHH|AAAAA|RRRR |PPPP") +
  j("    S|" + B + "|R  R |P") +
  j("SSSS |" + B + "|R   R|P"));
}

Wyjścia:

 SSSS     H   H      AAA      RRRR      PPPP
S         H   H     A   A     R   R     P   P
 SSS      HHHHH     AAAAA     RRRR      PPPP
    S     H   H     A   A     R  R      P
SSSS      H   H     A   A     R   R     P

Stax , 33 bajty „BCDEO”

┌☼&.àτ▲█╟;c♦▌ΩÅ╡≤♫¿(┌▲▲≡3*╤J s*è«

Uruchom i debuguj

Wybrałem to litery

• mieć symetrię pionową
• którego środkowe trzy kolumny są identyczne

Te właściwości oznaczają, że każda litera może być reprezentowana przez siatkę 3x3. Oto 9 regionów reprezentowanych przez cyfry.

12223
45556
78889
45556
12223

Rozważ literę „B”. To może być reprezentowana przez 3 cyfry ósemkowe: 656. Każda cyfra zawiera trzy bity, które kontrolują, które regiony są włączone dla tej litery. Ta technika działa również w przypadku „CDEO”.

Program po rozpakowaniu, niepolowaniu i komentowaniu wygląda tak.

"!^*14>G2eo"!   crammed integer literal             [63672, 54545, 64565]
|p              palindromize                        [63672, 54545, 64565, 54545, 63672]
m               for each, run this and output...    
  E             extract decimal digits to array     [6, 3, 6, 7, 2]
  `)"+0`        compressed string literal           "BCDEO"
  \             zip arrays                          [[6, 66], [3, 67], [6, 68], [7, 69], [2, 79]]
  {             map array using block               
    E           explode array                       6, 66
    Z\          tuck a zero under, and make pair    6, [0, 66]
    :B          custom base convert                 [66, 66, 0] 
    3)          pad to length 3                     [66, 66, 0]
    3O\         tuck a one under a 3 and pair       [66, 66, 0], [1, 3]
    :B          repeat elements corresponding times [66, 66, 66, 66, 0]
    A(          pad right to length 10              [66, 66, 66, 66, 0, 0, 0, 0, 0, 0]
  m

Uruchom ten

Python 3, 234 228 227 166 bajtów (chmurka):

import base64,gzip;b=b'ABzY86gn$d0{>HR1_A{T@KJyRe}8`nBNU1i6kLFS%Nec$q1YdaQ51tPO;sx(oDBkK&Q=Hwg(wC)8vxUXJX_-c000';print(gzip.decompress(base64.b85decode(b)).decode())

Wydruki:

 CCCC     L          OOO      U   U     DDDD
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
C         L         O   O     U   U     D   D
 CCCC     LLLLL      OOO       UUU      DDDD

Python 3, 178 bajtów

e,f,i,t,h,s='EFITH '
p=print
S=s*5
D=i+s*9+t+s*7
A=e*5+S
F=S+i*5+S
B=e+s*9+f+s*11+D+h+s*3+h
C=h+s*3+h
p(A+f*5+F+t*5+S+C)
p(B)
p(e*4+s*6+f*4+s*8+D+h*5)
p(B)
p(A+f+s*4+F,s+t+s*7+C)

Nie wygra, ale nie używa żadnej kompresji. To sprawia, że:

EEEEE     FFFFF     IIIII     TTTTT     H   H
E         F           I         T       H   H
EEEE      FFFF        I         T       HHHHH
E         F           I         T       H   H
EEEEE     F         IIIII       T       H   H

Każda pomoc jest mile widziana, prawdopodobnie coś przeoczyłem. Nie używałem Pythona 2, ponieważ nie możesz tego zrobić p=print, a to oszczędza 17 bajtów. Wypróbuj na repl.it.

Rubinowy, 101 bajtów (TIFLE)

"o@h@u".bytes{|i|k=3+i%2;puts "%-10s"*5%"TIFLE".chars.map{|j|i/=2;(i/16>i%2*3?'  ':'')+j+j*k*(i%2)}}

TTTTT     IIIII     FFFFF     L         EEEEE
  T         I       F         L         E
  T         I       FFFF      L         EEEE
  T         I       F         L         E
  T       IIIII     F         LLLLL     EEEEE

Wybrałem litery wymagające jednego bloku liter (o długości 1,4 lub 5 liter) w każdej linii. F, L i E są wyrównane do lewej, ale T i I wymagają spacji wiodących, na których drukowana jest jedna litera (część pionowa). Kod dodawania tych spacji wygląda na to, że można go ulepszyć.

bez golfa

"o@h@u".bytes{|i|               #for each byte (64 always set, 32...2 bits set for horiz bar, 1 bit=length of bar)
   k=3+i%2                      #decode least sig. bit for no of chars printed if a 1 is found
   puts "%-10s"*5%              #puts "%-10s%-10s%-10s%-10s%-10s" format string (expects array of subsitutes)
     "TIFLE".chars.map{|j|      #for each letter 
        i/=2                    #halve i
        (i/16>i%2*3?'  ':'')+   #if i large enough and i%2 zero, add leading space (or T and I)
        j+j*k*(i%2)             #print the letter once, then additional letters if bar required.
     }
}

C 176 bajtów

Jeśli dozwolone są wartości niejawne, możliwe jest odcięcie kolejnych 8 bajtów.

#define C ,//11 bytes
#define R(r)r r r r r//21 bytes
T(int l){int c=324;printf(R(R("%c")R(" "))"\n" R(R(C(++c,l>>=1)&1?c/5:32)));}//77 bytes
f(){T(67010460);T(34702434);T(66160574);T(34702434);T(67010466);}//65 bytes

Wyjście: EDCBA

EEEEE     DDDD       CCCC     BBBB       AAA      
E         D   D     C         B   B     A   A     
EEEEE     D   D     C         BBBB      AAAAA     
E         D   D     C         B   B     A   A     
EEEEE     DDDD       CCCC     BBBB      A   A     

Jak to działa: Makro R po prostu powtarza fragment kodu 5 razy. Biorąc pod uwagę, jak często pojawiają się piątki w tym problemie, bardzo przydatne. Teraz: oto, co robi T (int). T przyjmuje liczbę całkowitą i używa jej jako pola bitowego, aby określić, gdzie drukować litery i gdzie należy drukować białe znaki. Na przykład, jeśli podane T(0b11111111100111111110011100), to będzie wyjście: EEEEE DDDD CCCC BBBB AAA. Stopniowo odlicza, jaką literę drukuje. Najpierw wypisuje E, następnie D, następnie C, a następnie B, a następnie A. Wywołanie f () spowoduje wydrukowanie całej rzeczy.

Partia, 135 bajtów (DOCILe)

@set b=     
@set s=@echo DDDD%b%  OOO%b%  CCC%b% IIIII%b%L
@set t=@echo D   D%b%O   O%b%C%b%%b% I%b%  L
%s%
%t%
%t%
%t%
%s%LLLL

Uwaga: pierwsza linia kończy się 5 spacjami.

GRZMOTNĄĆ, 95, 111 bajtów (EBASH)

Grał w golfa

base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

Wyjaśnienie

Base64 przez surowy strumień bajtów LZMA

Próbny

>base64 -d<<<4ADlADhdACLpBDSMnNdRTj0Ob2qBPVT3HkdMRZzZ3kL+yIb6mhkz06EM+KOspSDy2EBoUKKL6pfwNo0akV0zAA==|xz -dqFraw

EEEEE     BBBB       AAA       SSSS     H   H
E         B   B     A   A     S         H   H
EEEE      BBBB      AAAAA      SSS      HHHHH
E         B   B     A   A         S     H   H
EEEEE     BBBB      A   A     SSSS      H   H

Zrzeczenie się

Tak, jestem w pełni świadomy, że to nie jest tak naprawdę przenośne, dlatego zapłaciłem bajt, aby ukryć ostrzeżenia xz za pomocą opcji -q w pierwszym przypadku> :)

Python 2, 208 194 193 bajtów

To mój pierwszy golf w kodzie;) Zabawne

for i in range(0,25,5):
 for c,p in {'M':18732593,'O':15255086,'N':18667121,'T':32641156,'Y':18157700}.items():
  print format(p,'025b')[i:i+5].replace('0',' ',).replace('1',c)+'   ',
 print

Wynik:

Y   Y    M   M    TTTTT     OOO     N   N
 Y Y     MM MM      T      O   O    NN  N
  Y      M M M      T      O   O    N N N
  Y      M   M      T      O   O    N  NN
  Y      M   M      T       OOO     N   N

Korzystanie ze słownika niszczy porządek sortowania liter, ale nie było to wymagane

perl 94 bajty.

Pierwsze 4 liter ( D, O, I, C) są wybrane w szczególności mieć górne i dolne linie podobne, a środkowe podobne. Ponieważ nie ma innej podobnej litery, wybrałem „L”, aby móc zastosować ten sam algorytm i dodać brakujące 4L.

for(($a="D5 6O3 6I5 6C4 5L")."
","D 3D 5O 3O 7I 7C 9L
"x3,$a."4L
"){s/(.)(\d)/$1x$2/eg;print}

Zaoszczędziłem trochę dodatkowych bajtów, zastępując \nw kodzie prawdziwą nową linią.

Wynik:

DDDD       OOO      IIIII      CCCC     L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
D   D     O   O       I       C         L
DDDD       OOO      IIIII      CCCC     LLLLL