Wydrukuj obraz Super Mario

28

Jest to problem dotyczący Luogu OJ. Postanowiłem opublikować go tutaj, ponieważ w Luogu OJ wiele osób, w tym ja i mój przyjaciel, jest zainteresowanych tym, jak rozwiązać ten problem wśród jak najmniejszej liczby postaci.

Twoim zadaniem jest wygenerowanie następującej grafiki ASCII:

               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############

To jest golf golfowy, więc wygrywa najkrótszy program.

code-golf  ascii-art  kolmogorov-complexity 
— Wysoce radioaktywny
źródło
7
Czy dozwolone są dodatkowe białe znaki (na przykład w celu utworzenia prostokąta znaków) po prawej stronie? co z końcowym znakiem nowej linii?
— Level River St
@LevelRiverSt Przepraszamy za późną odpowiedź. Tak, OJ automatycznie usuwa wszystkie końcowe białe znaki / tab / nowa linia i wszystkie białe znaki / tab po prawej stronie.
— HighlyRadioactive

Odpowiedzi:

22

Brainfuck , 1347 bajtów

Dlaczego robię to sobie

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

Wypróbuj online!

Wersja „czytelna”:

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

<<
>...............>............>>.
<<<...............<....<....>.<.>>>>>.
<<<.............<.<..>...<.....>..<....>>>>>.
<<<.............<...<.......>......>..<<<++[->>>............<...<<]>>>>>>.
<<<................<<...........>>.....<<<++[->>>..........<.<...>.<<]>>>>>>.
<<<...............<..>>.<<.......>.......<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.
<<<............<....>>.......<<......>...<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.
<<<...........<<...>><.>>...<<<.>>>....<<<.>>>.<<...<....>>..........<.<.>.<.>.>..........<.<.>.<.>.>>>>.
<<<...........<<....>>>..........<<..<.....>>...........<...>............<...>>>>.
<<<...........<<....>>>....<....>.....<<<....>>>>>.
<<<.....<<<++[->>>........<....<<]>>>>>>.
<<<...<<<++[->>>........<......<<]>>>>>>.
<<<<<<+++++++[->>........<<]>>......>>>>.
<<<<<<+++[->>.<...>.<......>.<.>.<<]>>.>>>..................<<<.>>>>.
<<<<<<+++++++[->>......<<]>>.>>>..................<<<.>>>>.
<<<<<<+++[->>.<..>.<....>.<....>.<<]<+++++[->>>....<<<]>>>>>>>.
<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++[->>.<.....>.<......>.<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++[->>.<.>.<..>.<....>.<..>.<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++++++[->>......<<]>>>....<............
— Przypadkowy facet
źródło
1
To nic niezwykłego. Czy sam to zaprojektowałeś, czy korzystałeś z programu, który Ci pomoże?
— jaaq
4
Zrobiłem to sam. Wiem też, że istnieje prawdopodobnie lepszy i krótszy sposób, aby to zrobić, ale bolesne było ciągłe rysowanie mario w pieprzeniu mózgu ręcznie.
— Przypadkowy facet
5
Z drugiej strony wiesz, że absolutnie niewiarygodne nikt nie będzie próbował wymyślić konkurencyjnej krótszej wersji: D
— CD001
4
@ CD001 czy to wyzwanie?
— Benjamin Urquhart
1
@Evorlor dobrze są kompilatory, makra i skrypty, które potrafią przetłumaczyć czytelne instrukcje na pieprzenie mózgu. Przez „ręcznie” miałem na myśli to, czy on sam zbudował kod, co faktycznie zrobił. Uznanie za to.
— jaaq
16

T-SQL, 322 298 288 bajtów

SELECT CONCAT('',DECOMPRESS(CAST('H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA='as XML).value('.','varbinary(max)')))

Używa kompresji G-Zip wbudowanej w SQL 2016 i później, wraz z kodowaniem Base64, zobacz ten post z poradami, aby uzyskać szczegółowe informacje .

W SSMS albo będziesz musiał wyprowadzać tekst jako majsterkowanie w ograniczeniach znaków SSMS w ustawieniach, albo po prostu skopiuj i wklej dane wyjściowe do okna kodu:

wprowadź opis zdjęcia tutaj

EDYCJE : Zapisano 24 bajty z lepiej skompresowanym łańcuchem dzięki @someone; zapisano 10 bajtów z niejawną konwersją przy użyciu CONCAT, dzięki @digscoop.

— BradC
źródło
2
Myślę, że mają krótszy ciąg base64 GZIP, H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA=. Nie mogę tego przetestować, ponieważ nie mam pojęcia, jak to zrobić, ale możesz lub nie możesz pominąć =.
— mój zaimek to monicareinstate
@someone Dzięki, ten ciąg działa (potrzebuje =) i oszczędza 24 bajty; zgadnij, że moja procedura kodowania jest daleka od ideału.
— BradC
1
Możesz użyć zmiennej bezimiennej i niejawnej konwersji, aby ją nieco skrócić. Spróbuj: DECLARE @ XML='H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA='SELECT CONCAT('',DECOMPRESS(@.value('.','varbinary(max)')))
— digscoop
Dzięki, @digscoop, zaoszczędziłem 10 bajtów. Użyłem CONCATlewy, ale nie zmiennej XML, ponieważ
— dodałoby
12

PHP , 176 155 bajtów

-21 bajtów dzięki super skompresowanemu ciągowi Ryana Moore'a .

Ta wersja wykorzystuje surowe dane wyjściowe gzdeflate i zawiera niezadrukowane dane binarne, więc sam kod i link TIO nie mogą być tutaj zamieszczone, ale oto zrzut heksowy :

000000  3c 3f 3d 67 7a 69 6e 66 6c 61 74 65 28 27 a5 91
000010  81 06 04 21 00 44 01 e8 2b e2 01 71 ef ff 3f ef
000020  5c 91 76 f6 64 57 0f 31 c6 98 a6 ea 95 b6 50 c2
000030  03 50 c5 ab 83 0e 47 41 4d 1b 1c d0 a9 e9 86 2c
000040  35 70 62 38 a8 84 cc 38 34 06 35 41 24 64 c9 c5
000050  6d 40 e7 55 5c fd a5 6d fd 00 54 9f 5f 5e b5 4d
000060  40 d5 a7 2f 37 d3 f3 53 ef 1f b3 0e 22 e2 90 2e
000070  14 8e 28 a8 d8 41 b6 ea 73 e3 55 fb df b8 a2 3a
000080  8e ad 4a de 6d ef 0f 16 cd cb ba 9d ca e8 59 eb
000090  b2 8a 9d 3a 6d 5d f8 02 27 29 3b

Dzięki @dzaima , oto TIO, które używa bash do utworzenia i uruchomienia tego pliku: Wypróbuj online!

To w zasadzie odwraca deflację i drukuje wynik. Zapisz go jako plik binarny, a następnie uruchom go w następujący sposób:php mario.php

PHP , 239 216 bajtów

-23 bajty dzięki super skompresowanemu ciągowi Ryana Moore'a .

<?=gzinflate(base64_decode('pZGBBgQhAEQB6CviAXHv/z/vXJF29mRXDzHGmKbqlbZQwgNQxauDDkdBTRsc0Knphiw1cGI4qITMODQGNUEkZMnFbUDnVVz9pW39AFSfX161TUDVpy830/NT7x+zDiLikC4Ujiio2EG26nPjVfvfuKI6jq1K3m3vDxbNy7qdyuhZ67KKnTptXfgC'));

Wypróbuj online!

Taki sam jak powyższa wersja, ale użyty kod wyjściowy base64_encode na wyjściu gzdeflate, więc kod jest czytelny i dostępny jest również link TIO. To w zasadzie odwraca base64 i defluje i drukuje wynik.

— Noc 2
źródło
1
Łącze TIO używające bash do prawidłowego utworzenia pliku
— dzaima
@dzaima wielkie dzięki! Nie wiedziałem, że możemy uruchamiać inne polecenia za pomocą bash w TIO.
— Night2
1
Zapisz 2 bajty dla wersji Pro lub 22 bajtów dla Semipro z pZGBBgQhAEQB6CviAXHv / Z / vXJF29mRXDzHGmKbqlbZQwgNQxauDDkdBTRsc0Knphiw1cGI4qITMODQGNUEkZMnFbUDnVVz9pW39AFSfX161TUDVpy830 / NT7x + zDiLikC4Ujiio2EG26nPjVfvfuKI6jq1K3m3vDxbNy7qdyuhZ67KKnTptXfgC
— Ryan Moore
1
@Ryan Moore Wielkie dzięki! W rzeczywistości zapisał 21 bajtów w wersji binarnej i 23 bajty w wersji do odczytu. Jak udało ci się osiągnąć tak wyższą kompresję? Czy masz jakieś specjalne narzędzie i / lub ustawienia?
— Noc 2
1
@ Night2 używam advdef od advancemame.it - używa Zopfli spróbować zillion różne opcje i zwykle robi lepszą kompresję niż regularne gzip. Problem polega na tym, że działa tylko na zawartości .gz, więc musisz zgzipować oryginał, advdef .gz, a następnie usunąć nagłówki .gz dla PHP gzinflate, aby go użyć.
— Ryan Moore
10

Bubblegum , 138 bajtów

00000000: a591 410a 0321 0003 efbe 6261 6e42 e7ff  ..A..!....banB..
00000010: cf2b b522 6e5a 6cc5 3908 2184 18bd eed4  .+."nZl.9.!.....
00000020: 8912 1e80 2ade 1db4 3b82 9a76 f794 c695  ....*...;..v....
00000030: 6ec8 7205 0e0c 0795 9019 874a 1677 1009  n.r........J.w..
00000040: 5972 717d 4363 2bae bed2 d676 00aa ff5f  Yrq}Cc+....v..._
00000050: 5eb5 0e40 d5df 2f17 e9f1 a99a 1f33 0f22  ^..@../......3."
00000060: e290 2e14 8e28 a8d8 4096 eaf1 c156 fbd7  .....(..@....V..
00000070: b8a2 f663 a992 bded edc1 a279 5ab7 5219  ...c.......yZ.R.
00000080: 3d6b 9d56 b152 a7ad 134f                 =k.V.R...O

Wypróbuj online!

— ovs
źródło
1
Dla porównania próbowałem wyprowadzić cały obraz jako pojedynczy skompresowany ciąg Charcoal, co daje 155-bajtowy program. Próba narysowania części za pomocą poleceń Węgiel faktycznie zwiększa długość.
— Neil
Ciekawy „język”, naprawdę kopie $$ 😛
— roblogic
8

Galaretka , 235 213 bajtów

“µ!æeıçȷ&#ð%ø&$dɓeñe÷Ɲ$Ƥ&ɓ'¤"' 'dd%dẎeȤdƤƬddƲdƝ‘s2⁴+Ɱ23¤żẎṣjƭƒ“Ç=ÇgƲ'€$fȤeƲ€fƈiÆf¿fÐɦÇ!×Çe2jÑþµþ¿g8i€þµþ½%4Ɲ5Ɲ2fƲ××½Ʋ;#½f¿f½Ʋ5¤6Ʋ€g¬g½i¬ⱮvØØØḳƁḳÞÞÞⱮpœßßßdœ⁾œŒŒŒdœ⁾¤o‘b50U+Ø0U‘Œṙṁ1xⱮ“&ðẏṪ¶ẏ×Ṙ⁷Ƈ⁾1Ẓṁn#’b64¤¤ị“ *#.-”Y

Wypróbuj online!

Wykorzystuje kombinację kodowania długości przebiegu i zastępowania wspólnych sekwencji długości 2 jedną cyfrą. Nie używa żadnej standardowej biblioteki kompresji, takiej jak gzip. Ogólnie ma 169 bajtów skompresowanych danych i 44 kodu.

Wyjaśnienie

Krok 1: zamień wartości w danych od 17 do 39 na wstępnie zapisane pary bajtów

“µ...Ɲ‘                     | Base-250 integer list 9, 33, 22, 101, 25, 23, 26, 38, 35, 24, 37, 29, 38, 36, 100, 155, 101, 27, 101, 28, 150, 36, 151, 38, 155, 39, 3, 34, 39, 32, 39, 100, 100, 37, 100, 209, 101, 154, 100, 151, 152, 100, 100, 153, 100, 150
       s2                   | Split into twos
             ¤ż             | Zip the following as a nilad with this:
         ⁴                  | - 16
          +Ɱ23               | - Add this to implicit range from 1 to 23
             Ẏ              | Tighten (join outermost lists)
                   ƒ“Ç...o‘ | Reduce using the following, and starting with the base-250 integer list 14, 61, 14, 103, 153, 39, 12, 36, 102, 154, 101, 153, 12, 102, 156, 105, 13, 102, 11, 102, 15, 160, 14, 33, 17, 14, 101, 50, 106, 16, 31, 9, 31, 11, 103, 56, 105, 12, 31, 9, 31, 10, 37, 52, 150, 53, 150, 50, 102, 153, 17, 17, 10, 153, 59, 35, 10, 102, 11, 102, 10, 153, 53, 3, 54, 153, 12, 103, 7, 103, 10, 105, 7, 149, 118, 18, 18, 18, 217, 143, 217, 20, 20, 20, 149, 112, 30, 21, 21, 21, 100, 30, 142, 30, 19, 19, 19, 100, 30, 142, 3, 111
                  ƭ         | - Alternate between:
                ṣ           |   - Splitting
                 j          |   - And joining

Krok 2: Dekodowanie długości przebiegu i konwersja na ciąg

b50                                 | Convert to base 50
   U                                | Reverse order of bytes
    +Ø0                             | Add 0,0
       U                            | Reverse order again (effectively the last three links add in leading zeros where needed)
        ‘                           | Increment by 1
         Œṙ                         | Run length decode
           ṁ            ¤           | Mould like the following as a nilad:
            1xⱮ        ¤            | - 1 repeated each of the following as a nilad:
             “&...#’                |   - Base-250 integer 36418435425519061363927141799858777786
                    b64             |   - Convert to base 64
                         ị“ *#.-”   | Index into " *#.-"
                                 Y  | Join ith newlines
— Nick Kennedy
źródło
7

Lateks, 452 448 bajtów

Utworzony z zastąpieniem bigramu (i jednym trygramem) zamiast programowania pętli w celu zastąpienia wielu kolejnych symboli.

\newlinechar`+\def~#1{\catcode`#1=13\lccode`~=`#1\lowercase{\def~}}~$#1#2{~#1{#2#2}}~l#1#2#3{~#1{#2#3}}\catcode`#=12$_*$[_$]{ }$^]$!^$<#$><$=>$&=$@.$:@$)-$()$?($/&lx#.$;xl'#@l"<#l`!^l|!]lv#+lc:@lw><lk#:lh`]lg'.lf.#lq#|ld<:lr<@lnfc~s{?)v}la/=li'klj^#l,js\typeout{h [[[+h >:x+` '":.d+` "c.wh"`"+!!:c.h gqgvh <*>"!! ;q;v`>[_*w` ;q;v| @f_*.[.*":|gqgv| :[[_d.| "`"+| :[^[*:+` >!>+| w!w+/&=w+g#cxrnxrnx<?sa"?sikrkkrkk&>va<,kndn<:n#,a<,xi'<.i'<.i'#,a<^=>}

LaTeX, 506 bajtów

Najprawdopodobniej będzie bardziej wydajny wariant, ale udało mi się to uzyskać ręcznie (brak wbudowanych narzędzi do kompresji w LaTeX ...). Utworzyłem małą pętlę, aby zastąpić kolejne sekwencje.

\def\|{\catcode`}\def~#1{\|#1=13\lccode`~=`#1\lowercase{\def~}}\| =12~@#1#2{\ifnum#1>0#2@{\numexpr#1-1}{#2}\fi}\|#=12~){@3}~({@4}~?{(.}~/{( }~<{@9  }~>{< }~_{>)#}~[{<#).#}~]{<#.#.#}~^{#).#@6.#.#}~!{#@{18}-#}~={@{42}#}~'{?}~&{#..#?#?#}~;{/#@9--#}~:{#@5.#@6.#}~"{#.#..#?#..#}\newlinechar`+\typeout{>/@{12}{*}+>/(#?#.+>  #..)#@5.##?+>  )#@7.@6#) _ _+>@5 @{11}.@5 @2[+>/##*@7#@7 @2]+> (#@7*@6#) @2]+>).#)*.(*.*)#?@2[+>?@9**##@5._ _+>?(*/@5*?+>  (#@8 (#+>@6#@8 @6#+@{62}#+)^!+=!+)&@{20}#+=;+):;+=;+)";+=/@{12}#}

Wyjście końcowe (obu kodów):

This is pdfTeX, Version 3.14159265-2.6-1.40.20 (TeX Live 2019) (preloaded format=pdf
latex)
 restricted \write18 enabled.
entering extended mode
(./mariocg.tex
LaTeX2e <2018-12-01>
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############
)
— Skillmon
źródło
5

Bash + coreutils + xz, 243 242 240 bajtów

base64 -d<<<4AROAJpdABBtAVsJZEAxAEVT46Z4yzQSDRh1V2s3yKKQ3CiFBCqNr55BVH/f7Qz/mkCIrVe+i4qcFSY5BEjUGbKH55TbsFibiXAoQ8LLpf0KeeR/Qj+UVG3Y3+Xx/Xt+0BI+rKPZCnr2NYt5PB4YsQBJeHbN+TCDB9VxVA5l2MZerD23kdk9GwTt9T7j2LGzPwyNGnq9XrJxWS3PWQOEtp8A|xz -qdFraw
— David Conrad
źródło
1
Podwójne cudzysłowy nie są konieczne.
— TheSola10
@ TheSola10 Dzięki! Zapisano 2 bajty.
— David Conrad
4

Keg , 2204 1012 745 bajtów

(35*| )(34*|\*)\
(35*| )(4|\#)(4|\.)\#\.\
(35*| )\#\.\.(3|\#)(5|\.)\#\#(4|\.)\
(76+| )(3|\#)(7|\.)(6|\#)  (2|(34*| )(3|\#))\
(82*| )(65+|\.)(5| )(2|(91+| )\#(3|\.)\#)\
(35*| )\#\#\*(7|\#)(7| )(2|(91+| )\#\.\#\.\#)\
(34*| )(4|\#)(7|\*)(6|\#)   (2|(91+| )\#\.\#\.\#)\
(65+| )(3|\.)\#(3|\*)\.(4|\*)\.\*(3|\#)(4|\.)(2|(91+| )\#(3|\.)\#)\
(65+| )(4|\.)(91+|\*)\#\#(5|\.)(65+| )(3|\#)(34*| )(3|\#)\
(65+| )(4|\.)(4|\*)    (5|\*)(4|\.)\
     (2|(8| )(4|\#))\
   (2|(8| )(6|\#))\
(88*2-|\#)\
(3|\#(3|\.)\#(6|\.)\#\.\#)\#(92*|\-)\#\
(67*1+|\#)(92*|\-)\#\
(3|\#\.\.\#(4|\.)\#(4|\.)\#)(54*|\#)\
(67*|\#)    \#(91+|\-)\#\
(3|\#(5|\.)\#(6|\.)\#)    \#(91+|\-)\#\
(67*|\#)    \#(91+|\-)\#\
(3|\#\.\#\.\.\#(4|\.)\#\.\.\#)    \#(91+|\-)\#\
(67*|\#)    (34*|\#)(

Wypróbuj online!

Zaoszczędzono 267 bajtów dzięki @Sriotchilism O'Zaic

Program 1012 bajtów

(35*| )(34*|\*)\
(35*| )(4|\#)(4|\.)\#\.\
(35*| )\#(2|\.)(3|\#)(5|\.)(2|\#)(4|\.)\
(76+| )(3|\#)(7|\.)(6|\#)(72*| )(3|\#)(34*| )(3|\#)\
(82*| )(65+|\.)(35*| )\#(3|\.)\#(91+| )\#(3|\.)\#\
(35*| )(2|\#)\*(7|\#)(98+| )\#\.\#\.\#(91+| )\#\.\#\.\#\
(34*| )(4|\#)(7|\*)(6|\#)(76+| )\#\.\#\.\#(91+| )\#\.\#\.\#\
(65+| )(3|\.)\#(3|\*)\.(4|\*)\.\*(3|\#)(4|\.)(91+| )\#(3|\.)\#(91+| )\#(3|\.)\#\
(65+| )(4|\.)(91+|\*)(2|\#)(5|\.)(65+| )(3|\#)(34*| )(3|\#)\
(65+| )(4|\.)(4|\*)(4| )(5|\*)(4|\.)\
(67+| )(4|\#)(8| )(4|\#)\
(65+| )(6|\#)(8| )(6|\#)\
(88*2-|\#)\
\#(3|\.)\#(6|\.)\#\.(2|\#)(3|\.)\#(6|\.)\#\.(2|\#)(3|\.)\#(6|\.)\#\.(2|\#)(92*|\-)\#\
(67*1+|\#)(92*|\-)\#\
\#(2|\.)\#(4|\.)\#(4|\.)(2|\#)(2|\.)\#(4|\.)\#(4|\.)(2|\#)(2|\.)\#(4|\.)\#(4|\.)(37*|\#)\
(67*|\#)(4| )\#(91+|\-)\#\
\#(5|\.)\#(6|\.)(2|\#)(5|\.)\#(6|\.)(2|\#)(5|\.)\#(6|\.)\#(4| )\#(91+|\-)\#\
(67*|\#)(4| )\#(91+|\-)\#\
\#\.\#(2|\.)\#(4|\.)\#(2|\.)(2|\#)\.\#(2|\.)\#(4|\.)\#(2|\.)(2|\#)\.\#(2|\.)\#(4|\.)\#(2|\.)\#(4| )\#(91+|\-)\#\
(67*|\#)(4| )(34*|\#)

Wypróbuj online!

Jest to po prostu kodowanie obrazu ascii, ale zaimplementowane w Keg

Stary program

\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \*\*\*\*\*\*\*\*\*\*\*\*\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\.\.\.\.\#\.\
\ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\.\#\#\#\.\.\.\.\.\#\#\.\.\.\.\
\ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\.\.\.\.\.\.\.\#\#\#\#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \.\.\.\.\.\.\.\.\.\.\.\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\*\#\#\#\#\#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\
\ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\*\*\*\*\*\*\*\#\#\#\#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\ \ \ \ \ \ \ \ \ \ \#\.\#\.\#\
\ \ \ \ \ \ \ \ \ \ \ \.\.\.\#\*\*\*\.\*\*\*\*\.\*\#\#\#\.\.\.\.\ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\ \ \ \ \ \ \ \ \ \ \#\.\.\.\#\
\ \ \ \ \ \ \ \ \ \ \ \.\.\.\.\*\*\*\*\*\*\*\*\*\*\#\#\.\.\.\.\.\ \ \ \ \ \ \ \ \ \ \ \#\#\#\ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\
\ \ \ \ \ \ \ \ \ \ \ \.\.\.\.\*\*\*\*\ \ \ \ \*\*\*\*\*\.\.\.\.\
\ \ \ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\ \ \ \ \ \ \ \ \#\#\#\#\
\ \ \ \ \ \ \ \ \ \ \ \#\#\#\#\#\#\ \ \ \ \ \ \ \ \#\#\#\#\#\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\
\#\.\.\.\#\.\.\.\.\.\.\#\.\#\#\.\.\.\#\.\.\.\.\.\.\#\.\#\#\.\.\.\#\.\.\.\.\.\.\#\.\#\#\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\-\#\
\#\.\.\#\.\.\.\.\#\.\.\.\.\#\#\.\.\#\.\.\.\.\#\.\.\.\.\#\#\.\.\#\.\.\.\.\#\.\.\.\.\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\.\.\.\.\.\#\.\.\.\.\.\.\#\#\.\.\.\.\.\#\.\.\.\.\.\.\#\#\.\.\.\.\.\#\.\.\.\.\.\.\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\.\#\.\.\#\.\.\.\.\#\.\.\#\#\.\#\.\.\#\.\.\.\.\#\.\.\#\#\.\#\.\.\#\.\.\.\.\#\.\.\#\ \ \ \ \#\-\-\-\-\-\-\-\-\-\-\#\
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\ \ \ \ \#\#\#\#\#\#\#\#\#\#\#\#

Wypróbuj online!

Wiem, że prawdopodobnie nie wygra żadnych konkursów, ale hej, ładnie to wygląda. Dosłownie po prostu ucieka przed każdą postacią i drukuje ją. To znaczy, można grać w golfa, ale czy nie lubisz tylko programów artystycznych w ascii?

— Jono 2906
źródło
@A_, pierwotnie próbowałem tego z generatorem, którego użyłem (nie napisałem go ręcznie), ale to nie zadziałało
— Jono 2906
— Wheat Wizard
A teraz, gdy rozumiem, jak to działa nieco bardziej, tutaj jest znacznie krótsza wersja.
— Wheat Wizard
4

JavaScript (Node.js) ,  265  264 bajtów

Zapisano 1 bajt dzięki @ Night2

Deflated.

_=>require('zlib').inflateRawSync(Buffer('pVJbDoAwCPvfKZb0b4nc/3jCRAWGOrN+qNiV8litDs2geKqCQQyQZ/inMnS8SpQRKSsYkoYw2la6ESuSpCEcq27IjPt5eDmCXFQ6jCTFl1yqYSW1/tAxzBcvp+9l6BCnJ3eqr6Wmi4H9LoHzLPNYQukd6k04bspjtA345Z7K1QDnPX2O0uKn0QcWnE13b9EoXXE1XeEtWnU12AE','base64'))+''

Wypróbuj online!

JavaScript (Node.js) , 318 bajtów

Kolejne podstawienia ciągów.

_=>[...`L=J00BP
FM1A46E.##3B
2G@;<9#7#:7#8.653*42-1.0 #`].reduce((s,c,i)=>s.split(Buffer([94-i])).join(c+`A= >9SOKQ< <N0#0H<> ?0C5;D3
13:498#653*42-1.0 #`[i]),`?T]=JT29#.\\A[O9\\[3.I?10#?0C779D.?TSYJT0*I#77 UBUJ2=8*I? UBUW3<8*.=.*[YYW9]8Z.K0#?0CK9=4=*9\\272WI7I
F;6I
AX3X3X@HV#@HA>>0L>0L>;2CVR>EZEZPRVRM^0<^0<^#RV462`)

Wypróbuj online!

JavaScript (ES7), 340 bajtów

Zgnieciony.

_=>[...'[{+SUPER~Mario!}]'+2**29].reduce((s,c)=>(l=s.split(c)).join(l.pop()),`U15555
U13#9#.~o#739}9~o397.28+S
18PP7.1ii
U13*2#18 a 335E28oa7}5.E.*39ii~P55E#9.8S~PEooE*P~o331+33~21+26r
#RRR00#6#00#
#[3[3[r#6]
9!9!9!]6]
#M3M3M#]6oor331o+9#P0{{{7..8U 6
2222r##E**]oo#0-#}.#!.97#+ iU#7}r2223a#}}U#}}~M}79#7~
8R7!.3E5*P77U11S3#8 3#+o {---[799`)

Wypróbuj online!

Lub tu:

Pokaż fragment kodu

— Arnauld
źródło
4

C (gcc) , 322 320 318 316 bajtów

-2 bajty dzięki pułapkowi cat.

f(i,c){for(i=0;c="/<q/TDQAq-QBSERDq-SGV.S,Sq/!K/QCQ*QCQq/R1W/\"QAQAQ*QAQAQq,T7V-QAQAQ*QAQAQq+CQ3A4A1SD*QCQ*QCQq+D:RE+S,Sq+D4$5Dq-T(Tq+V(Vq____RqQCQFQARCQFQARCQFQARocQq__]ocQqQBQDQDRBQDQDRBQDQD_Vq__\\$QjQqQEQFREQFREQFQ$QjQq__\\$QjQqQAQBQDQBRAQBQDQBRAQBQDQBQ$QjQq__\\$\\"[i++];)for(;c--%16;)printf(L" *.#-\n"+c/16-2);}

Wypróbuj online!

— gastropner
źródło
4

Bash + coreutils, 269 262 261 bajtów

base64 -d <<<H4sICLN9e10CA01BUklPAKVSWw6AMAj73ymW9G+J3P94wkQFhjqzfqjYlfJYrQ7NoHiqgkEMkGf4pzJ0vEqUESkrGJKGMNpWuhErkqQhHKtuyIz7eXg5glxUOowkxZdcqmEltf7QMcwXL6fvZegQpyd3qq+lpouB/S6B8yzzWELpHepNOG7KY7QN+OWeytUA5z19jtLip9EHFpxNd2/RKF1xNV3hLVp1tWPaAR8+K1RPBAAA|gunzip

Trochę trywialne - nic mądrego się tu nie dzieje. Nie jestem pewien, czy wolno mi używać gzip w ten sposób. Jeśli nie jestem, nie mam wątpliwości, że ktoś na mnie krzyczy.

(lepiej, jeśli usunę bezcelowe spacje / cytaty)

Dzięki @manatwork za zapisanie bajtu

Wypróbuj online!

— ssta
źródło
1
Cyfrowy Trauma „s wskazówka może pomóc zredukować go nieco więcej.
— manatwork
@manatwork Dzięki, to pomogło mi zoptymalizować bajt z mojej odpowiedzi.
— David Conrad
2
Możesz upuścić echopolecenie i potok, robiąc tobase64 -d<<<...|gunzip
— TheSola10
4

Python3, 921 916 752 751 539 534 476 bajtów

A oto obowiązkowa uczciwa wersja. Użyłem skryptu, aby policzyć poszczególne znaki, powinny być identyczne:

w,s,d,r=' *.#'
m='--'
n=m*5
A=d*2
B=d*3
C=d*4
D=d*5
E=d*6
F=r*2
G=r*3
H=r*4
I=r*6
J=r*42
K=w*10
L=K+w
M=L+w
N=M+w
O=w*15
P=w*4
Q=w*8
R=d+r
S=r+R+R
T=B+r
U=r+T
V=r+A
W=r+d+F+T+E
X=r+C
Y=r+E+F+D
Z=R+A+X+V
a=r+P+r+n+r
b=J+P+r
c=F+A+X+X
e=b+n+r
f=s*12
g=d*7
h=s*3
j=s*4
k=r*62
l=m*9
o=r*11
p=r*21
z='\n'
for i in"OfzOHCrdzNVGDFCzNGgINwGMGzOwDEOUKUzOFsGHNPSKSzMHhjINSKSzLThdjdsGCKUKUzLCjhhFDLGMGzLCjPjsCzNHQHzLIQIzkzUEWWrdFlrzJrlrzVXXccpzezrDYYrEazezrZFZFZazboz":print(end=eval(i))

Wypróbuj online!

Dzięki uprzejmości niesamowitych facetów w komentarzach, którzy są znacznie lepsi ode mnie!

Oto skrypt (python3) dla wszystkich innych, którzy mogą chcieć wygenerować kod i są zbyt leniwi / wydajni, aby liczyć ręcznie:

mario = '''
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############
'''

curr_char = ""
count = 0
for i in mario:
    if i == curr_char:
        count += 1
    else:
        if curr_char != '\n':

            if curr_char == ' ':
                curr_char = 'w'
            elif curr_char == '#':
                curr_char = 'r'
            elif curr_char == ".":
                curr_char = "d"
            elif curr_char == "-":
                curr_char = "m"
            elif curr_char == '*':
                curr_char = 's'

            print(curr_char + '*' + str(count), end="+")
        else:
            print(",", end="")

        curr_char = i
        count = 1

Wykorzystano lukę w Pythonie, 167 bajtów

Ponieważ nic nie powiedziano o standardowych lukach, zakradnę się tutaj, póki będę mógł. TIO z jakiegoś powodu nie lubi urllib, jeśli ktoś zna witrynę, na której można przechowywać skrypt, proszę mi o tym powiedzieć. Oczywiście skracacz linków mógłby zaoszczędzić trochę bajtów, ale nie chciałem dalej schodzić do tej dziury.

from urllib.request import *
import re
print(re.split("</?code>",str(urlopen("/codegolf//q/192715/85978").read()))[1].replace("\\n","\n")[:-1])
— jaaq
źródło
12
Jestem prawie pewien, że chodzi o standardowe luki, które mają zastosowanie, nawet jeśli nie zostały wyraźnie wymienione.
— ar4093
1
Tak, zgadzam się; ale skoro powiedział op many people, including me and my friend, are interested about how to solve this problem within the fewest characters, pomyślałem, że warto się śmiać; który pasuje do tematu programowania rekreacyjnego tego postu i części tej witryny.
— jaaq
1
Następnie weź tekst jako tekst i użyjprint(input())
— ar4093
1
Cóż, wtedy policzyłbym dane wejściowe do użytych bajtów, ponieważ pokonałoby to całe wyzwanie. Chciałem tylko pograć trochę w pułapkę „programiści nigdy nie powinni przerabiać tego, co już istnieje”. Przepraszam, jeśli przeszkadza mi mentalność zabawy w tym środowisku, wcale nie chciałem!
— jaaq
2
Nie znam Pythona, ale czy możesz zrobić m równe dwa myślniki, ponieważ każde użycie myślnika jest liczbą parzystą? Jeśli tak, możesz zapisać około 5 znaków.
— Keeta
4

MarioLANG , 3287 3286 3285 bajtów

Musiałem to zrobić dla tematu.

+++++++++++++++++++++++++++++++++++++++++++++)++++++++++++++++++++++++++++++++)+++++++++++++++++++++++++++++++++++)++++++++++++++++++++++++++++++++++++++++++++++)++++++++++)++++++++++++++++++++++++++++++++++++++++++((((...............))))...........(.(((...............)....)....(.).).(((.............).)..(...).....(..)....).(((.............)...).......(......(..............)...(............)...)).(((................))...........((...............).)...(.(..........).)...(.)).(((...............)..))).(((.......(.................).).(.).(.(..........).).(.).(.)).(((............)....))).......(((......(.............).).(.).(.(..........).).(.).(.)).(((...........))...(.)))...((.))....((.)).(((...)....((..........).)...(.(..........).)...(.)).(((...........))....))..........(((..).....((...........)...(............)...)).(((...........))....))....((((....))))....((.....).(((.............)....(........)....)).(((...........)......(........)......)).((..............................................................)).((.)...(.)......(.).(..)...(.)......(.).(..)...(.)......(.).(..((..................)).)).((...........................................((..................)).)).((.)..(.)....(.)....(..)..(.)....(.)....(..)..(.)....(.)....(.....................)).((..........................................(....).((..........)).)).((.).....(.)......(..).....(.)......(..).....(.)......(.(....).((..........)).)).((..........................................(....).((..........)).)).((.).(.)..(.)....(.)..(..).(.)..(.)....(.)..(..).(.)..(.)....(.)..(.(....).((..........)).)).((..........................................(....)...........
=========================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================.

Wypróbuj online!

To okropne i bardzo mi przykro. Pętle mogą stać się naprawdę drogie (bajtowo mądre) w MarioLANG, jeśli nie jesteś mądry na ich temat, a także prawie straciłem wolę życia, zanim dotarłem tak daleko, więc Mario dosłownie biegnie w linii prostej, najpierw ustawienie 6 komórek pamięci na prawidłowe wartości ASCII, a następnie przełączanie między nimi w celu uzyskania danych wyjściowych we właściwej kolejności. Można to zdecydowanie pograć w golfa dalej, a jeśli naprawdę się nienawidzisz, zdecydowanie sugeruję, abyś spróbował.

(Zapisano jeden bajt, usuwając ostatnią równą (postać podłogowa), ponieważ Mario trafia w ostatnią instrukcję, gdy spada nawet bez niej, a drugi, uświadamiając sobie, że mógł faktycznie trafić dwie instrukcje jesienią).

5413 bajtów

+++++>)+++++++++)+++++++)++++++)++++++++)+++++++++)++((((((-[!)+))++)++(()...............)............)).(((...............(....(....).(.))))).(((.............(.(..)...(.....)..(....))))).(((.............(...(.......)......)..(((++>-)))............(...(([!)))))).(((................((...........)).....(((++>-)))..........(.(...).(([!)))))).(((...............(..)).((.......).......(((++>-)))..........(.(.).(.).(([!)))))).(((............(....)).......((......)...(((++>-)))..........(.(.).(.).(([!)))))).(((...........((...))(.))...(((.)))....(((.))).((...(....))..........(.(.).(.).)..........(.(.).(.).)))).(((...........((....)))..........((..(.....))...........(...)............(...)))).(((...........((....)))....(....).....(((....))))).(((.....(((++>-)))........(....(([!)))))).(((...(((++>-)))........(......(([!)))))).((((((+++++++>-))........(([!))......)))).((((((+++>-)).(...).(......).(.).(([!)).)))..................(((.)))).((((((+++++++>-))......(([!)).)))..................(((.)))).((((((+++>-)).(..).(....).(....).(([!(+++++>-)))....((([!))))))).((((((+++++++>-))......(([!)))....(.)))..........(((.)))).((((((+++>-)).(.....).(......).(([!)))....(.)))..........(((.)))).((((((+++++++>-))......(([!)))....(.)))..........(((.)))).((((((+++>-)).(.).(..).(....).(..).(([!)))....(.)))..........(((.)))).((((((+++++++>-))......(([!)))....(...........
====="=======================================================#========================================================================================================================================================================="=======================#==================================================="=========================#====================================================="===========================#====================================================="===========================#=================================================================================================================================================================================================================================================================="====================#=================="======================#===================="==============#======================"==========================#=============================================="============#=========================================="==========================#======"============#====================="============#========================================"========================#============================================"============#========================================"============================#============================================"============#==================.
     !                                                       <                                                                                                                                                                         !                       <                                                   !                         <                                                     !                           <                                                     !                           <                                                                                                                                                                                                                                                                  !                    <                  !                      <                    !              <                      !                          <                                              !            <                                          !                          <      !            <                     !            <                                        !                        <                                            !            <                                        !                            <                                            !            <
     #======================================================="                                                                                                                                                                         #======================="                                                   #========================="                                                     #==========================="                                                     #==========================="                                                                                                                                                                                                                                                                  #===================="                  #======================"                    #=============="                      #=========================="                                              #============"                                          #=========================="      #============"                     #============"                                        #========================"                                            #============"                                        #============================"                                            #============"

Wypróbuj online!

Jest to port odpowiedzi przypadkowego faceta za pomocą konwertera Brainfuck Dennisa na MarioLANG, który wprowadza bardzo drobne zmiany, aby zaoszczędzić kilka bajtów. Chociaż jest oczywiście znacznie dłuższy, zawiera więcej funkcji języka i lepiej pokazuje, jak działa ten język, więc pomyślałem, że go uwzględnię.

— CoedRhyfelwr
źródło
3

Pyth , 211 bajtów

Xr9.HC.Z"xÚ]Á	Â@E%Q‚².NŠ[@‚^LI¦°Šñ¾$æ>A¼Ûƒx]Уcô 2Ìÿæ?&°sT	M3«DÊljbÝ/ɬ}Ì ÏÞ‘L¦&›¡%®R$èW+…mö>3Ž`!Wr¢“ê0-ü
{*÷KšjÎÇËáÂÏÒm*üúYÓ^	. Õ¯ŽÎ´Ó,æ†]ó« –ÎRäP¨ïB#ª5Cø®Þš?ÇǸz-vxË"<G6"
 .-*#

Wypróbuj online!

Metoda kompresji: Ponieważ jest tylko 6 znaków, spacja, znak nowej linii oraz #.-*zamień każdy z nich na literę od a-f. Następnie run-length koduje całość ( aaaaaccc-> 5a3citd.), A następnie kompresuje za pomocą zlib.

Xr9.HC.Z"..."<G6"\n .-*#"  # Complete program (last " is implicit)
        "..."              # zlib-compressed string
      .Z                   # decompress
     C                     # read that as a base 256 integer
   .H                      # convert to hex string
 r9                        # run-length decode
X            <G6"\n .-*#"  # translate "abcdef" to "\n .-*#"

Skompresowany ciąg to

      _0 _1 _2 _3  _4 _5 _6 _7  _8 _9 _a _b  _c _d _e _f

000_  78 da 5d 8d  c1 09 c2 40  10 45 0b 10  25 51 82 b2
001_  2e 4e 01 8a  5b 40 82 0b  5e 13 4c 01  49 07 a6 07
002_  0b b0 8a 05  f1 be 24 e6  3e 41 bc db  83 78 1f 5d
003_  d0 a3 63 f4  20 32 cc ff  1f e6 3f 26  b0 73 11 54
004_  0e 09 4d 08  33 9d ab 44  0c ca c7 89  62 dd 2f c9

005_  ac 7d cc 20  02 cf de 91  4c a6 26 9b  a1 25 ae 52
006_  07 24 8f e8  57 8f 2b 85  6d f6 3e 07  33 8e 60 21
007_  57 72 a2 93  16 ea 30 2d  fc 0a 7b 2a  f7 4b 9a 6a
008_  ce c7 cb e1  c2 cf d2 6d  2a fc fa 59  d3 5e 09 2e

009_  15 20 d5 af  8e ce b4 d3  2c e6 86 0e  5d f3 ab 20
00a_  96 ce 52 17  04 e4 50 a8  ef 42 0c 1e  23 aa 35 43
00b_  f8 ae de 9a  3f c7 0f c7  b8 7a 01 2d  76 78 cb
— ar4093
źródło
3

Bash , 486 bajtów

a=#.#.#O#.#.#
b=#e#O#e#
c=I#w#
S="Tb
T3f#.
R#d2g1f
R2i5S2Q2
UmT$b
T1*6V$a
Q3]5R$a
Pe#Y.Z.*2fO$b
Pf\`1gP2Q2
PfZI[f
R3M3
P5M5
EEA
#e#h#.1e#h#.1e#h#.1wu#
EDwu#
#d#f#f1d#f#f1d#f#fD
EC$c
#g#h1g#h1g#h#$c
EC$c
#.#d#f#d1.#d#f#d1.#d#f#d#$c
ECI;"
p(){
for((i=$[d-$2];i>0;i--)){ printf "$1";}
}
IFS=
while read -r -d '' -n1 c;do
printf -vd %d "'$c"
[ $d -le 47 ]&&printf "$c"||[ $d -le 69 ]&&p '#' 47||[ $d -le 86 ]&&p ' ' 69||[ $d -le 98 ]&&p '*' 86||[ $d -le 109 ]&&p '.' 98||p '-' 109
done<<<$S

Wypróbuj online!

Łańcuch zakodowany w trybie Run-Length $ S wygenerowany przez program inny niż golfowy: Wypróbuj online!

Następnie zmienne $ a, $ b, $ c w $ S zostały zastąpione przez kontrolę ręczną, a pojedynczy $ haczyk musiał być poprzedzony znakiem ucieczki w $ S, aby umożliwić użycie zmiennych.

— spuck
źródło
3

Perl, 422 396 370 366 365 znaków

print"f c*
f 4#4.#.
d #..3#5.##4.
d 3#7.6#e 3#c 3#
10 b.f #3.#a #3.#
f ##*7#11 2<#.>#a 2<#.>#
c 4#7*6#d 2<#.>#a 2<#.>#
b 3.#3*.4*.*3#4.2<a #3.#>
b 4.a*##5.b 3#c 3#
b 4.4*4 5*4.
d 4#8 4#
b 6#8 6#
3e#
3<#3.#6.#.#>#12-#
2b#12-#
2<#..#4.#4.#>#.2<.#4>.15#
2a#4 #a-#
3<#5.#6.#>4 #a-#
2a#4 #a-#
3<#.#..#4.#..#>4 #a-#
2a#4 c#"=~s/.<(.+?)>/$1x$&/ger=~s/\w+(.)/$1x hex$&/ger;

Długość przebiegu zakodowana w 2 krokach: kolejne znaki i kolejne wzory wielu znaków.

Wypróbuj online!

— człowiek w pracy
źródło
2

PHP, 608 565 557 bajtów

Używa GMP, 5kJvr...ciąg został utworzony przez użycie podstawień do konwersji oryginału na bazę 5 6, a następnie GMP do konwersji na bazę 62.

<?=str_replace(range(0,5),str_split("\n-.#* "),gmp_strval(gmp_init('5kJvrGbxP8CrM96cfgUaH1i7H5NT19NW3eSlwbRNO6MzND4omDb8BkvVwnTb1bQtCr6pet0EVt9BQnTuRSwcrL1Gnzs6dMEKAPctFQDrnbXv3eIzlyPYhZpGTwostpxBRJa7bvJvVVgoVjErM9sLKVxa0YkOaOUgMAP6orzz4ZGzb5iQ4qGDDuUOEiKmrcGTHp58srEheAqQSRQE4dOMlauXH4i06DY6tY8gu4maD2BFa68FA7s9sQG9VplFHpecaduYnzLoZgz18xwunIlSkFyIFCUyVMgVxvN7wxtyFZZSAli6DRyV1EobXZtiRa60mYyIZTYL79x190EjhCRAlBM1Lk11FJCeOFkKpAYW8M1hzUpghKA07J31gHpvlkFFKA4dSXvoZwGPbcrGOsmcsi5GAbhB2MIJe9XJGrA7KcSeMfOdxany7HEcesx8oewhtlRHnwxmG8qu8WwA8fjm1S82LMGrq3t',62),6));

Uruchom online.

2

Python3, 557 bajtów

Przeprowadź kodowanie długości, a następnie ręcznie wyodrębnij kilka powtórzonych podciągów (spacje, a następnie trzy „#”, „-” otoczone blokami itp.). Zdecydowanie miejsce na ulepszenia

u,v,w,x,y,z="*.-#\n "
t=z*4
s=x+w*18+x
r=t+x+w*10+x+y
q=x+v*3+x+v*6+x+v+x
p=x+v*2+x+v*4+x+v*4+x
o=x+v*5+x+v*6+x
n=x+v+x+v*2+x+v*4+x+v*2+x
m=z*10+x+v+x+v+x
l=z*10+x+v*3+x
print(t*4+u*12+y+z*15+x*4+v*4+x+v+y+z*13+x+v*2+x*3+v*5+x*2+v*4+y+z*13+x*3+v*7+x*6+z*14+x*3+t*3+x*3+y+t*4+v*11+z*5+l*2+y+z*15+x*2+u+x*7+z*7+m*2+y+t*3+x*4+u*7+x*6+z*3+m*2+y+z*11+v*3+x+u*3+v+u*4+v+u+x*3+v*4+l*2+y+z*11+v*4+u*10+x*2+v*5+z*11+x*3+t*3+x*3+y+z*11+v*4+u*4+t+u*5+v*4+y+z*13+x*4+t*2+x*4+y+z*11+x*6+t*2+x*6+y+x*62+y+q*3+s+y+x*42+s+y+p*3+x*20+y+x*42+r+o*3+r+x*42+r+n*3+r+x*42+t+x*11)

Python3, 789 bajtów

Zabawa z generatorami liczb losowych. Obraz jest kodowany pod względem długości, a następnie dzielony na 6-częściowe. Pierwszy fragment (wskaźniki dla symbolu do wydrukowania) jest generowany z generatora liczb pseudolosowych. Drugi to kodowanie base64 6 liczb.

from random import*
for a,b in zip([24743,129678,6328,31748,115,39591,43781,6080,105810,23721,53737,47694,64624,41381,26725,50462,13767,37213,119081,62980,29054,29054,29054,88178,27000,29054,29054,22423,17293,29054,53737,4887,17293,29054,29054,29054,53737,4887],[4366013200,2167672897,13976478019,12938928579,1328349251,1124376643,18371322817,10754461761,1090785345,1293447436,1241780289,11828203585,1141125187,3240640705,1091310209,11895611659,4479791875,13976490244,6627279364,1106776456,2164547651,2164547651,2164547651,1387008082,1141121089,1141121156,1141121156,1151866180,1157894218,2248429702,1141137477,1151864906,1090785354,2181316674,1141121089,1107562626,1141121092,11889283146]):
    seed(a)
    while b:
        b,i=divmod(b,64)
        print(" \n#-.*"[randrange(6)]*i,end="")
— spyr03
źródło
1
Zamiast mieć znak nowej linii w zmiennej, której możesz użyćprint(line1,line2,...,sep='\n')
— ovs
2

C, 1142 1068 1044 bajtów

To nie jest bardzo dobre, ale udało mi się. Zasadniczo szedłem wiersz po wierszu i w dowolnym miejscu jedna funkcja plus dwa lub więcej wywołań funkcji była krótsza niż oryginalny tekst, zastąpiłem tekst funkcją.

s=32;a=42;h=35;d=46;m=45;p(c,n){while(n--){putchar(c);}}n(){puts("");}c(){printf("#.#.#");}o(){printf("#...#");}z(){p(m,18);p(h,1);n();}x(char*c){printf("%s",c);}y(){p(h,42);x("    #----------#\n");}main(){p(s,15);p(a,12);n();p(s,15);x("####....#.\n");p(s,13);x("#..###.....##....\n");p(s,13);p(h,3);p(d,7);p(h,6);p(s,14);p(h,3);p(s,12);p(h,3);n();p(s,16);p(d,11);p(s,15);o();p(s,10);o();n();p(s,15);p(h,2);p(a,1);p(h,7);p(s,17);c();p(s,10);c();n();p(s,12);p(h,4);p(a,7);p(h,6);p(s,13);c();p(s,10);c();n();p(s,11);x("...#***.****.*###....");p(s,10);o();p(s,10);o();n();p(s,11);x("....**********##.....");p(s,11);p(h,3);p(s,12);p(h,3);n();p(s,11);x("....****    *****....\n");p(s,13);p(h,4);p(s,8);p(h,4);n();p(s,11);p(h,6);p(s,8);p(h,6);n();p(h,62);n();o();x("......#.##...#......#.##...#......#.##");z();p(h,43);z();x("#..#....#....##..#....#....##..#....#....");p(h,21);n();y();x("#.....#......##.....#......##.....#......#    #----------#\n");y();x("#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#\n");p(h,42);p(s,4);p(h,12);n();}

Pozwala to zaoszczędzić 99 bajtów na zwykłym printf.

Zaoszczędzono 69 bajtów, usuwając specyfikatory int i void oraz #include <stdio> . Zapisano kolejne 2 bajty, deklarując i jako globalny zamiast w pętli for . Zapisano kolejne 3 bajty, zmieniając printf na putchar w dwóch miejscach. Usunięto kolejne 21 bajtów ze zmianami sugerowanymi przez @Christian Gibbons: Na początku usunięto deklaracje zmiennych, zmieniono pętlę for na malejącą podczas pętli, zmieniono „\ n” na 10 w funkcji n () . Zapisano kolejne 3 bajty, zmieniając putchar (10) na puts („”) , dzięki uprzejmości tej odpowiedzi .

1143 bajtów

main(){printf("               ************\n               ####....#.\n             #..###.....##....\n             ###.......######              ###            ###\n                ...........               #...#          #...#\n               ##*#######                 #.#.#          #.#.#\n            ####*******######             #.#.#          #.#.#\n           ...#***.****.*###....          #...#          #...#\n           ....**********##.....           ###            ###\n           ....****    *****....\n             ####        ####\n           ######        ######\n##############################################################\n#...#......#.##...#......#.##...#......#.##------------------#\n###########################################------------------#\n#..#....#....##..#....#....##..#....#....#####################\n##########################################    #----------#\n#.....#......##.....#......##.....#......#    #----------#\n##########################################    #----------#\n#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#\n##########################################    ############\n");}

Wypróbuj online tutaj .

Ungolfed (ish)

s=32;a=42;h=35;d=46;m=45; // ASCII indices of (space) * # . - symbols.
p(c,n){ // Prints c, n times.
    while(n--){
        putchar(c);}}
n(){ // Prints a newline.
    puts("");}
c(){ // Prints a piece of the coins. Used 4 times.
    printf("#.#.#");}
o(){ // Prints a piece of the coins, and the ground. Used 5 times.
    printf("#...#");}
z(){ // Prints a piece of the ground. Used twice.
    p(m,18);;p(h,1);n();}
x(char*c){ // Wrapper for printf. Used 10 times.
    printf("%s",c);}
y(){ // Prints a piece of the ground. Used twice.
    p(h,42);x("    #----------#\n");}
main(){
    p(s,15);p(a,12);n();
    p(s,15);x("####....#.\n");
    p(s,13);x("#..###.....##....\n");
    p(s,13);p(h,3);p(d,7);p(h,6);p(s,14);p(h,3);p(s,12);p(h,3);n();
    p(s,16);p(d,11);p(s,15);o();p(s,10);o();n();
    p(s,15);p(h,2);p(a,1);p(h,7);p(s,17);c();p(s,10);c();n();
    p(s,12);p(h,4);p(a,7);p(h,6);p(s,13);c();p(s,10);c();n();
    p(s,11);x("...#***.****.*###....");p(s,10);o();p(s,10);o();n();
    p(s,11);x("....**********##.....");p(s,11);p(h,3);p(s,12);p(h,3);n();
    p(s,11);x("....****    *****....\n");
    p(s,13);p(h,4);p(s,8);p(h,4);n();
    p(s,11);p(h,6);p(s,8);p(h,6);n();
    p(h,62);n();
    o();x("......#.##...#......#.##...#......#.##");z();
    p(h,43);z();
    x("#..#....#....##..#....#....##..#....#....");p(h,21);n();
    y();x("#.....#......##.....#......##.....#......#    #----------#\n");
    y();x("#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#\n");
    p(h,42);p(s,4);p(h,12);n();}
— MichaelS
źródło
Możesz grać w golfa z kilkoma prostymi zmianami. Usuń s,a,h,d,m,od początku, zostaną one domyślnie zadeklarowane jako ints, gdy zainicjujesz je natychmiast po tym. for(;i++>n;)pozwoli ci uniknąć iponownego pisania w pętli. putchar('\n')->, putchar(10)aby ogolić jeszcze kilka bajtów. Również wygląda Macie obce ;w swojej zfunkcji.
— Christian Gibbons
właściwie możemy icałkowicie zrzucić . Zamiast for-loop, zróbwhile(n--)
— Christian Gibbons
@ChristianGibbons: Dzięki. Myślę, że to zaoszczędziło 21 bajtów. Szkoda, że ​​wciąż ponad trzykrotnie przewyższa tę drugą odpowiedź C.
— MichaelS
Przechodząc x()na górę, możesz mieć c()i o()wywołać go, aby zaoszczędzić trochę bajtów. x()samo to może zająć int*, ponieważ wszystkie wskaźniki mają zwykle ten sam rozmiar i drukuje za pomocą, printf(c)aby zaoszczędzić kilka dodatkowych bajtów. Dwie funkcje można nieco skrócić: n(){p(10,1);}i p(c,n){while(n--)x(&c);}(zakłada mały endian). Za każdym razem, gdy wywołujesz funkcję bez argumentu, możesz użyć poprzedniego wywołania funkcji jako argumentu, na przykład: c();n();-> n(c());.
— gastropner
Opierając się na @gastropner 987 bajtach
— pułapkot
2

Python , 340 378 bajtów

Zepsułem kodowanie w oryginalnej odpowiedzi, oto ta oparta na kompresji LZW. Może kiedyś wrócę do mojej pierwotnej odpowiedzi.

n=0
for c in'"/AVHF`N.o,>D\\5:{/RD?{C._Q\\%r7,SUOXGh8<}nA^Qddb<=Vb7;L@QPi[XJ65W=p|@<fxMl2+C1gro(x%m"Iz0+B?9d</tYaj.!:6(T#_/5el1Hl{[W&g*A.Oc1*4zf#[{WfLr@Km_jgFkg#1D`&Ik9r\'{M]7c&# X1,U#]=>}JFwVexi7nzbKnS-@-y{IA=l#="EVj=8L`%"9w@zoc9!:q/rT\\OMd]/p^ksiT?P_yj,':n=n*94+ord(c)-32
d=[*' *\n#.-']
s=c=' '
while n:i=n%202;d+=[c+(i>=len(d)and c[0]or d[i][0])];c=d[i];s+=c;n//=202
print(s)

Wypróbuj online!

— Kyle Gullion
źródło
1
Ten nie jest poprawny, brakuje 16 znaków w ostatnim wierszu wyniku.
— Skillmon
@Skillmon Dzięki, zaktualizowano o działającą odpowiedź.
— Kyle Gullion
2

Czysty JavaScript 419 bajtów (bez lib)

Kompresja (1 krok: policz każdy znak w kodzie szesnastkowym, np. **********Daje *a, 2 krok: przekonwertuj dwa znaki jak * 1 lub # 4 na pojedynczy znak bez kodu ascii)

Pokaż fragment kodu

Dekompresja

Pokaż fragment kodu

— Kamil Kiełczewski
źródło
2

PowerShell + tar, 265 = 9 + 256 bajtów

Ten skrypt działa w systemach Windows i Linux. Skrypt wyodrębnia dane wyjściowe z archiwum tar t(256 bajtów). tPowinien być umieszczony w tym samym katalogu co skrypt.

tar xOf t

Wypróbuj online!

Skrypt PowerShell do utworzenia archiwum tar t:

(@"
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############
"@) | Set-Content f -Force
tar zcfo t f
— mazzy
źródło
1

Perl z filtrem: moduł sh, 672 bajty

Jest długi, ale jest również raczej nieczytelny, więc pomyślałem, że kwalifikuje się jako odpowiedź na golfa ...

use Filter::sh 'sed "s/S/\" \"/g"';
use Filter::sh 'sed "s/\([0-9]\+\)/x\1 ./g"';
$e="....";$a="#...#$e..#.#";$b="#..#$e#$e#";$c="#$e.#$e..#";$d="#.#..#$e#..#";$f="###";$g="#...#";$h="#.#.#";
print S16"*"12"\n".S16'#'4'.'4"#.\n".S14"#..$f$e.##$e\n".S14$f."."7$f.$f.S13$f.S12"$f\n".S17"."11S14$g.S10"$g\n".S16"##*"."#"7S16$h.S10"$h\n".S13"$f#"."*"7"#"6S12$h.S10"$h\n".S12"...#***.****.*###$e".S9$g.S10"$g\n".S12$e."*"10"##$e.".S10$f.S12"$f\n".S12"$e****    ****$e\n".S14"$f#".S8"$f#\n".S12$f.$f.S8"$f$f\n"."#"62"\n$a$a$a#"."-"18"#\n"."#"43"-"18"#\n$b$b$b"."#"20"\n"."#"42S4"#"."-"10"#\n$c$c$c".S4"#"."-"10"#\n"."#"42S4"#"."-"10"#\n$d$d$d".S4"#"."-"10"#\n"."#"42S4"#"12"\n";

Objaśnienie: filtr zamienia Ssię na " "i liczbę na x(num) ., więc na przykład S14staje się " "x14. W Perlu oznacza to „wydrukuj przestrzeń 14 razy”. Ponadto istnieje pewna ręczna kompresja sekwencji, które często występują przy użyciu zmiennych $a- $h.

— Marijn
źródło
Po co używać komend sed, skoro perl obsługuje s/regex/replace/gnatywnie składnię?
— Score_Under
@Score_Under, ponieważ nie wiedziałem o emodyfikatorze wyrażeń regularnych, który jest potrzebny tutaj do wykonania operatora x po podstawieniu - ale teraz to robię: D
— Marijn
1

SOGL V0.12 , 971 bajtów

Po prostu skopiowałem cały ciąg do kompresora. Uświadomiłem sobie, że struna nie była zbyt mocno skompresowana.

"ξ↔⁴‚σ╔↔æz½↓«ļ;¾⅝↑¶q$+ξρI#↔@≥Β⁄,;∆n2BΡ¾~«n▼og╤iCΘ⌠δZ░∑℮E3č─æ`⅓+↑žS]ķø 'αN²'Q-ω⅞±ž<e⁴Κ№6‼Dfθ∫⅞)i≠Ph╗8B‽`HΔ→┘↓d5∑∫h╤kΖΜY⅞|⌡Σχ¡GΥq«≡─ηe→°~⁹*░κRΝycč□±H⅔b¾℮╗↕Θ*ζΜ9⁵Dæqēυ¦Jn|¼▲ū-⁹¡╗;g²T℮F6u*ε¤3⅜v■└$}Q;▒MKηBqο⁰X╬/Lβ┌I╬č¤¾►'█p¹A0E∑QXγ9§čΡT▒ξ⁾n‚Υ∫æ¤3I-↕æA⁄gTq√šk3>‼μσ¤j:Zk►↓σ¾ņ*∑*╤ΚPn׀æS~3j‚~█fo╔Ε‼■¤υ ρ{¦Oτ◄μ`]ŗS▓κΜ4y║6AΨū0⁽:uMφ^υκ≤&/═;Ο≠№3→⁄Θ±ū<R°ω.cģ²⁴׀Kē~Θ60Εθ^Ε½rA┼═◄⅞║⁶jH²βX8ΓMOšι≤9#$XΚƨ]¶ļA¾⅛x▲Ε|F■¾ƨ(Υ5ΨB[↑√℮⅔α@↓ļ\TB⌠w⅝³βšīηo¤Ω¦∑CTΕņžAh′DαψH?¡ΙO‽HωΕ?○ƦΖ`∙²u   ⁶¾╚iļ⁶Π7⁾ρ℮░;(Ο²9⅔v○⌡⁽¾‽↑┼ξjƧ¬h¼┌Y▲¹ēhμΞ*⁴ā≠cmeeW℮ADC═¬[9išE⅛~№k⅔№lķ¼⅛∆$qΒR┐Γ¦⅔}\Φ‼ΩxøG⁾ΓOŗ⅟zψ;¹]m║░↔═;↑τΩÆΘχW»G∞ΧQT_L  Δ   nē‼№>ζƧρΕ↔Λλ↑EīšÆ↑gWIμū█⁹└Ιf⌡EΘ⁶cυ═<⅜LjΤlτ⅞⅟ΟB╚@░⁽ič-|dΘž⁽Υ■tPp⁵θ╝│⅜v+M8³Τ╝ι░╬¶ū¾oī⅜o╥\VΨΖ6±≡∆hl?ΦģīX╚æ→#%C\aG‛Ι⌠?ΞJ⁄═⁴v°±∫⁸dy►īι׀ģ&χeģ ~xš/L»ψ(Ξ]δ‛ģæ─╗ƨ╚a*‰■Υ□L$.Λ└≈′9ν‚v░¦+ΛξƧΟļBKγ÷Π*IΝ‚ρTGΜ-^gΗ?Æ[ā╤⅓c&►δæ↓°√>R%┘⁵ī╥$J▲kψβ▲Χ╝0ψγαp¾‼~γ!ι⅔_γψ⁄⅝┼═ģÆ⁴A»┼Jλ∆≤š'ΣRΡΩd4¬hAVb¬zbH⁸ωθyV»⁹№ξ╤*°Kν-G[═ζ∙εY↔⁾Xp⁷χ<⁹≈≈┐>°(Æ#¼i┌γδ∫+ευļDET⌡∆═ν<xzΘ⁰⌡hS»ΚKļ⁰G*mε▲GΖλDΗ_Ηx╝⁴ΘλLσ╝ψB~χ[Ν#ΗhΡ\λ2Y∙ψ¤i⌠}λ▒│αξqzP⅜¶²‘

Wypróbuj tutaj!

— ZA
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.