Em homenagem a Adam West


90

Adam West faleceu, e eu gostaria de honrar sua memória aqui no PPCG, embora duvide que ele soubesse de nossa existência. Embora existam muitas coisas diferentes pelas quais esse homem é conhecido, nenhuma é mais proeminente do que seu papel como o batman original . Eu sempre me lembrarei do meu padrasto ainda assistindo o Batman e Robin da velha escola até hoje. Esse desafio é de natureza simplista, nada alinhado com o homem complicado que era Adam West. No entanto, é o melhor que pude apresentar, pois esta é a imagem mais icônica da carreira do homem.


Eu queria postar isso antes, mas estava esperando alguém aparecer com algo melhor.


Saída o seguinte (com ou sem espaços à direita / novas linhas):

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **

Isso é , a menor contagem de bytes vencerá.


7
Você deve proibir seqüências de caracteres codificadas. Realmente não é divertido!
sergiol

7
Ele não era o Batman original. Essa honra pertence a Lewis Wilson.
Shaggy

42
Quando vi o título, pensei que o resultado seria "na-na-na-na-na-na-na-na-na-na-na-na-na-na-na-na-na".
D Krueger

3
@DKrueger: torná-lo assim em outra pergunta :)
Olivier Dulac

4
Por que isso não começou no ano passado? Carrie Fisher, príncipe, David Bowie e Alan Rickman!
caird coinheringaahing

Respostas:


47

Geléia , 44 bytes

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ߌÆ@Ƥ’b25o99Jx$ị⁾ *s25ŒBY

Experimente online!

Como funciona

“¡©İ'¹!ðkW>ṅṙẏṙlœf:ߌÆ@Ƥ’

Este é um literal numérico. Todos os caracteres são substituídos por seus índices baseados em 1 na página de códigos de Jelly, o resultado é interpretado como um inteiro bijetivo base-250, resultando em

58616171447449697510361193418481584558895594063391402

Em seguida, b25converta esse número inteiro na base 25 e o99substitua 0 por 99 , produzindo

11 1 20 4 10 1 8 4 12 4 3 6 12 4 2 9 9 5 1 99 1 24 2 5 7 11 4 4 7 3 4 3 7 2 7 1 6 2

Jx$substitui a j- ésima base-25 dígitos n por n cópias de j , produzindo

1 1 1 1 1 1 1 1 1 1 1 2 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 7 7 7 7 7 7 7 7 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 11 11 11 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 14 14 14 14 15 15 16 16 16 16 16 16 16 16 16 17 17 17 17 17 17 17 17 17 18 18 18 18 18 19 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 21 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 22 23 23 24 24 24 24 24 25 25 25 25 25 25 25 26 26 26 26 26 26 26 26 26 26 26 27 27 27 27 28 28 28 28 29 29 29 29 29 29 29 30 30 30 31 31 31 31 32 32 32 33 33 33 33 33 33 33 34 34 35 35 35 35 35 35 35 36 37 37 37 37 37 37 38 38

Agora, ị⁾ *indexa o par de caracteres. A indexação é baseada em 1 e modular, portanto, números ímpares são substituídos por espaços, mesmo números com asteriscos. Isso gera

           *                    ****          *        ****            ****   ******            ****  *********         ***** *************************************************************************************************** ************************  *****       ***********    ****       ***    ***       **       *      **

s25corta o resultado em pedaços de comprimento 25 . Se escrevermos cada pedaço em sua própria linha, obteremos

           *             
       ****          *   
     ****            ****
   ******            ****
  *********         *****
 ************************
*************************
*************************
*************************
 ************************
  *****       ***********
    ****       ***    ***
       **       *      **

O átomo de rejeiçãoŒB palindromiza cada pedaço anexando uma cópia invertida sem seu primeiro caractere, produzindo

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       

Por fim, Yapresenta os feeds de linha reais.


11
E eu pensei que “QƤḣọḲ£¿ẆịµñẒṢƊ¬ƒỤ2ỴÐ,ịṁ&Ḅ<ḋsḳn.⁷ṛḃṡ⁾6bḋeṁ’ṃ⁾ *s25ŒBYera curto o suficiente em 53 bytes ...
Erik o Outgolfer

Tentei 14 coisas diferentes e finalmente cheguei a isso por tentativa e erro. Não entendi o que você quis dizer com "substitui 0 por 99" até que eu tentei.
Magic Octopus Urn

156

Wordfuck , 5761 2686 bytes

Acho que usar o nome dele como código-fonte dá a Adam West alguma honra.

adam west adam west adam_wes t_a dam_we st_a dam_ west adam west adam west adam west_ad am_west_a dam_we st ad am we st ad am we st ad am west_a dam_we st_a dam_ west_ada m_w est ada m_w est ada m_west_ adam west_a dam_west_ adam_we st_ ad am_west ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_w est_ adam west adam west adam west adam west adam we st_adam west_ad am we st ad am we st adam_w es t_ ad am west_ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am west_a da m_ we st adam_w es t_adam_ west_ad am we st ad am west_a da m_ we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am we st adam_we st ad am we st ad am we st ad am we st_ada m_ we st ad am_wes t_ adam_we st_adam we st ad am_wes t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st ad am_west ad am we st ad am we st ad am we st adam_w es t_ ad am we st adam_w es t_adam_ west_ad am we st_ada m_ we st ad am we st ad am west_ad am we st ad am we st ad am west_a da m_ we st ad am we st ad am_west ad am we st ad am we st ad am_wes t_ ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am west_a da m_west_ ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am_wes t_ adam_we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st adam_w es t_adam_ west_ad am west_a da m_ we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st ad am we st_ada m_ west_ad am_west ad am west_a da m_ we st ad am_west ad am we st ad am we st_ada m_ we st ad am we st ad am we st ad am we st ad am we st ad am west_ad am we st ad am we st adam_w es t_ ad am we st_ada m_ west_ad am_west ad am we st adam_w es t_ ad am west_ad am we st ad am we st adam_w es t_ ad am_west ad am we st adam_w es t_ ad am we st_adam we st ad am west_a da m_ we st_adam we st ad am we st ad am_wes t_ ad am we st_ada m_ west_ad am_west ad am we st ad am we st_ada m_ we st_adam we st ad am we st ad am_wes t_ adam_we st ad am we st ad am_wes t_ ad am west_ad am we st ad am we st_ada m_ west_ad am we st ad am we st adam_w es t!

Experimente online! (brainfuck transpilado)

Adam West cantando (obrigado @carusocomputing)


69
Isso é terrível. Eu amo isso.
precisa

25
Hmm. Sim. Muito bom, mas eu acho que você esqueceu um sublinhado na linha 1.
Mateen Ulhaq

2
Existe uma maneira de testar isso?
Shaggy

4
@Wilf bem-vindo ao PCCG! nós realmente não competimos neste site, é claro que essa não é a solução vencedora, mas é temática hilariante e desafiadora, para que seja votada para que mais pessoas possam aproveitar. Na esperança de votar em breve suas respostas!
Uriel


67

Pitão, 530 529 528 524 bytes

import zlib as Holy
B=list("NNAAAnAAnnAnaAannnaaaaNaAAnNanAaAanNNaNNaNaanNNANanNNANaAnAaANANAAnAaANNnAanAaNnAaAANNAaAnNANAaaANNAanAaNaNNNAaNNanAAnNNnaaaNANANANnnaaaNaaAAAANaNaNaNAnNAAAAaaaaANAaNnnAaAaNAAaANNnaaNnNnaannaaAaananannNnAAAAAanAananANAnaAAnANAAaaaAaaanaaAAaanNAnanAAnnnANAnNAnnAnnnanaNNaaaNaNNaAAnNAaaANNNANAnAaaAaNaANnNNNaaAanaaaanaaaaaAaAaNnNnnaAnANaNnnANanNA")
A=dict(N='11',A='01',n='10',a='00')   
T=""
POP=BIFF=POW=OOF=lambda:A[B.pop()]
while B:T+=chr(int(POP()+POW()+BIFF()+OOF(),2))
print Holy.decompress(T)

5
Oh senhor, eu não ri tanto assim por um tempo. NAanANANaNANaNAANnAnaNANanaNA
Magic Octopus Urn

9
No golfe código, estamos supostamente para tornar o byte contar pequeno, mas sua entrada é bastante robusto . ;)
PM 2Ring

34
Na ocasião, é preciso fazer sacrifícios pelo bem maior.
rrauenza

11
Parece algo que o Batman diria. ;) Tenho que admitir que acho o B.pop(0)pouco chato. Por que não reverter Bpara que você possa usar o muito mais eficiente (e mais curto) B.pop()? Ele pop(0)precisa mover todos os elementos restantes da lista para um slot. Claro, isso acontece na velocidade C, mas ainda é menos eficiente do que sair do final da string.
PM 2Ring

5
Os aliases para POP, BIFF, POW, OOFme fez cuspir para fora o que eu estava bebendo no meu monitor. Graças lol. +1.
rayryeng

21

JavaScript (ES6), 148 146 bytes

_=>`n2zh2
f8l2b2l8
b8pep8
7cpepc
5ijiji
3yyq
0
0
0
3yyq
5afy8fa
98f69a96f8
f4f2d6d2f4`.replace(/./g,c=>'* '[(n=parseInt(c,36))&1].repeat(n/2||49))

Demo


12

Python, 149 142 bytes

7 bytes salvos graças a @ PM2Ring

for l in"b1d 74a13 54c4 36c4 2995 1o 0p 0p 0p 1o 257b 447343 727162".split():x=''.join(s*int(k,36)for s,k in zip(' *'*3,l));print(x+x[-2::-1])

Agradável. Você pode cortar 7 bytes:x=''.join(s*int(k,36)for s,k in zip(' *'*3,l))
PM 2Ring

Não se preocupe. Consegui escrever uma versão Python ainda mais curta. ;)
PM 2Ring

11
@ PM2Ring você conseguiu o meu +1
Uriel

12

MATL , 61 59 bytes

' *'60:'*u9|K9j[~F9R,>ejc4Q,7;F\1l_=7sFR'F11:ZaY"13e)25ZvZ)

Experimente online!

Como funciona

Isso usa as seguintes técnicas padrão:

  • Como a imagem é simétrica horizontalmente , apenas a metade esquerda (incluindo a coluna central) é codificada.
  • A imagem é linearizada na ordem principal da coluna (para baixo e depois para o outro lado) e a sequência resultante é codificada no comprimento da execução .
  • Os comprimentos de execução resultantes levam valores de 1para 11, portanto, a sequência de comprimentos de execução é compactada pela conversão de base , de base 11para base 94(caracteres ASCII imprimíveis, exceto aspas simples, que precisariam ser escapados).

11
Existem 60 execuções na ordem principal da coluna, mas apenas 38 na linha principal. Isso salvaria algum bytes?
Dennis

@ Dennis O problema é que, nesse caso, os comprimentos de execução são [1:12 20 24 99], o que dificulta a compactação. Minha melhor tentativa é de 60 bytes
Luis Mendo

Em vez de construir o conjunto exato, você tentou simplesmente usar a base 25 e substituir 0 por 99 por, por exemplo Y|,? Eu não sei o suficiente atm MATL para testar se isso é realmente mais curto ...
Dennis

@ Dennis Isso parece promissor. Usando o conjunto [1:24 99], removi um byte . Se eu usar [0:24](base 25) Eu não sei como transformar 0em 99em alguns bytes
Luis Mendo

11
Right Y|não funciona no MATL / Octave, como no Jelly / Python. Neste último, 0 or 99produz 99 ...
Dennis

7

05AB1E , 47 bytes

„ *19×S•«M;Ó8ζ?èYÑ?½¨/Ž´.δòÈÖ<•25вт<19ǝ×J13ä€û»

Experimente online!


Portado o algoritmo de Dennis, certo?
Erik the Outgolfer

@EriktheOutgolfer: pegou emprestado replace 99 trickdele (salvou 4 bytes pelo caminho direto). Ainda estou procurando uma maneira melhor.
Emigna

-1 usando em .∞vez de €û»(espelhos ingressar implicitamente em listas em novas linhas primeiro na versão herdada, antes de aplicar o espelho). Eu também tentei usar ₂вem vez de 25в, mas infelizmente o número inteiro comprimido é então 1 byte mais tão bem, por isso não salvar nada: •2Ø°×á[1∊Œ)’˜Àå<тIÞ‡p5ÉQ•₂в.
Kevin Cruijssen

7

vim, 168 156 bytes

:nm N a <C-v><ESC>
:nm A a*<C-v><ESC>
:nm B aY<C-v><ESC>yyp!!rev<C-v><CR>kJh4xo<C-v><ESC>
11NA13NB7N4A10NA3NB5N4A12N4AB3N6A12N4AB2N9A9N5ABN24AB25ABkyyppjN24AB2N5A7N11AB4N4A7N3A4N3AB7N2A7NA6N2ABdd

Isso pressupõe um ambiente Unix, para rev. I usar um bastante simples (contagem, de caracteres) que codifica, com N e A anexando um e *, respectivamente, e B fazendo a cópia e reverso.

No arquivo real, as entradas entre colchetes são substituídas pelos bytes literais que representam. <C-v>é 0x16, <ESC>é 0x1b e <CR>é 0x0d.

Experimente online


Eu acho que seria mais rápido não se incomodar em criar macros 'b' e 'c' e, em vez disso, remapear diretamente. :nm N a <C-v><esc>e:nm A a*<C-v><esc>
DJMcMayhem

@DJMcMayhem É o que faz. Por alguma razão, achei que seria mais difícil armazenar o <C-v>arquivo em um arquivo do que é, então usei o método de rotatória para testá-lo { cat foo.vim; echo ':wq'; } | vim out.txt. Não sei por que não me ocorreu tentar <C-v><C-v>ontem.
Ray

Fico feliz em saber que você conseguiu! Outra maneira de testar as respostas do vim por conveniência é Experimente on-line! , que realmente usa um esolang que escrevi, mas é (principalmente) compatível com versões anteriores. A -vbandeira permite que você use descrições principais vim (como <C-v>e outros enfeites)
DJMcMayhem

@DJMcMayhem Very nice. Obrigado.
Ray

Você não pode escrever em <NL>vez de <NEWLINE>?
L3viathan

7

Carvão , 69 54 52 48 bytes

E⪪”|↖y{{﹪yc›o”n↗πf>T≔Y¿PN|ωπQβ” ⪫Eιק* μ⌕βλω‖O←

Experimente online! Link é a versão detalhada do código. Editar: Graças a @ ASCII-somente, salvo 4 bytes por comutação de um sinalizador separado para loop sobre índices, 7 bytes, utilizando o (não documentada?) ⸿De caracteres, e mais 4 bytes, utilizando o alfabeto para a codificação de comprimento de percurso. Salvou mais 2 bytes porque AtIndexassume automaticamente o módulo. Salvou mais 4 bytes porque Mapcria automaticamente uma variável de índice. Explicação:

Print(Map(

O externo Mapretorna uma matriz. Printlida com isto, a impressão de cada elemento na sua própria linha, evitando ter que manualmente Joinos com \n.

Split("anb adbke eme fjj y z z z y lhf dedhe cgbhc" " "),

A sequência codifica todas as meias linhas da saída. Letras alternadas referem-se ao número de se *espaços ( a=0é usado para manipular uma linha que começa com um espaço). O espaço é uma escolha conveniente de delimitador, mas também é compactado bem (x também é compactado para 55 bytes gerais). Cada linha é processada separadamente. (Nota: o deverbosifier falha ao remover o separador entre uma sequência compactada e não compactada, caso contrário, o código teria uma ,legibilidade.)

Join(Map(i, Times(AtIndex("* ", m), Find(b, l))), w)));

Faça um loop sobre cada letra, expandindo para o número apropriado de *s ou espaços. A variável mé o índice do loop interno para isso Map, enquanto lmantém a letra. O resultado é Joineditado em uma única sequência usando a sequência vazia predefinida w.

ReflectOverlap(:Left);

Depois que todas as linhas forem impressas, reflita tudo à esquerda, sobrepondo a coluna do meio.

Tentei manipular as novas linhas, espaços e estrelas em um único loop, mas na verdade foram necessários mais dois bytes desta maneira:

Print(Join(Map("anb adbke eme fjj y z z z y lhf dedhe cgbhc", Ternary(Equals(" ", i), "\n", Times(AtIndex("* ", k), Find(b, i)))), w));
ReflectOverlap(:Left);

11
+1 Eu realmente preciso aprender Carvão Vegetal (assim como Hexagony e Cubix). Três das minhas linguagens de programação favoritas que vejo aqui. Btw, eu acho que você já estava planejando, mas você poderia adicionar uma explicação?
Kevin Cruijssen

@KevinCruijssen Hmm, acho que até o código detalhado precisa de alguns esclarecimentos ... isso é suficiente?
Neil

Ah, eu não tinha notado que o TIO continha a versão detalhada tbh. Mas, no entanto, uma explicação na própria resposta nunca é demais, então obrigado por dedicar um tempo para escrevê-la.
Kevin Cruijssen

Quero aprender carvão, mas ele precisa de uma página como 05AB1E, que explica o que cada caractere da página de código realmente faz sem ter que mergulhar no código.
Urna Mágica do Polvo

2
@carusocomputing Não é tão ruim: além de cadeias compactadas, você tem cadeias normais (caracteres ASCII e pilcrow), números (dígitos sobrescritos), setas (... setas), comandos (geralmente letras maiúsculas) e operadores (tudo para que você possa procurá-los na página apropriada do wiki.
21717 Neil

6

Clojure, 833 437 bytes

Quase por definição, Clojure nunca ganhará nenhum prêmio por brevidade, mas como eu esperava TODAS AS SEMANAS SEMANA nos DOIS (conte-os - DOIS ) episódios de Batman (mesmo tempo de morcego, mesmo canal de morcego!), Fica claro que há nao ha tempo a perder!

Rápido, Robin - para o Bat-REPL !!!

(defn r[c n](clojure.string/join(repeat n c)))(defn pl[col](loop[i 0 c " "](print(r c (nth col i)))(if(< i (dec (count col)))(recur (inc i) (if (= c " ") "*" " "))(println))))(defn p[](loop[lines [[11 1 25 1][7 4 10 1 5 1 10 4][5 4 12 7 12 4][3 6 12 7 12 6][2 9 9 9 9 9][1 47][0 49][0 49][0 49][1 47][2 5 7 21 7 5][4 4 7 3 4 5 4 3 7 4][7 2 7 1 6 3 6 1 7 2]] i 0] (pl (nth lines i))(if (< i (dec (count lines)))(recur lines (inc i))nil)))

Versão sem golfe:

(defn repstr [c n]
  (clojure.string/join (repeat n c)))

(defn print-bat-signal-line [col]
  (loop [i  0
         c  " "]
    (print (repstr c (nth col i)))
    (if (< i (dec (count col)))
      (recur (inc i) (if (= c " ") "*" " "))
      (println))))

(defn print-bat-signal []
  (loop [lines [[11 1 25 1]  ; spaces asterisks spaces asterisks
                [7 4 10 1 5 1 10 4]
                [5 4 12 7 12 4]
                [3 6 12 7 12 6]
                [2 9 9 9 9 9]
                [1 47]
                [0 49]
                [0 49]
                [0 49]
                [1 47]
                [2 5 7 21 7 5]
                [4 4 7 3 4 5 4 3 7 4]
                [7 2 7 1 6 3 6 1 7 2]]
        i      0]
    (print-bat-signal-line (nth lines i))
    (if (< i (dec (count lines)))
      (recur lines (inc i))
      nil)))

RIP Adam West. Não importa quão ridículos sejam esses shows, aqueles de nós que éramos crianças o saudam.


Apesar de não jogar golfe, ainda bate o gato responder heh.
Urna Mágica do Polvo

Versão Golfed adicionada. Eu o virava de lado para fazer parecer que está subindo em uma parede, se eu pudesse. :-)
Bob Jarvis

6

C (gcc) , 191 bytes

#define x 16777215
char*b,*c,a[50];l[]={4096,122888,491535,2064399,4186143,x/2,x,x,x,x/2,4064255,983495,98435,0},*p=l;main(){for(;*p;p++,puts(a))for(b=c=a+23;b>=a;*p/=2)*b--=*c++=" *"[*p&1];}

Experimente online!


6

Várias soluções, todas usando a codificação de comprimento de execução, com uma variedade de técnicas para codificar os dados do RLE.

Python 3, 125 121 bytes

Esta versão usa uma bytesstring para armazenar os dados.

s=''
for c in b'<)@4/:),0/>/,3>/*981(WYYY(W*14=./4-.-4+4)2+':s+=' *'[c%2]*(c//2-19);s*=len(s)<25or print(s+s[-2::-1])or 0

Let sSer uma seqüência de estrelas ou de espaços. Em seguida, a ncodificação de bytes sé fornecida por

n = 38 + 2*len(s) + (s[0]=='*')

Python 2, 133 126 bytes

Esta versão usa codificação alfabética. O valor da letra determina o comprimento da sequência de saída, o caso da letra determina se é composta de espaços ou estrelas.

s=''
for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB':
 s+=' *'[c<'a']*(int(c,36)-9)
 if len(s)>24:print s+s[-2::-1];s='' 

Minha solução original de 133 bytes Python 2.

Esta versão usa cadeias de comprimento zero para que possa alternar facilmente entre cadeias de estrelas e de espaço.

s=''
for c,n in zip(24*' *','b1d074a13054c436c429951o0p0p0p1o257b447343727162'):
 s+=c*int(n,36)
 if len(s)>24:print s+s[-2::-1];s=''

Apenas por diversão, aqui está uma lista usando a codificação alfabética.

Python 2, 148 bytes

print'\n'.join(''.join(s+s[-2::-1])for s in zip(*[iter(''.join(' *'[c<'a']*(int(c,36)-9)for c in'kAmgDjAceDlDcFlDbIiEaXYYYaXbEgKdDgCdCgBgAfB'))]*25))

Para ainda mais diversão, aqui está um padrão no Jogo da Vida de Conway que gera uma versão do logotipo do Batman. Eu tive que dobrar cada linha para manter a proporção mais ou menos a mesma da versão em texto. Esse padrão realmente não computa o logotipo (embora seja possível fazer cálculos no Life - ele é completo em Turing), apenas o substitui de loops de memória, então acho que não posso publicá-lo como uma entrada de código de golfe (embora Eu o criei usando um script Python que escrevi há alguns anos). ;)

É codificado em um formato RLE bastante padrão que a maioria dos mecanismos Life pode carregar. Se você não possui um programa GoL (por exemplo, Golly ), é possível visualizá-lo em ação online com este mecanismo Life online , que pode importar arquivos Life RLE. Aqui está uma versão PNG desse padrão Life , alguns programas Life (incluindo Golly) podem carregar padrões Life a partir de PNGs e vários outros formatos de arquivo de imagem.


6

T-SQL, 283 276 222 bytes

SELECT CAST(DECOMPRESS(CAST('H4sIAAAAAAAEAFNQgAMtBVxAi5cLxgICdB3IAkAAVYuqEsLHIgRWjV0KqxBIvZYWujQeEaAGLdIALxeJGuinhXSvQEMCPVSQAbIcJPJQReGSSHxU9WAeSppAqEMoBwCfudAGawIAAA=='as XML).value('.','varbinary(max)'))AS varchar(max))

Implementando a compactação GZIP da string batman original, através do método postado aqui . Isso funciona apenas no SQL 2016 e posterior.

Para versões anteriores do SQL, use meu método anterior ( 276 bytes ):

DECLARE @ CHAR(999)=REPLACE(REPLACE(REPLACE('PRINT SPACE(11#1$25#1&$7#4$10#1$5#1$10#4&$5#4$12#7$12#4&$3#6$12#7$12#6&$2#9$9#9$9#9&$1#47&#49&#49&#49&$1#47&$2#5$7#21$7#5&$4#4$7#3$4#5$4#3$7#5&$7#2$7#1$6#3$6#1$7#2)','#',')+REPLICATE(''*'','),'$',')+SPACE('),'&',')+CHAR(13')EXEC(@)

Basicamente, estou codificando manualmente uma string gigante que determina o que imprimir a seguir, usando o seguinte método:

  • #7 é substituído por +REPLICATE('*',7)
  • $4 é substituído por +SPACE(4)
  • & é substituído por +CHAR(13)

Após a substituição, a seqüência completa de 958 caracteres se parece (com quebras de linha em cada linha no símbolo do Batman:

PRINT 
SPACE(11)+REPLICATE('*',1)+SPACE(25)+REPLICATE('*',1)+CHAR(13)
+SPACE(7)+REPLICATE('*',4)+SPACE(10)+REPLICATE('*',1)+SPACE(5)+REPLICATE('*',1)+SPACE(10)+REPLICATE('*',4)+CHAR(13)
+SPACE(5)+REPLICATE('*',4)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',4)+CHAR(13)
+SPACE(3)+REPLICATE('*',6)+SPACE(12)+REPLICATE('*',7)+SPACE(12)+REPLICATE('*',6)+CHAR(13)
+SPACE(2)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+SPACE(9)+REPLICATE('*',9)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+REPLICATE('*',49)+CHAR(13)
+SPACE(1)+REPLICATE('*',47)+CHAR(13)
+SPACE(2)+REPLICATE('*',5)+SPACE(7)+REPLICATE('*',21)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(4)+REPLICATE('*',4)+SPACE(7)+REPLICATE('*',3)+SPACE(4)+REPLICATE('*',5)+SPACE(4)+REPLICATE('*',3)+SPACE(7)+REPLICATE('*',5)+CHAR(13)
+SPACE(7)+REPLICATE('*',2)+SPACE(7)+REPLICATE('*',1)+SPACE(6)+REPLICATE('*',3)+SPACE(6)+REPLICATE('*',1)+SPACE(7)+REPLICATE('*',2)

Que é executado como SQL dinâmico, produzindo a seguinte saída:

           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       *****
       **       *      ***      *       **

5

PHP , 137 bytes

<?=gzinflate(base64_decode(U1CAAy0FXECLC8YAAnQNyAJAwIVFIYSPRYgLLkWEYrByLS10WTwiXAgmcYCLRPV00kGyN6BhgB4eyABZjgstyqAsuDpU5YjEgJIOEKoQigE));

Experimente online!

PHP , 177 bytes

foreach(["9zojk",a2878,aa4nb,b7u9z,chbf3,eze2n,jz6rj,jz6rj,jz6rj,eze2n,cepdr,ako8z,a1pc1]as$v)echo$t=strtr(substr(base_convert($v,36,2),1),10,"* "),"* "[$k++<2],strrev($t),"\n";

Experimente online!

PHP , 179 bytes

for(;$o=ord(kAlgDjAbeDlCcFlCbIiDaWXXXaWbEgJdDgCdBgBgAfA[$i++]);($x+=$s)%24?:print$r.("* "[$k++<2]).strrev($r)."\n".$r="")$r.=strtr(str_repeat($b=+($o>96),$s=$o-64-$b*32),10," *");

Experimente online!


Seu primeiro exemplo precisa de aspas
Steven Penny

2
@StevenPenny Não, não. Verificaram o link experimentá-lo on-line ?
ovs 14/06

11
@StevenPenny Neste caso, o PHP usa o elenco de constantes inexistentes para strings. Eu só ligo um erro de aviso que é permitido no Codegolf. E o "=" ausente no final da cadeia de caracteres codificada em base64 será adicionado automaticamente
Jörg Hülsermann 14/17

4

Java, 296 214 bytes

Golfe:

()->{String r="";boolean b=1<0;for(int a:";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()){for(int i=0;i<a-48;++i)r+=(b?'*':' ');if(a<49)r+='\n';else b=!b;}return r;}

Ungolfed:

public class InHonorOfAdamWest {

  public static void main(String[] args) {
    System.out.println(f(() -> {
      String r = "";
      boolean b = 1 < 0;
      for (int a : ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172".toCharArray()) {
        for (int i = 0; i < a - 48; ++i) {
          r += (b ? '*' : ' ');
        }
        if (a < 49) {
          r += '\n';
        }
        else {
          b = !b;
        }
      }
      return r;
    }));
  }

  private static String f(java.util.function.Supplier<String> f) {
    return f.get();
  }
}

Poderia usar ";1I1074:151:4054<7<4036<7<6029999901_10a10a10a01_0257E570447345437407271636172"para dados e for(char a:x){a=(int)a-48; [...]basicamente adiciona 48 a cada um dos números e os converte em seu equivalente ascii char. Eu acredito que isso vai lhe poupar 70-80 bytes. Também acredito que codificar os dados no lamba também reduzirá bytes.
Magic Octopus Urn

Também boolean b=false;pode ser boolean b=1<0, ou melhor ainda, você pode usar um inte também combinar a declaração ina mesma linha;).
Magic Octopus Urn

11
@carusocomputing obrigado, eu não pensei em embalá-lo em uma string. O seu tinha algum valor Unicode ruim, tive que regenerá-lo e a saída é exibida corretamente agora.

Como você não usa ino seu loop for, acho que você pode usar for(int i=0;i++<a-48;)como for-head.
Roman Gräf

3

Bubblegum , 75

Despejo xxd:

00000000: cd92 b501 8050 1043 fb4c 91fa efbf 1f0e  .....P.C.L......
00000010: 2f87 d371 5814 37d3 7c35 4d2b 1826 64f6  /..qX.7.|5M+.&d.
00000020: d8aa 419c 2a11 3e75 ce25 6d1e ee9d 22e0  ..A.*.>u.%m...".
00000030: bb11 f04f 0d7f 2e38 dfc8 6926 3dad 0871  ...O...8..i&=..q
00000040: f316 1071 6db8 fc07 a408 f7              ...qm......

Experimente online .


3

Coffeescript (282 bytes)

t=['6bk','59mw','l2j3','2ghsf','4zg2n','9zldr','jz6rj','4u7zz','165qf','47wj']
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d)->parseInt(t[d], 36).toString(2).padStart 25, '0').forEach (d)->console.log (d+d.split('').reverse().join('').substring(1)).replace(/0/g, ' ').replace(/1/g,'*')

Explicação (usando ES6 comum)

  • Como outros mencionados, a imagem é simétrica, para que possamos jogar metade dela na codificação
  • Várias linhas também são repetidas, para que possamos lançar cada linha em uma tabela de pesquisa para economizar alguns bytes
  • Convertemos cada meia-linha em binário (usando 0 como espaço e 1 como *) e codificamo-lo no ponto mais alto em Javascript (36), resultando na matriz de codificação.
  • O primeiro mapa pega cada linha e a converte novamente em sua meia-linha de saída final, preenchendo-a com 0s
  • O segundo mapa concatena cada linha com sua metade invertida (jogando a coluna do meio pela segunda vez) e substitui os 0s e 1s por espaços e * s

var t = [
    '6bk',
    '59mw',
    'l2j3',
    '2ghsf',
    '4zg2n',
    '9zldr',
    'jz6rj',
    '4u7zz',
    '165qf',
    '47wj'
];
[0,1,2,3,4,5,6,6,6,5,7,8,9].map((d) => {
    return parseInt(t[d], 36).toString(2).padStart(25, '0');
})
.forEach((d) => {
    console.log((d + d.split('').reverse().join('').substring(1))
        .replace(/0/g, ' ')
        .replace(/1/g, '*'));
});


Resposta legal! Bem vindo ao site! :)
DJMcMayhem

2

V , 102 bytes

i±³ *±± 
³ *± ´*· 
´*±² ´*µ 
´*±² ¶*³ 
µ*¹ ¹*  
²´* Ä3o²µ*jo±±*· µ*  
³*´ ³*· ´*´ 
**¶ *· **· Îæ$vp

Experimente online!

Hexdump:

00000000: 69b1 b320 2ab1 b120 0ab3 202a b120 b42a  i.. *.. .. *. .*
00000010: b720 0ab4 2ab1 b220 b42a b520 0ab4 2ab1  . ..*.. .*. ..*.
00000020: b220 b62a b320 0ab5 2ab9 20b9 2a20 200a  . .*. ..*. .*  .
00000030: b2b4 2a20 1bc4 336f b2b5 2a1b 6a6f b1b1  ..* ..3o..*.jo..
00000040: 2ab7 20b5 2a20 200a b32a b420 b32a b720  *. .*  ..*. .*. 
00000050: b42a b420 0a2a 2ab6 202a b720 2a2a b720  .*. .**. *. **. 
00000060: 1bce e624 7670                           ...$vp

Isso usa a codificação de comprimento de execução para gerar a seguinte metade do batman:

             *           
   *          ****       
****            ****     
****            ******   
*****         *********  
************************ 
*************************
*************************
*************************
************************ 
***********       *****  
***    ***       ****    
**      *       **      

E depois inverte e duplica cada linha.


2

Python 2 , 134 bytes

for w in'1D 4A13 4C4 6C4 995 O P P P O 57B 47343 27162'.split():r=''.join(c*int(k,36)for c,k in zip(3*'* ',w));print'%25s'%r+r[-2::-1]

Experimente online!

O comprimento da execução codifica cada linha da metade esquerda na base 36. Espelha-a para criar a linha completa, que é impressa. Os espaços iniciais não são codificados; em vez disso, a metade esquerda é preenchida com o comprimento 25.


Eu gostaria de poder usar esse truque preenchimento na minha versão ...
PM 2Ring

2

Mathematica 151 Bytes

Uncompress@"1:eJxTTMoPCm5iYmBQQAAtBVxAK8bA0AjGBgJ0PcgCQABXjaoWwsciBFWPXRKrEESHlha6AjwiYC1apAGQHhK10FsTOV6Chgp6CCEDZDlYdKKKw6WR+OjxD+KiJBSEQoR6AC49ZiI="

Barato e sem criatividade. A sequência é apenas do Compresscomando interno usado na saída necessária.

Atualizar:

Acho que posso fazer melhor com as funções ImportString\ ExportStringinternas, mas não consigo copiar e colar as seqüências resultantes ExportStringcorretamente. Por exemplo

b = "           *                         *\n       ****          *     *          ****\n     ****            *******            ****\n   ******            *******            ******\n  *********         *********         *********\n ***********************************************\n*************************************************\n*************************************************\n*************************************************\n ***********************************************\n  *****       *********************       *****\n    ****       ***    *****    ***       ****\n       **       *      ***      *       **"
ExportString[b,"GZIP"]
ImportString[%,"GZIP"]

Não consigo copiar a saída de texto da segunda linha para substituir %a terceira linha.


2

Bash ,407 322 bytes

w=`yes 1|head -30|tr -d '\n'`
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
x=`printf "%.$[0x${a}]d%.$[0x${b}]s%.$[0x${c}]d%.$[0x${d}]s%.$[0x${e}]d%.$[0x${f}]s" 0 $w 0 $w 0 $w`
echo -n $x$[f<1?0:1]
rev<<<$x
}|tr 01 \ \*

Experimente online!

realmente horrível, precisa de mais tempo ou ajuda para jogar golfe. gera a saída com 0 an 1 e translitera no final. Codificado em dígitos hexa a quantidade de 0 e 1, tendo o cuidado de fazer o último dígito 0 para as duas primeiras linhas como um sinalizador para gerar a coluna do meio. Utiliza a pressão printf no dígito ou na seqüência de caracteres para gerar 0 e 1. acha que o %.$[0x${X}]Cpadrão pode ser usado para jogar golfe.

w=`yes 1|head -30|tr -d '\n'`  # w=111111111111111111111111111111   
for i in B1C000 74A120 54C003 36C003 299004 1C0506 0D0506 0D0506 0D0506 1C0506 257505 447342 727161
{ read a b c d e f <<<$(echo $i| fold -1| xargs)
printf "%.$[0x${a}]d
%.$[0x${b}]s
%.$[0x${c}]d
%.$[0x${d}]s
%.$[0x${e}]d
%.$[0x${f}]s" 0 $w 0 $w 0 $w
echo -n $[f<1?0:1]
printf "%.$[0x${f}]s
%.$[0x${e}]d
%.$[0x${d}]s
%.$[0x${c}]d
%.$[0x${b}]s
%.$[0x${a}]d\n" $w 0 $w 0 $w 0 
}|tr 01 \ \*

2

Python 3, 232 197 183 164 bytes

Mais uma resposta em Python. Nenhum código de compressão chato embora. Código de compactação emocionante.

for s in map(lambda x:x+x[-2::-1],b".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&".split()):print(*((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)))

Estou usando o número mágico 35 porque, dessa forma, não ocorrem caracteres de controle, espaços ou coisas que precisariam escapar. Triste que eu tenha que processar os espaços e as estrelas separadamente, isso me custa um pouco.

Ungolfed:

for s in map(lambda x:x+x[-2::-1],   # map a list to the list and itself reversed,
                                     # minus the last (center) element
# magic string:
".$; *',$' ('.* &).* %,+, $R #T #T #T $R %()8 '')&&( *%)$(&"
.split()):                           # split on whitespace to divide into lines
 print(*(                            # unpack generator expression
(ord(s[i])-35)*" "                   # convert character to int, -25, times space
+(ord(s[i+1])-35)*"*"                # same thing with "*"
for i in range(0,len(s)-1,2)))       # for every pair in the list

Esse método de codificação é melhor que a base 36. Espero que você não se importe que eu o tenha adaptado para a minha solução mais recente. ;) Existem algumas coisas que você pode fazer para reduzir sua contagem de bytes. 1 Você pode salvar um byte colocando a printchamada na mesma linha que o for. 2 Se você usar uma bytescorda, poderá se livrar dessas ordchamadas. 3 Você pode substituir o rangezipando sobre um par de iteradores. Aqui está um gerador que combina essas duas idéias: ((u-35)*" "+(v-35)*"*"for u,v in zip(*[iter(s)]*2)). Essas mudanças
reduzirão

@ PM2Ring Eu não me importo. Sair de férias por algumas semanas, fique à vontade para editar suas alterações.
L3viathan

Ah ok. Mas eu vou deixar você fazer a nova versão sem golfe.
PM 2Ring

@ PM2Ring no já um ônibus, então eu vou só espero que alguém vai aprová-lo
L3viathan

2

PowerShell, 305 bytes, 307 bytes , 316 bytes

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Talvez alguém possa me ajudar a reduzi-lo ainda mais, embora eu não possa descobrir como, a menos que haja uma maneira mais concisa de definir um acelerador de tipo personalizado.

Edit: Versão reduzida (obrigado @root). A sequência codificada (codificação pré-base64) pode ser cortada por oito posições da matriz e o intervalo pode ser diminuído. Não sei por que o StreamWriter está introduzindo esse inchaço no MemoryStream. A compreensão do comportamento subjacente seria apreciada.

[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg')),0,94),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()

Ungolfed:

#Read decoded stream 
[IO.StreamReader]::new(
    (
        #Reverse GZip encoding
        [IO.Compression.GZipStream]::new(
            #Load GZip encoded string into a memory stream
            [IO.MemoryStream]::new(
                (
                    # Convert Base64 back to GZip encoded string
                    [Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')
                ),
                #Start of range
                0,
                #End of range. Stick the Memory Stream into a variable and use .Length here for non golf code
                102
            ),
            #Specify that we are decompressing
            [IO.Compression.CompressionMode]::Decompress
        )
    )
).ReadToEnd()

Código de compressão:

$s = '           *                         *
       ****          *     *          ****
     ****            *******            ****
   ******            *******            ******
  *********         *********         *********
 ***********************************************
*************************************************
*************************************************
*************************************************
 ***********************************************
  *****       *********************       *****
    ****       ***    *****    ***       ****
       **       *      ***      *       **'

#Create Memory Stream
$ms = [IO.MemoryStream]::new()
#Initialize a stream
$sw = [IO.StreamWriter]::new(
    #Create GZip Compression stream
    [IO.Compression.GZipStream]::new(
        #Reference Memory Stream
        $ms,
        #Set mode to compress
        [IO.Compression.CompressionMode]::Compress
    )
)
#Write input into stream
$sw.Write($s)
#Close the stream
$sw.Close()

#Convert Array to Base64 string
[Convert]::ToBase64String(
    #Retrieve Memory Stream as an array
    ($ms.ToArray() | select -SkipLast 8)
)

11
Por que 102? 99 funciona da mesma maneira,[IO.StreamReader]::new(([IO.Compression.GZipStream]::new([IO.MemoryStream]::new(([Convert]::FromBase64String('H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbuHBUsBqAgAA')),0,102),[IO.Compression.CompressionMode]::Decompress))).ReadToEnd()
root

@ raiz, sim, eu acho, mas não sei por que isso funciona. Na verdade, você pode diminuí-lo em oito a 94 e soltar os últimos oito caracteres da sequência de entrada codificada. Estou tendo dificuldade para descobrir por que isso funciona e não quero adicioná-lo à minha resposta até que eu faça. Minha função de compactação está adicionando incorretamente algum preenchimento estranho de alguma forma?
Chirishman

11
No seu código de compactação, os dois últimos valores de $ms.ToArray()são ambos 0. Eles são necessários?
root

Não. E tentando diferentes strings de entrada, parece consistente que são exatamente duas posições desnecessárias de array no final. Vou adicionar uma cláusula para pular os dois últimos no meu script de compactação. Ainda gostaria de saber por fluxo escritor estava adicionando os valores nulos para o final
Chirishman

11
Você está certo, são mais do que apenas os dois caracteres finais, são 8. As últimas 8 posições da matriz ('225','193','82','192','106','2','0','0')podem ser removidas para criação H4sIAAAAAAAEAL1SOQ4AIAjbTfwDc///QFE8gKAJi53sNQASbYBuQC3rxfANLTBm1iaFB9JIx1Yo9Tzg7YfCBeRQS7Lwr5IfZW7Cb0VDe3I8q25TcXvrTsyXOLGTbg==. Eu não entendo de onde eles estão vindo.
root

2

Perl 5, 168 bytes

$_="11 *25 
7 4*10 *5 *10 4
5 4*12 7*12 4
3 6*12 7*12 6
2 9*9 9*9 9
 47
49
49
49
 47
  5*7 21*7 5
4 4*7 3*4 5*4 3*7 4
7 **7 *6 3*6 *7 *";s/$/*/gm;say s/\d+(.)/$1x$&/ger

Observe o espaço à direita no final apenas da primeira linha. Requer -M5.01, que é gratuito.

Provavelmente pode ser jogado um pouco mais.


2

LaTeX, 314 bytes

\documentclass{book}\begin{document}\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}\catcode`.13\catcode`!13\catcode`-13\def!#1{\r*{`#1}}\def-#1{\r~{`#1}}\let.\par\tt-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B\enddocument

A versão ungolfed com explicações:

\documentclass{book}
\begin{document}
% Macro for repeating #1 (#2-64) times
\def\r#1#2{\ifnum#2>64#1\r#1{\numexpr#2-1}\fi}
% Prepare '.', '!' and '-' for usage as macro names
\catcode`.13\catcode`!13\catcode`-13
% The ASCII code of #1 (a character) is used as the number of how often '*' will be printed with \r
\def!#1{\r*{`#1}}
% Same as ! but for spaces
\def-#1{\r~{`#1}}
% . becomes a line break
\let.\par
% Set monospace font
\tt
% And finally print the whole thing
-K!A-Y!A.-G!D-J!A-E!A-J!D.-E!D-L!G-L!D.-C!F-L!G-L!F.-B!I-I!I-I!I.-A!o.
!q.!q.!q.-A!o.-B!E-G!U-G!E.-D!D-G!C-D!E-D!C-G!D.-G!B-G!A-F!C-F!A-G!B
\enddocument

2

C # (.NET Core) , 342 333 328 185 175 bytes

_=>{var r="";for(int i=0,j,k=0;i<63;i++)for(j=0;j++<"-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)"[i]-34;){r+=i%2<1?' ':'*';if(++k%49<1)r+='\n';}return r;}

Experimente online!

Muitos bytes salvos após alterar a abordagem. Tomando o desenho como uma matriz 2D, calculei a codificação RLE por arquivos:

{ 11, 1, 25, 1, 18, 4, 10, 1, 5, 1, 10, 4, 12, 4, 12, 7, 12, 4, 8, 6, 12, 7, 12, 6, 5, 9, 9, 9, 9, 9, 3, 47, 1, 147, 1, 47, 3, 5, 7, 21, 7, 5, 6, 4, 7, 3, 4, 5, 4, 3, 7, 4, 11, 2, 7, 1, 6, 3, 6, 1, 7, 2, 7 }

Índices ímpares representam s e índices pares representam *s. Substituí cada número por uma representação ASCII imprimível (assumindo o caractere '#' como 1) e obtive:

-#;#4&,#'#,&.&.).&*(.).('+++++%Q#µ#Q%')7)'(&)%&'&%)&-$)#(%(#)$)

Portanto, o algoritmo calcula o desenho descompactando essa string e adicionando novas linhas nos locais apropriados.


11
Não é necessário definir luma variável, basta usá-la diretamente no loop. .ToString(i, 2)-> .ToString(i,2)ou seja, remova o espaço em branco.
TheLethalCoder

Você pode salvar bytes com representações decimais ou científicas ( 1e10) para esses números? Este desafio é realmente útil aqui.
TheLethalCoder

@TheLethalCoder nope. Acabei de verificar (desafio impressionante, a propósito) e já uso a menor representação, então não tenho sorte lá. Eu até tentei encontrar o maior divisor comum entre eles para ver se eu poderia dividir os números por uma constante, mas é obviamente 1.
Charlie

2

PowerShell , 129 128 bytes

-join('5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% t*y|%{(' ','*')[$i++%2]*($_-42)})-split'(.{49})'-ne''

Experimente online!

Ungolfed:

-join(
    '5+C+<.4+/+4.6.616.206160/33333-Y+s*t+Y-/1?1/0.1-./.-1.5,1+0-0+1,'|% toCharArray|%{
        (' ','*')[$i++%2]*($_-42)
    }
)-split'(.{49})'-ne''

Resultado:

           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **

A ideia principal é muito simples

A codificação do emblema:

  1. Concatene todas as linhas do emblema em uma sequência
  2. Contar espaços e asteriscos
  3. Codifique o comprimento de cada segmento + 42 como um caractere

Decodificação (este script):

  1. Obtenha o código do char menos 42 para cada char na string cripto. Este é o comprimento de um segmento
  2. Anexar segmento, consistindo em um espaço ou asterisco repetidas Lengthvezes
  3. Inserir nova linha a cada 49 símbolos para dividir linhas

Algumas coisas inteligentes

  1. O algoritmo de codificação sugere um símbolo com o código 189 para exibir três linhas do meio asterisco. Este símbolo não é ASCII. Funciona normal em ambientes modernos, mas existem ambiguidades com o tamanho do script. Portanto, substituo o símbolo não-ascii ½por s*t(73 asteriscos, 0 espaços, 74 asteriscos).
  2. Cortei os espaços certos na última linha para economizar 1 byte. Desculpe, Batman.
  3. Por que o deslocamento é 42? Só queria :) E a cripto-string parece legal.

Extra: Scipt para codificação do Emblema

(@"
           *                         *           
       ****          *     *          ****       
     ****            *******            ****     
   ******            *******            ******   
  *********         *********         *********  
 *********************************************** 
*************************************************
*************************************************
*************************************************
 *********************************************** 
  *****       *********************       *****  
    ****       ***    *****    ***       ****    
       **       *      ***      *       **       
"@ -replace"`n"-split'( +|\*+)'-ne''|%{[char]($_.Length+42)})-join''

1

Mathematica, 271 bytes

T=Table;f[x_]:=""<>T["*",x];m={f@49};n={f@47};g[y_]:=""<>T[" ",y];k[a_,b_,c_,d_,e_]:={(s=f@a<>g@b<>f@c<>g@d<>f@e)<>StringDrop[StringReverse@s,1]};Grid@{k[1,13,0,0,0],k[4,10,1,3,0],k[4,12,0,0,4],k[6,12,0,0,4],k[9,9,0,0,5],n,m,m,m,n,k[5,7,0,0,11],k[4,7,3,4,3],k[2,7,1,6,2]}

1

Braingolf , 590 580 579 577 428 423 312 bytes

-111 bytes porque LeakyNun é um deus do golfe

14#
46*6394943[92+.6,5][8]#.[# ]#*[# ]#*#
[# ][#*][# ]#*[# ]#*[# ]#*...#
[# ][#*][# ][#*][# ]#*...#
# ..[#*][# ][#*][# ][#*]#
# .[#*][# ][#*][# ][#*]#
# [#*]#
&@#0[#*]#
!&@!&@# &@#.[#*]"
  "&@4645*643646366556[#*][# ][#*][# ][#*]"
    "[#*][# ]#*..# ...[#*]# ...#*..[# ][#*]#
[# ]#*.[# ]#*[# ]#*..[# ]#*[# ]#*.&@

Experimente online!

Braingolf não é bom em arte ASCII, mas caramba, eu tentei.

De jeito nenhum eu estou explicando esse clusterf ** k


1

/// , 171 166 bytes

5 bytes salvos porque eu estava usando \r\nna fonte, lol.

/-/  //,/!!//'/**//&/*"//%/--//#/,,,,,!*//"/%-//!/''/"% &""" *
" !"%*% &%!
% !""!'&"!
- !*&"!'&"!'
-,&- ,&- ,*
 #'
!#
!#
!#
 #'
-!& ,,!& !*
%!" '*%!*%'& !
" *& &'&& '

Experimente online!

Compactado usando iterações sucessivas de substituição das substrings "mais econômicas" por um único caractere. Isso é quase ideal, embora uma das duas coisas possa ser o caso:

  1. Eu poderia me safar usando algumas substituições meta (por exemplo, inserir regexes dinamicamente)
  2. De alguma forma, é mais benéfico substituir primeiro substratos menos econômicos (improvável).
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.