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
fonte
Respostas:
Brainfuck , 1347 bytes
Por que eu faço isso comigo mesmo
Experimente online!
A versão "legível":
fonte
T-SQL,
322 298288 bytesUsa 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:
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.fonte
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=
.=
) e salva 24 bytes; acho que minha rotina de codificação está longe de ser ideal.DECLARE @ XML='H4sIAAAAAAACA6WRQYrEIBQF955CqJ0wdf/jjehM2rwOdofUQvIoHj9f65m2UMLRsYNng/4ZQU0NThjUtBFLDXwRBpWIWYfGpCaIRCy5cZswuFVX6U3bOAA73/+8nXYw2368uWwfj3r5MKzfq4W0UHhEQcUBsk0/b9yafllX9P/YpeDu7rVDTF6226WoPpy6bMUmPZ66UH4BHz4rVE8EAAA='SELECT CONCAT('',DECOMPRESS(@.value('.','varbinary(max)')))
CONCAT
truque, 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)PHP ,
176155 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:
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 ,
239216 bytes-23 bytes graças à string super compactada de Ryan Moore .
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.fonte
Chiclete , 138 bytes
Experimente online!
fonte
Geléia ,
235213 bytesExperimente 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
Etapa 2: decodificar o comprimento da execução e converter em string
fonte
LaTeX,
452448 bytesCriado com substituição de bigram (e um trigrama) em vez de programar um loop para substituir vários símbolos consecutivos.
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.
Saída do terminal (de ambos os códigos):
fonte
Bash + coreutils + xz,
243242240 bytesfonte
Barril ,
22041012745 bytesExperimente online!
Guardado 267 bytes graças a @Sriotchilism O'Zaic
Programa de 1012 bytes
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?
fonte
JavaScript (Node.js) ,
265264 bytesGuardado 1 byte graças a @ Night2
Esvaziado.
Experimente online!
JavaScript (Node.js) , 318 bytes
Substituições consecutivas de cadeias.
Experimente online!
JavaScript (ES7), 340 bytes
Esmagado.
Experimente online!
Ou aqui:
Mostrar snippet de código
fonte
C (gcc) ,
322320318316 bytes-2 bytes graças ao ceilingcat.
Experimente online!
fonte
Bash + coreutils,
269262261 BytesUm 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!
fonte
echo
comando e um pipe, tornando-obase64 -d<<<...|gunzip
Python3,
921 916 752 751 539 534476 bytesE aqui está uma versão justa obrigatória. Eu usei um script para contar os caracteres individuais, deve ser idêntico:
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:
Falha no Python3 abusada, 167 bytesJá 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.
fonte
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.print(input())
MarioLANG ,
3287 32863285 BytesEu 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.
fonte
Pitão , 211 bytes
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 dea-f
. Depois, o comprimento da execução codifica a coisa toda (aaaaaccc
->5a3c
etc.) e, em seguida, compacta usando o zlib.A cadeia compactada é
fonte
Bash , 486 bytes
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.
fonte
Perl,
422396370366365 caracteresDuração codificada em 2 etapas: caracteres consecutivos e padrões consecutivos de vários caracteres.
Experimente online!
fonte
PHP,
608565557 bytesUtiliza GMP, a
5kJvr...
sequência foi criada usando primeiro substituições para converter o original em base56 e, em seguida, GMP para converter em base 62.Execute online.
fonte
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
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.
fonte
print(line1,line2,...,sep='\n')
C,
114210681044 bytesNã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.
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
Experimente online aqui .
Ungolfed (ish)
fonte
s,a,h,d,m,
desde o início, aqueles serão implicitamente declarados comoint
s quando você os inicializar imediatamente depois.for(;i++>n;)
permitirá que você evite escreveri
novamente dentro do loop.putchar('\n')
->putchar(10)
para raspar mais alguns bytes. Também parece que você tem um estranho;
em suaz
função.i
completamente. Em vez de um loop for, façawhile(n--)
x()
para o topo, você pode terc()
eo()
chamá-lo para salvar alguns bytes.x()
pode demorarint*
, pois todos os ponteiros tendem a ter o mesmo tamanho e imprimir usandoprintf(c)
para salvar mais alguns bytes. Duas funções podem ser abreviadas um pouco:n(){p(10,1);}
ep(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());
.Python ,
340378 bytesEu estraguei a codificação na resposta original, aqui está uma baseada na compactação LZW. Pode revisitar minha resposta original em algum momento.
Experimente online!
fonte
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
fonte
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). Ot
deve ser colocado no mesmo diretório que o script.Experimente online!
O script powershell para criar o arquivo tar
t
:fonte
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 ...
Explicação: o filtro substitui
S
por" "
e um número porx(num) .
, por exemplo,S14
torna-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
.fonte
s/regex/replace/g
sintaxe nativamente?e
modificador de regex necessário aqui para executar o operador x após a substituição - mas agora sim: DSOGL V0.12 , 971 bytes
Simplesmente copiei toda a corda no compressor. Percebi que a corda não era muito comprimida.
Experimente aqui!
fonte