Saída de uma imagem Super Mario

28

Este é um problema no Luogu OJ. Decidi publicá-lo aqui, porque no Luogu OJ, muitas pessoas, incluindo eu e meu amigo, estão interessadas em como resolver esse problema com o menor número de caracteres.

Sua tarefa é produzir a seguinte arte ASCII:

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

Isso é código-golfe, e o programa mais curto vence.

code-golf  ascii-art  kolmogorov-complexity 
— Altamente radioativo
fonte
7
É permitido um espaço em branco adicional (por exemplo, para criar um retângulo de caracteres) no lado direito? que tal uma nova linha à direita?
— Level River St
@LevelRiverSt Desculpe pela resposta tardia. Sim, o OJ retira automaticamente todos os espaços em branco / guias / nova linha e todos os espaços em branco / guias no lado direito.
— HighlyRadioactive

Respostas:

22

Brainfuck , 1347 bytes

Por que eu faço isso comigo mesmo

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

Experimente online!

A versão "legível":

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

<<
>...............>............>>.
<<<...............<....<....>.<.>>>>>.
<<<.............<.<..>...<.....>..<....>>>>>.
<<<.............<...<.......>......>..<<<++[->>>............<...<<]>>>>>>.
<<<................<<...........>>.....<<<++[->>>..........<.<...>.<<]>>>>>>.
<<<...............<..>>.<<.......>.......<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.
<<<............<....>>.......<<......>...<<<++[->>>..........<.<.>.<.>.<<]>>>>>>.
<<<...........<<...>><.>>...<<<.>>>....<<<.>>>.<<...<....>>..........<.<.>.<.>.>..........<.<.>.<.>.>>>>.
<<<...........<<....>>>..........<<..<.....>>...........<...>............<...>>>>.
<<<...........<<....>>>....<....>.....<<<....>>>>>.
<<<.....<<<++[->>>........<....<<]>>>>>>.
<<<...<<<++[->>>........<......<<]>>>>>>.
<<<<<<+++++++[->>........<<]>>......>>>>.
<<<<<<+++[->>.<...>.<......>.<.>.<<]>>.>>>..................<<<.>>>>.
<<<<<<+++++++[->>......<<]>>.>>>..................<<<.>>>>.
<<<<<<+++[->>.<..>.<....>.<....>.<<]<+++++[->>>....<<<]>>>>>>>.
<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++[->>.<.....>.<......>.<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++++++[->>......<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++[->>.<.>.<..>.<....>.<..>.<<]>>>....<.>>>..........<<<.>>>>.
<<<<<<+++++++[->>......<<]>>>....<............
— O cara aleatório
fonte
1
Isso é incrível. Você mesmo projetou ou usou um programa para ajudá-lo?
— jaaq 13/09
4
Fiz eu mesmo. Também sei que provavelmente existe uma maneira melhor e mais curta de fazer isso, mas foi doloroso o suficiente desenhar mario no cérebro com a mão.
— O cara aleatório
5
No lado positivo, você sabe que ninguém pode tentar encontrar uma versão mais curta e competitiva: D
— CD001
4
@ CD001 isso é um desafio?
— Benjamin Urquhart
1
@Evorlor bem, existem compiladores, macros e scripts de brainfuck que podem traduzir instruções legíveis em brainfuck. Por "à mão", quis dizer se ele construiu o código inteiramente sozinho, o que ele realmente fez. Parabéns por isso.
— jaaq 17/09
16

T-SQL, 322 298 288 bytes

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

Usa a compactação G-Zip incorporada ao SQL 2016 e posterior, juntamente com a codificação Base64, consulte esta publicação de dicas para obter detalhes .

No SSMS, você precisará produzir como texto após mexer nos limites de caracteres do SSMS nas configurações ou apenas copiar e colar a saída na janela de código:

insira a descrição da imagem aqui

EDITAS : Salva 24 bytes com uma string compactada melhor, graças a @someone; salvou 10 bytes com uma conversão implícita usando CONCAT, graças a @digscoop.

— BradC
fonte
2
Eu acho que tenho uma string base64 gzip mais curta H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA=,. Não posso testar isso porque não tenho idéia de como, mas você pode ou não ser capaz de omitir o =.
— meu pronome é monicareinstate
@ alguém: Obrigado, essa string funciona (precisa do =) e salva 24 bytes; acho que minha rotina de codificação está longe de ser ideal.
— BradC 12/09
1
Você pode usar uma variável sem nome e uma conversão implícita para encurtar um pouco mais. Tente: DECLARE @ XML='H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA='SELECT CONCAT('',DECOMPRESS(@.value('.','varbinary(max)')))
— digscoop 13/09
Obrigado, @digscoop, me salvou 10 bytes. Eu usei o CONCATtruque, mas não a variável XML, uma vez que teria acrescentado volta 3 bytes (seria mais curto, porém, em situações que eu já tinha uma variável)
— BradC
12

PHP , 176 155 bytes

-21 bytes graças à string super compactada de Ryan Moore .

Esta versão usa a saída bruta do gzdeflate e contém dados binários imprimíveis, portanto, o próprio código e o link TIO não podem ser publicados aqui, mas aqui está um dump hexadecimal:

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

Graças a @dzaima , aqui está um TIO que usa o bash para criar e executar este arquivo: Experimente online!

Isso basicamente reverte o esvaziamento e imprime o resultado. Salve-o como um arquivo binário e execute-o assim:php mario.php

PHP , 239 216 bytes

-23 bytes graças à string super compactada de Ryan Moore .

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

Experimente online!

Igual à versão anterior, mas usada base64_encode na saída de gzdeflate, portanto, o código é legível e o link TIO também está disponível. Isso basicamente inverte a base64 e esvazia e imprime o resultado.

— Night2
fonte
1
Link TIO usando o bash para criar corretamente o arquivo
— dzaima 12/09
@dzaima Muito obrigado! Não sabia que poderíamos executar outros comandos com o bash no TIO.
— Night2
1
Guardar 2 bytes para a versão Pro ou 22 bytes para o semipro com pZGBBgQhAEQB6CviAXHv / z / vXJF29mRXDzHGmKbqlbZQwgNQxauDDkdBTRsc0Knphiw1cGI4qITMODQGNUEkZMnFbUDnVVz9pW39AFSfX161TUDVpy830 / NT7x + zDiLikC4Ujiio2EG26nPjVfvfuKI6jq1K3m3vDxbNy7qdyuhZ67KKnTptXfgC
— Ryan Moore
1
@ Ryan Moore Muito obrigado! Na verdade, ele salvou 21 bytes na versão binária e 23 bytes na versão legível. Como você conseguiu uma compressão tão alta? Você tem alguma ferramenta e / ou configurações especiais?
— Night2 14/09
1
@ Night2 Eu uso advdef do advancemame.it - ele usa o Zopfli para tentar um zilhão de opções diferentes e geralmente faz uma compressão melhor do que o gzip comum. O problema é que ele só funciona com conteúdo .gz, então você precisa compactar o original, advdefar o .gz e remover os cabeçalhos .gz do PHP gzinflate para usá-lo.
— Ryan Moore
10

Chiclete , 138 bytes

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

Experimente online!

— ovs
fonte
1
Para comparação, tentei produzir a imagem inteira como uma única string compactada em carvão, o que resulta em um programa de 155 bytes. Tentar desenhar peças usando os comandos do carvão vegetal na verdade aumenta o comprimento.
— Neil
"Linguagem" interessante, realmente chuta um $$ 😛
— roblogic 17/09
8

Geléia , 235 213 bytes

“µ!æ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

Experimente online!

Usa uma combinação de codificação de execução e substituição de seqüências comuns de comprimento 2 por um único dígito. Não usa nenhuma biblioteca de compactação padrão como o gzip. No geral, tem 169 bytes de dados compactados e 44 de código.

Explicação

Etapa 1: substituir valores nos dados entre 17 e 39 por pares de bytes pré-armazenados

“µ...Ɲ‘                     | 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

Etapa 2: decodificar o comprimento da execução e converter em string

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

LaTeX, 452 448 bytes

Criado com substituição de bigram (e um trigrama) em vez de programar um loop para substituir vários símbolos consecutivos.

\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 bytes

Provavelmente haverá uma variante mais eficiente, mas foi o que consegui obter manualmente (sem ferramentas de compressão incorporadas no LaTeX ...). Criei um pequeno loop para substituir seqüências consecutivas.

\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}#}

Saída do terminal (de ambos os códigos):

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
fonte
5

Bash + coreutils + xz, 243 242 240 bytes

base64 -d<<<4AROAJpdABBtAVsJZEAxAEVT46Z4yzQSDRh1V2s3yKKQ3CiFBCqNr55BVH/f7Qz/mkCIrVe+i4qcFSY5BEjUGbKH55TbsFibiXAoQ8LLpf0KeeR/Qj+UVG3Y3+Xx/Xt+0BI+rKPZCnr2NYt5PB4YsQBJeHbN+TCDB9VxVA5l2MZerD23kdk9GwTt9T7j2LGzPwyNGnq9XrJxWS3PWQOEtp8A|xz -qdFraw
— David Conrad
fonte
1
As aspas duplas não são necessárias.
— TheSola10 14/09
@ TheSola10 Obrigado! 2 bytes salvos.
— David Conrad
4

Barril , 2204 1012 745 bytes

(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*|\#)(

Experimente online!

Guardado 267 bytes graças a @Sriotchilism O'Zaic

Programa de 1012 bytes

(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*|\#)

Experimente online!

Esta é apenas uma codificação de execução da imagem ascii, mas implementada no Keg

Programa antigo

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

Experimente online!

Sei que isso provavelmente não ganhará nenhuma competição, mas, parece bom. Literalmente apenas escapando de todos os caracteres e imprimindo-os. Quero dizer, poderia ser jogado, mas você não ama programas de arte ascii?

— Jono 2906
fonte
@A_, Inicialmente eu tentei isso com o gerador que eu usei (i não escrever à mão), mas não funcionou
— Jono 2906
— Assistente de trigo
E agora que entendo como isso funciona um pouco mais, aqui está uma versão muito mais curta.
— Wheat Wizard
4

JavaScript (Node.js) ,  265  264 bytes

Guardado 1 byte graças a @ Night2

Esvaziado.

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

Experimente online!

JavaScript (Node.js) , 318 bytes

Substituições consecutivas de cadeias.

_=>[...`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`)

Experimente online!

JavaScript (ES7), 340 bytes

Esmagado.

_=>[...'[{+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`)

Experimente online!

Ou aqui:

Mostrar snippet de código

— Arnauld
fonte
4

C (gcc) , 322 320 318 316 bytes

-2 bytes graças ao ceilingcat.

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

Experimente online!

— gastropner
fonte
4

Bash + coreutils, 269 262 261 Bytes

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

Um pouco trivial - nada de inteligente acontecendo aqui. Não tenho certeza se tenho permissão para usar o gzip assim. Se não sou, não tenho dúvida de que alguém gritará comigo.

(melhor se eu remover espaços / aspas inúteis)

Obrigado a @manatwork por salvar um byte

Experimente online!

— ssta
fonte
1
A dica do Digital Trauma pode ajudá-lo a reduzi-lo um pouco mais.
— manatwork 13/09
@manatwork Obrigado, isso me ajudou a otimizar um byte da minha resposta.
— David Conrad
2
Você pode soltar o echocomando e um pipe, tornando-obase64 -d<<<...|gunzip
— TheSola10 14/09
4

Python3, 921 916 752 751 539 534 476 bytes

E aqui está uma versão justa obrigatória. Eu usei um script para contar os caracteres individuais, deve ser idêntico:

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

Experimente online!

Cortesia dos caras incríveis nos comentários que são muito melhores que eu!

E aqui está o script (python3) para qualquer um que queira gerar algum código e seja muito preguiçoso / eficiente para contar manualmente:

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

Falha no Python3 abusada, 167 bytes

Já que nada foi dito sobre brechas comuns, vou esconder essa aqui enquanto puder. O TIO não gosta de urllib por algum motivo, se alguém conhece um site para hospedar o script, por favor me diga. Obviamente, um encurtador de link poderia salvar alguns bytes, mas eu não queria ir mais longe naquele buraco de coelho.

from urllib.request import *
import re
print(re.split("</?code>",str(urlopen("/codegolf//q/192715/85978").read()))[1].replace("\\n","\n")[:-1])
— jaaq
fonte
12
Tenho certeza de que o ponto das brechas padrão é que elas se aplicam mesmo quando não mencionadas explicitamente.
— ar4093 13/09
1
Sim eu concordo; mas como o op disse many people, including me and my friend, are interested about how to solve this problem within the fewest characters, pensei que valeria uma boa risada; que se encaixa no tema de programação recreativa desta postagem e de partes deste site.
— jaaq 13/09
1
Em seguida, basta pegar o texto como entrada e usarprint(input())
— ar4093 13/09
1
Bem, então eu contaria a entrada para os bytes usados, pois isso derrotaria todo o desafio. Eu só queria brincar um pouco com o tropo 'programadores nunca devem refazer o que já está lá fora'. Desculpe se minha mentalidade de apenas me divertir nesse ambiente incomoda você, eu não pretendia!
— jaaq 13/09
2
Eu não sei python, mas você pode fazer m igual a dois traços, já que todo uso de traço é um número par? Nesse caso, você pode salvar cerca de 5 caracteres.
— Keeta 13/09
4

MarioLANG , 3287 3286 3285 Bytes

Eu tive que fazer isso para o tema.

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

Experimente online!

Isso é horrível e sinto muito. Os loops podem ficar muito caros (bytes em bytes) no MarioLANG se você não for esperto sobre eles e também quase perdi a vontade de viver até o momento em que cheguei tão longe, para que Mario literalmente simplesmente corra em linha reta, primeiro definindo 6 células de memória com os valores ASCII corretos e depois alternando entre elas para a saída na ordem correta. Definitivamente, isso pode ser ainda mais aprimorado e, se você realmente se odeia, sugiro que experimente.

(Salva um byte excluindo os últimos iguais (caractere de andar), pois Mario acerta a última instrução enquanto cai mesmo sem ela e outro ao perceber que poderia realmente acertar duas instruções no outono.)

5413 Bytes

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

Experimente online!

Esta é uma porta da resposta do cara aleatório, usando o conversor Brainfuck para MarioLANG de Dennis, fazendo pequenas alterações para economizar alguns bytes. Embora seja obviamente muito mais longo, inclui mais recursos do idioma e mostra melhor como o idioma funciona, então pensei em incluí-lo.

— CoedRhyfelwr
fonte
3

Pitão , 211 bytes

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"
 .-*#

Experimente online!

Método de compactação: como há apenas 6 caracteres, o espaço, a nova linha e também #.-*substitui cada um deles por uma letra de a-f. Depois, o comprimento da execução codifica a coisa toda ( aaaaaccc-> 5a3cetc.) e, em seguida, compacta usando o 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 .-*#"

A cadeia compactada é

      _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
fonte
3

Bash , 486 bytes

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

Experimente online!

A seqüência codificada de comprimento de execução $ S gerada pelo programa não-golfe aqui: Experimente online!

Em seguida, as variáveis ​​$ a, $ b, $ c em $ S foram substituídas pela inspeção manual e um único retorno foi necessário em $ S para permitir que variáveis ​​fossem usadas.

— spuck
fonte
3

Perl, 422 396 370 366 365 caracteres

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;

Duração codificada em 2 etapas: caracteres consecutivos e padrões consecutivos de vários caracteres.

Experimente online!

— homem a trabalhar
fonte
2

PHP, 608 565 557 bytes

Utiliza GMP, a 5kJvr...sequência foi criada usando primeiro substituições para converter o original em base 5 6 e, em seguida, GMP para converter em base 62.

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

Execute online.

2

Python3, 557 bytes

Comprimento da execução codificado e, em seguida, algumas substrings repetidas (espaços e três "#", "-" cercados por blocos, etc.) extraídos manualmente. Definitivamente espaço para melhorias

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 bytes

Diversão com geradores de números aleatórios. A imagem é codificada em tamanho de execução e, em seguida, dividida em partes de 6. O primeiro pedaço (índices para o símbolo imprimir) é gerado a partir de um gerador de números pseudo-aleatórios. O segundo é uma codificação base64 dos 6 números.

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
fonte
1
Em vez de ter a nova linha armazenada em uma variável, você pode usarprint(line1,line2,...,sep='\n')
— ovs 15/09
2

C, 1142 1068 1044 bytes

Não é muito bom, mas eu consegui. Basicamente, eu fui linha por linha e qualquer lugar em que uma função mais duas ou mais chamadas de função fosse mais curta que o texto original, substitui o texto por uma função.

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

Ele economiza 99 bytes usando apenas printf direto.

Economizou 69 bytes removendo os especificadores int e void e o #include <stdio> . Economizou mais 2 bytes declarando i como global em vez de no loop for . Economizou mais 3 bytes alterando printf para putchar em dois lugares. Foram removidos outros 21 bytes com as alterações sugeridas por @Christian Gibbons: Removidas as declarações de variáveis ​​no início, alteradas o loop for para um loop while decrescente , alteradas '\ n' para 10 na função n () . Economizou outros 3 bytes alterando putchar (10) para puts ("") , cortesia desta resposta .

1143 bytes

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

Experimente online aqui .

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
fonte
Você pode jogar um pouco mais com algumas mudanças simples. Remova s,a,h,d,m,desde o início, aqueles serão implicitamente declarados como ints quando você os inicializar imediatamente depois. for(;i++>n;)permitirá que você evite escrever inovamente dentro do loop. putchar('\n')-> putchar(10)para raspar mais alguns bytes. Também parece que você tem um estranho ;em sua zfunção.
— Christian Gibbons
na verdade, podemos despejar icompletamente. Em vez de um loop for, façawhile(n--)
— Christian Gibbons
@ChristianGibbons: Obrigado. Eu acho que economizou 21 bytes. Pena que ainda é três vezes maior que a outra resposta C.
— MichaelS 14/09
Mover x()para o topo, você pode ter c()e o()chamá-lo para salvar alguns bytes. x()pode demorar int*, pois todos os ponteiros tendem a ter o mesmo tamanho e imprimir usando printf(c)para salvar mais alguns bytes. Duas funções podem ser abreviadas um pouco: n(){p(10,1);}e p(c,n){while(n--)x(&c);}(assume pouco endian). Sempre que você chamar uma função sem argumento, poderá usar a chamada de função anterior como argumento, assim: c();n();-> n(c());.
— gastropner 16/09
Com base @gastropner 987 bytes
— ceilingcat
2

Python , 340 378 bytes

Eu estraguei a codificação na resposta original, aqui está uma baseada na compactação LZW. Pode revisitar minha resposta original em algum momento.

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)

Experimente online!

— Kyle Gullion
fonte
1
Este não está correto, faltam 16 caracteres na última linha da saída.
— Skillmon 14/09
@ Skillmon Obrigado, atualizado com uma resposta de trabalho.
— Kyle Gullion 14/09
2

JavaScript puro 419 bytes (sem lib)

Compressão (1 passo: conte cada caractere em hexadecimal, por exemplo , **********dá *a, 2 passo: converta dois caracteres como * 1 ou # 4 em um código ascii livre de bruxa de caractere único)

Mostrar snippet de código

Descompressão

Mostrar snippet de código

— Kamil Kiełczewski
fonte
2

PowerShell + alcatrão, 265 = 9 + 256 bytes

Este script funciona com Windows e Linux. O script extrai a saída do arquivo tar t(256 bytes). O tdeve ser colocado no mesmo diretório que o script.

tar xOf t

Experimente online!

O script powershell para criar o arquivo tar t:

(@"
               ************
               ####....#.
             #..###.....##....
             ###.......######              ###            ###
                ...........               #...#          #...#
               ##*#######                 #.#.#          #.#.#
            ####*******######             #.#.#          #.#.#
           ...#***.****.*###....          #...#          #...#
           ....**********##.....           ###            ###
           ....****    *****....
             ####        ####
           ######        ######
##############################################################
#...#......#.##...#......#.##...#......#.##------------------#
###########################################------------------#
#..#....#....##..#....#....##..#....#....#####################
##########################################    #----------#
#.....#......##.....#......##.....#......#    #----------#
##########################################    #----------#
#.#..#....#..##.#..#....#..##.#..#....#..#    #----------#
##########################################    ############
"@) | Set-Content f -Force
tar zcfo t f
— confuso
fonte
1

Perl com filtro: módulo sh, 672 bytes

É longo, mas também é bastante ilegível, então eu pensei que se qualifica como uma resposta para o golfe ...

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

Explicação: o filtro substitui Spor " "e um número por x(num) ., por exemplo, S14torna-se " "x14. No Perl, isso significa "imprimir um espaço 14 vezes". Além disso, existe alguma compressão manual para sequências que ocorrem frequentemente usando variáveis $a- $h.

— Marijn
fonte
Por que usar comandos sed quando o perl suporta s/regex/replace/gsintaxe nativamente?
— Score_Und
@Score_Under isso é porque eu não sabia sobre o emodificador de regex necessário aqui para executar o operador x após a substituição - mas agora sim: D
— Marijn
1

SOGL V0.12 , 971 bytes

Simplesmente copiei toda a corda no compressor. Percebi que a corda não era muito comprimida.

"ξ↔⁴‚σ╔↔æ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⅜¶²‘

Experimente aqui!

— UMA
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.