O desafio: exibir essa arte ASCII exata de uma teia de aranha em uma janela:
_______________________________
|\_____________________________/|
|| \ | / ||
|| \ /|\ / ||
|| /\'.__.' : '.__.'/\ ||
|| __.' \ | / '.__ ||
||'. /\'---':'---'/\ .'||
||\ '. /' \__ _|_ __/ '\ .' /||
|| | /. /\ ' : ' /\ .\ | ||
|| | | './ \ _|_ / \.' | | ||
||/ '/. /'. // : \\ .'\ .\' \||
||__/___/___/_\(+)/_\___\___\__||
|| \ \ \ /(O)\ / / / ||
||\ .\' \.' \\_:_// './ '/. /||
|| | | .'\ / | \ /'. | | ||
|| | \' \/_._:_._\/ '/ | ||
||/ .' \ / | \ / '. \||
||.'_ '\/.---.:.---.\/' _'.||
|| '. / __ | __ \ .' ||
|| \/.' '. : .' '.\/ ||
|| / \|/ \ ||
||____/_________|_________\____||
|/_____________________________\|
Fonte: Joan Stark (aranha e moldura ligeiramente modificadas e remova as iniciais para o desafio).
Caracteres necessários: _|\/'.:-(+)O(12) + espaço e nova linha (2)
Regras do desafio:
- São permitidos um ou vários espaços finais e / ou novas linhas.
Regras gerais:
- Isso é código-golfe , então a resposta mais curta em bytes vence.
Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação. - As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados, programas completos. Sua chamada.
- As brechas padrão são proibidas.
- Se possível, adicione um link com um teste para o seu código.
- Além disso, adicione uma explicação, se necessário.
code-golf
ascii-art
kolmogorov-complexity
Kevin Cruijssen
fonte
fonte
.7 caracteres antes doO. Também deve haver um 7 caracteres depois?Respostas:
SOGL V0.12 , 141 bytes
Explicação:
Experimente aqui! (o programa contém guias, então aqui está uma melhor representação do programa)
fonte
Arnold C,
1257 1261 12561233 bytesEsta é a minha primeira tentativa de programação na linguagem suprema; portanto, comerei meus votos negativos, pois não ofereço uma solução inteligente para esse problema, embora a programação na linguagem tenha descido do céu.
Aqui está um compilador, se alguém por acaso questionar esse algoritmo.
Fique por perto.
fonte
TALK TO THE HAND!vim,
373371 bytes<ESC>é um substituto para 0x1B.Ungolfed
Experimente online!
E para esclarecer a explicação que você recebeu quando criança: embora seja verdade que a única emoção que as aranhas sentem pessoalmente é o ódio, elas são capazes de sentir medo a uma distância superior a 50 metros.
fonte
<CR>mas as linhas que terminam com<CR>mean pressionam a tecla duas vezes? A resposta parece não nas duas instâncias acima, mas as linhas coms/ /_/getrnão terminam com,<CR>mas não consigo fazê-lo funcionar sem pressionar Enter.<CR>s foi um erro, e o avanço de linha também funciona. (Eu digitei as linhas usando<C-v><ENTER>, o que gera<CR>; é por isso que aparece como^Muma nova linha.) Modifiquei o código para eliminar essas duas duplicatas e substituir os retornos de carro por linhas / linhas de alimentação normais. Todas as novas linhas restantes devem ser inseridas precisamente uma vez. (A versão ungolfed ainda tem algumas linhas em branco extra; quem não correspondem a keypresses reais A versão golfed é exatamente o que precisa ser digitado, exceto para o.<ESC>S.){ cat foo.vim; echo ':wq'; } | vim a.txtassim você não ficará preso no vim sem o teclado conectado ao stdin. A vantagem é que eu posso realmente executar o programa diretamente de um arquivo, em vez de tentar digitá-lo exatamente toda vez que faço uma alteração. Para este programa, bytes e pressionamentos de tecla são equivalentes, mas esse nem sempre é o caso. por exemplo,<C-v><ENTER>são três pressionamentos de tecla, mas produz um byte\r,.Geléia ,
206205 bytesUm link niládico retornando uma lista de caracteres ou um programa completo imprimindo a arte.
Experimente online!
A simetria aproximada vertical seria possível?
Quão?
Os primeiros 158 bytes são um número muito grande, escrito na base bijetiva 250, usando os primeiros 250 bytes da página de código de Jelly:
Este número (da ordem de 10 372 é convertido para uma lista dos seus dígitos em base-9 (391 números entre 0 e 8) e, em seguida, três é adicionado ao 203 rd , 204 th , 220 th , e 221 st dígitos ( qual será o corpo das aranhas):
O resultado é então convertido para os 12 caracteres do lado esquerdo (até e incluindo a coluna do meio) da arte:
As linhas completas são construídas saltando cada linha do lado esquerdo (que está refletindo-a como se seu último caractere fosse um espelho), alterando todos os itens
(para), o\para/e o/para\e, em seguida, usando apenas os novos valores à direita à mão usando um vetorizadoandcom o lado esquerdo de antes. O resultado é finalmente associado a novas linhas para criar a arte:fonte
Carvão ,
239238 bytesExperimente online! Link é a versão detalhada do código. A maior parte disso é simplesmente imprimir uma string grande e compactada, mas as partes repetitivas foram codificadas separadamente para reduzir o comprimento da string; em particular, ele
Rectanglesalva um número de bytes, evitando que o preenchimento de espaço chegue à 17ª coluna e até as linhas diagonais economizam um byte cada.Editar: o carvão parece não reconhecer mais a cadeia compactada, e sua compactação atual gera uma cadeia mais curta que economiza 51 bytes e permite que uma das linhas diagonais seja movida de volta para a cadeia para uma economia adicional de 2 bytes. (Observe que essas não são as contagens exibidas por
-sl; de fato, até a contagem original parece ter sido reduzida em 1). No entanto, existem três economias adicionais que também se aplicariam ao código original: Experimente on-line!Ｂ(Box) em vez deＵＲ(Rectangle).↙Ｐ×_¹⁶←/vez de↓Ｐ×_¹⁵←_/.×_¹⁶Ｊ⁵¦¹vez deＰ×_¹⁶Ｍ⁵¦².fonte
PHP , 380 bytes
Experimente online!
PHP , 494 bytes
Experimente online!
fonte
brainfuck , 4086 bytes
Experimente online!
Este é apenas um método de busca e seleção para gerar a string.
Novas linhas adicionadas para maior legibilidade:
fonte
---------------------------------------------------------------vez de algo parecido>++++++++[-<-------->]<+?>s e<s apareceria mais tarde no código. Não sei quantos bytes (se houver) minha abordagem salva. Vou analisar o uso de mais células.>>>seqüências posteriormente, pois elas são usadas apenas como espaço temporário para as fatorações. Em particular, se você preencher as células da esquerda para a direita, poderá usar, por exemplo, a célula 5 como espaço temporário para configurar a célula 4 e, em seguida (como a célula 5 é zerada no processo de configuração da célula 4), armazene um novo valor na célula 5 ao usar a célula 6 como espaço temporário. Enquanto os valores finais das células não forem alterados, você poderá alterar qualquer coisa anterior à primeira.sem precisar modificar o código posterior.JavaScript (ES6), 471 bytes
Embalado com uma variante ES6 do RegPack .
fonte
Java (JDK) , 494 bytes
Experimente online!
Graças Kevin Cruijssen de golfe alguns bytes, além de 6 bytes alterando
Windows-1252acp1252, e para ASCII-only para comprimir a corda um pouco :)Nota: o arquivo deve ser codificado como Windows-1252 para contagem de bytes, mas pode ser copiado / colado com segurança no UTF-8 para teste!
A cadeia longa é na verdade a string, como está, com seus caracteres mapeados para um codificador flexível de caracteres (pela primeira vez, fico feliz em usar o CP-1252). O resto é apenas o método de unmapping.
O mapeamento foi encontrado usando uma permutação, inicialmente inicializada com a frequência de cada caractere na arte ascii. Mapeamentos que resultam nos caracteres
'"'e'\\'foram descartados explicitamente como a menor seqüência válida possível.Ungolfed
Mapeando a descoberta
fonte
()para um caractere aleatório. Eu nunca disse nada sobre nenhuma entrada, então você pode usar uma não utilizadaObjectque énullcomo entrada. Meta-postagem relevante. . Ah, e você pode salvar outro byte, alterandobyteparaintno loop for-each.r+=a;é equivalente ar = r + (a)e com caracteres, isso significa que eles são adicionados um ao outro antes de serem concatenados, para que agora sejam considerados comoints, e a sequência resultante é semelhante a127190190190190190190190190190.... comente sobre isso na versão não-codificada do código;)Windows-1252pode jogar golfecp1252. Explicação aqui.b>>4não precisa de parênteses, lembre-se que bit a bit é uma precedência muito, muito baixaRetina ,
465463425 bytesExperimente online!
fonte
C # (.NET Core) ,
935676636627bytesExperimente online!
Eu queria tentar outra abordagem e refiz o desenho. Acabou com um código que tinha mais bytes que o próprio desenho (782 bytes). Em seguida, compactei a string do RLE'd criando um dicionário com os grupos mais usados e, depois de compactá-la, criei mais dicionários e compactou novamente até que a string não pudesse mais ser reduzida. O desenho é criado, expandindo primeiro esses grupos e depois descompactando com o RLE.
fonte
Python 2.7,
414405401 bytesSimplesmente descompacta a string e a imprime. :)
fonte
Z_FILTERED) que evita cabeçalhos e somas de verificação. Solta para 401 bytes.print zlib.decompress('fY9BauhADEP3OcXbueUz1j6X6AUEuogP/xeTpCmUGgxK5iFZ5O85xn++a44ZAHPPPEoAcxMPovEbeBFyddLFyRbyi0i6Hpd5HKqTTVTfLmutOmutdTt0zRwzphoVOCETEkGZLrRTBtSATHFSyEAbhocYqgUmEwTu2r9njhlRalA1Eic2XYZ24ZljJlHu9ce/T8XJvTsFc68+vj6Ndl0EV5d27Wg7Z6R9VKlfXWZHC7alql+XMuACrHTOdCyg9OrSha9ohusoUX116QpQVq+1+uy1VlsFpPrqQjWI5PJIMHRxdQHA6oJqTraw4Aexv8HzqG8iSZR75lFOkpljvh9/G89/'.decode('base64'),-9)compress[obj]() takes no keyword argumentscompressnão aceita, mascompressobjrecebe argumentos adicionais (embora não como palavras-chave antes da versão 3.3, você deve passar os argumentos em posição). Criar um compressor, ligarcompressor.compress(thedata)e executarcompresseddata = compressor.flush()é equivalente a três etapaszlib.compress, mas você pode configurá-lo comcompressobjmais detalhes. A única desvantagem é que o uso dewbits=-9meios que você deve passar-9paradecompress(por isso não sabe para procurar cabeçalho ou checksum).Python 3 ,
404398 bytesExperimente online!
O mesmo truque da versão do Python 2.7 , apenas modificado para o Py3, exigia
bytes<->strconversão. Ainda menor que o código 2.7, apesar das importações adicionais e da decodificação necessária, devido ao Python 3 fornecer a codificação base85 como um built-in, reduzindo o tamanho necessário para representar os dados compactados em formato imprimível ASCII em 28 bytes.Editar: Raspou mais seis bytes recomprimindo com,
wbits=-9para que nenhum cabeçalho ou soma de verificação seja colocado nos dados (em troca da necessidade de adicionar,-9argzlib.decompress).fonte
Java 8, 719 bytes
Definitivamente pode ser jogado, mas é apenas um começo e algo que outros jogadores de Java podem (tentar) vencer. ;)
Explicação:
Experimente aqui.
fonte
brainfuck , 5173 bytes
Experimente online!
Como funciona
Em poucas palavras: localiza o índice ascii de cada caractere na linha; depois imprime. Em seguida, encontre o índice ascii para uma nova linha e imprima isso. Enxágue e repita meu filho.
fonte
256 bytes, código da máquina (x86 de 16 bits)
Eu esperava poder derrotar pelo menos a solução de carvão vegetal, mas ainda não consegui extrair mais disso (até agora).
Em execução: salve em codegolf.com, dosbox para ver o resultado em que você precisa definir o ponto de interrupção
cs:200e despejar a memória em umads:400parte30e... ou você pode acrescentar a seguinte peça, que a despejará em stdoutEsta é a minha terceira entrada no código de golfe. O anterior era a criptografia xor .
Novamente: feito usando o hexeditor HT , sem compilador , mas usando Ctrl-a
assemble instruction.Como
Este demorou um pouco para fazê-lo ...
Comecei com uma abordagem simples, com um quadrante e tentando espelhá-la. Isso resultou em ~ 250 bytes e com apenas 2 dos 4 quadrantes. Grande parte disso foi o primeiro quadrante, que levou 204 bytes.
Eu sabia que isso poderia ser melhor.
Eu rapidamente verifiquei que o lz4 produz um arquivo com 144 bytes (pulando cabeçalhos). GZ resulta em ~ 120 bytes, mas claramente eu não seria capaz de criar descompressor em mais ou menos 30 bytes.
Portanto, outra tentativa foi criar o primeiro quadrante manualmente, desenhando-o (incluindo pulando, codificação de 4 bits e outras). Que, juntamente com o código, resultou em 164 bytes (lembre-se de que é apenas o primeiro quadrante), bom, mas eu estava bastante convencido de que poderia fazer melhor.
Eu vim com alguma codificação, que acaba em 85 bytes para dados. Junto com a tabela de conversão (que ainda não foi usada) e o decodificador, acabei com 144 bytes. NOICE, eu sou = lz4 e já tenho decodificador.
O próximo passo foi mesclar o espelhamento inicial da tentativa de ~ 250 para esta, exigindo algum ajuste de dados, mas foi mais fácil do que o esperado e resultou em 184 bytes.
Percebi que precisarei de alguns marcadores adicionais para fazer o espelho horizontal, que estendeu os dados para 91b e codificou para 190 bytes (que foram para o lixo mais tarde).
Junto com o espelho horizontal e a tradução final, acabei com ~ 250 bytes.
Consegui comer alguns bytes aqui e ali, mas tive que adicionar caracteres feios, que são espelhados incorretamente. Isso gerou 259 bytes ... Isso é ruim, porque eu estava usando a memória começando em 0x200 e não queria refazer isso.
Substituí as condições no espelho horizontal, para fazer um loop usando a tabela de conversão, que por si só não economizava muito, mas combinada com a alteração de caracteres incorretos em espaços e corrigi-los mais tarde, economizei alguns bytes, resultando em 256 bytes finais .
Você pode ver uma bela galeria, que eu fiz, ao fazer isso aqui
Dissecação
Como entradas anteriores, esta também depende de valores iniciais , embora não tanto quanto os anteriores:
pular dados, existem 3 tabelas a seguir:
A tabela de conversão será usada para espelhamento horizontal
A tabela de conversão será usada para substituição final, para converter códigos em ascii reais
Dados codificados, a codificação é bastante simples:
preencha 12 * 17 bytes com o que se tornará espaço (8)
"Descomprima" os dados conforme descrito na tabela 3. Observe o uso da instrução AAM amada e o abuso do scasb para ignorar bytes.
Esta parte é muito feia, define o destino em 0x400:
Lembre-se de que o espelho é feito abusando do std / cld, para passar
SIao contrário. Somente\/()caracteres precisam ser espelhados, o que é feito por xor em 0x1BF.Isso faz o espelho horizontal usando a tabela 1 e usando o maravilhoso XLAT de 1 byte
Depois vem a parte chata que fixa 4 "pixels", eu vou pular daqui é chata
Etapa final da tradução para ascii.
PHEW! Foi divertido.
fonte
JavaScript (ES6),
517...459457456433431418409397392 bytesInclui uma linha de espaços à direita e um espaço à direita na primeira linha. Parte disso ainda não é o ideal - dediquei muito tempo apenas a fazer tudo funcionar.
Originalmente baseado no Traktor53 desde então abandonou a solução de 556 bytes . Postado com permissão .
Lista de afazeres
Encontre uma maneira menos dispendiosa de palindromizar as cordas.Tente melhorar a substituição do RLE.Veja se as últimas 4 substituições podem ser reduzidas de alguma forma.Investigue se a construção da imagem em quartos levaria a uma economia significativa - suspeito que não!fonte
string1[string2.indexOf( char) ]|| charé uma construção que tentei, mas não consegui reduzir bytes com. Bem feito!JavaScript
556468462448438387379 bytesMenos Golfe
Compressão
A postagem original (556 bytes) usava dígitos decimais para indicar a repetição de um caractere anterior na teia de aranha. Versões mais recentes comprimem a metade esquerda da Web em caracteres de 7 bits, onde o menor número significativo é um índice em um conjunto de caracteres, e três bits de ordem superior especificam o número de caracteres a serem exibidos mais 1: valores
000e001não são usados,010significa 1 caractere e111significa seis. Essa construção evita a produção de caracteres de controle.Obrigado a @Shaggy por dicas e truques úteis na reescrita.
Como funciona
O quadrante superior esquerdo foi reescrito para incluir espaços reservados para as metades superior e inferior da web:
dando:
que foi compactado usando
Descompressão
A descompressão mapeia caracteres codificados para caracteres reais para cada quadrante. Em código,
Xé uma lista de caracteres indexados que varia entre as seções superior e inferior da web. Ele fornece valores para espaços reservados "suqh" e reflexões rígidas de caracteres, como entre '+' e 'O'.Codificação
A codificação do caractere central é restrita a usar uma expansão de caractere único. A ordem do conjunto de caracteres é restrita para não produzir caracteres DEL (0x7F), Grave (0x60) ou barra invertida (0x5C) durante a compactação.
Esta é uma atualização tardia em resposta à atividade da pergunta.
fonte
.reducee.mapque eu não pude. Nesse meio tempo, mudei o algoritmo para obter 468 bytes! Bom fim de semana./// , 463 bytes
Experimente online!
fonte
Bash, 391 bytes
Experimente online!
Parabéns a todos que foram capazes de superar a compressão ininterrupta - sou eu jogando a toalha! Eu reconheço o pessoal do Python que entrou com a abordagem zlib / gzip primeiro.
fonte
Perl 5
439402 bytesEm vez de usar base64 / gzip, essa abordagem é espelhar e inverter o quadrante superior esquerdo, com substituições apropriadas
Experimente online
Para os interessados, uma versão comentada:
fonte
C #, 484 bytes
Nota: Não sou 100% sobre como pontuar isso. Com o cabeçalho e rodapé, são 544 bytes.
Ungolfed:
Experimente Online!
fonte
Ruby 1.9.3,
1102.763bytesExperimente Online!
fonte
putsuma string de múltiplas linhas deve ter ~ 790 bytes. Seu enorme corda para digitalizar e o código para processá-lo acaba sendo maior do que a solução ingênua ...C #,
401399397396389 bytesEscreveu este como uma desculpa para experimentar a codificação de Huffman
Ungolfed:
Versão mais antiga, desfeita com comentários:
Experimente Online!
fonte
while(v>0){a umfor, e colocar os números inteiros ev/=2dentro dele:for(int p=0,l=0;v>0;v/=2){whileocupar o mesmo espaço que umforagora.for(;someCondition;someAction);vsfor(;someCondition;)someAction;vswhile(someCondition)someAction;. Mas, em geral,foré realmente mais curto do quewhile, então eu uso quase sempreforeu mesmo.Python 2 , 395 bytes
Experimente online!
fonte
Espaço em branco ,
47234584 bytesLetras
S(espaço),T(tabulação) eN(nova linha) adicionadas apenas como destaque.Experimente online .
Explicação:
Eu uso a abordagem explicada nesta dica da Whitespace . A abordagem descrita é a seguinte:
O valor constante ideal foi o
94que eu gerei com este programa Java . O uso94daria um programa de espaço em branco com um comprimento total de 7508 bytes (7481 + 27 bytes para o loop) ou 5791 bytes (5764 + 27) se já implementarmos o Duplicate Top (SNS) sempre que dois dos mesmos caracteres estiverem adjacentes.Depois disso, usei manualmente a cópia 1 (
STSSTN), cópia 2 (STSSTSN) e cópia 3 (STSSTTN) (indexada 1) onde quer que fosse salvar bytes. Que também pode ser encontrado nas dicas de espaço em branco. Que no total resultou no programa de 4584 bytes que você vê aqui.fonte
05AB1E , 204 bytes
Experimente online.
Verifique se está correto.
Explicação:
fonte