A resposta para a vida, o universo e a arte ASCII

25

Desafio simples: tente gerar o seguinte texto no menor número de bytes possível:

       the        answer
      toli      fetheuniv
     ersea     nde     ver
    ything     the     ans
   wer tol     ife     the
  uni  ver           sean
 dev   ery         thin
gth    ean       swer
tolifetheuni    ver
seandeveryth   ing
       the     ans      wer
       tol     ifetheuniver
       sea     ndeverything

O desenho original contém 332 caracteres.

Regras

  • Nenhuma entrada ou entrada não utilizada.
  • A saída pode estar em qualquer formato razoável (string, lista de strings, matriz de caracteres e assim por diante).
  • Você pode usar maiúsculas em vez de minúsculas para o desenho, se preferir.
  • Espaços em branco e novas linhas permitidos.
  • Isso é código-golfe , portanto, pode ganhar o programa / função mais curto para cada idioma!

Notas

code-golf ascii-art kolmogorov-complexity Charlie
fonte
Isso vem da caixa de areia .
1977 Charlie
1
Pessoalmente, acho que isso é um tópico e não um engano. Eu acho que você não precisa de uma citação de spoiler.
programmer5000
1
@ Phoenix Eu não acho que isso seja um tolo , sogl superou o chiclete . Portanto, a compactação não é uma maneira ideal de fazer isso.
programmer5000
1
Para ser sincero, não percebi que meu voto de reabertura era obrigatório. Pelas razões já mencionadas por @ programmer5000, eu realmente não acho que é um joguete de Não somos estranhos ... . Pode ser um engano de outro - ainda por identificar - desafio, mas não este.
Arnauld
1
@Nacht A melhor parte é que, a princípio, eu desenhei os caracteres 42com *e os substituí pelo texto, que se encaixava perfeitamente. Não precisei modificar o desenho original para ajustar a frase. Coincidência?
30717 Charlie

Respostas:

21

Python 3 , 224 220 219 215 211 194 bytes

  • Obrigado a @TFeld por 1 5 bytes: em if(j%27<1)*jvez de if j*(j%27<1)e declaração de impressão simplificada.
  • Graças a @Leaky Nun por 4 bytes: inverter 0 e 1, não exigiu o preenchimento por zeros 7*'0'
  • Freira @Leaky economizou 17 bytes com suas habilidades impressionantes de golfe (Muito obrigado !!!!): uso incrível da indexação modular
i=j=0
k=int("OHZE5WCKDTW6JYMO1JNROAAJQVAN6F8KEO0SMKJM86XIBMCEH5FXXONZGBAVCN3689DS",36)
while k:j+=1;print(k%2*'theanswertolifetheuniverseandeverything'[i%39]or' ',end='\n'*(j%27<1));i+=k%2;k//=2

Experimente online!

Explicação:

Usa a compressão base-36 para compactar esse número binário (nova linha excluída)

111111100011111111000000111
111111000011111100000000011
111110000011111000111110001
111100000011111000111110001
111000100011111000111110001
110001100011111111111000011
100011100011111111100001111
000111100011111110000111111
000000000000111100011111111
000000000000111000111111111
111111100011111000111111000
111111100011111000000000000
111111100011111000000000000

Basicamente, temos dois contadores ie j. Ao encontrar um 1, imprimimos um espaço; Caso contrário, se 0imprimirmos a próxima letra da string e aumentaremos i. jaumenta para cada um 0 or 1. Também imprimimos novas linhas sempre que necessário, ou seja, quando j%27<1se torna realidade.

officialaimm
fonte
1
Você pode salvar 1 byte, alterando if j*(j%27<1):paraif(j%27<1)*j:
TFeld
2
205 bytes
Freira vazada
2
201 bytes com aritmética inteira
gotejante Nun
2
200 bytes com indexação modular
Leaky freira
2
194 bytes
Freira com vazamento
8

Python 2 , 235 218 213 bytes

x=bin(int('OC5POO6MZYQNBWY0RP6BKBZCOZL13MIAB6I8YZ5N7LXSZBVKX7GC57AW5631YCJ6XCLC',36))[2:].replace('1',' ')
for c in'theanswertolifetheuniverseandeverything'*4:x=x.replace('0',c,1)
while x:y,x=x[:27],x[27:];print y

Experimente online!

Comutado para uma base 36 codificada int das posições das letras, como sugerido na pergunta.

Substitui cada personagem, um de cada vez.

       111        111111                              the        answer
      1111      111111111                            toli      fetheuniv
     11111     111     111                          ersea     nde     ver
    111111     111     111                         ything     the     ans
   111 111     111     111                        wer tol     ife     the
  111  111           1111                        uni  ver           sean
 111   111         1111             --->        dev   ery         thin
111    111       1111                          gth    ean       swer
111111111111    111                            tolifetheuni    ver
111111111111   111                             seandeveryth   ing
       111     111      111                           the     ans      wer
       111     111111111111                           tol     ifetheuniver
       111     111111111111                           sea     ndeverything

Edit: Parece officialaimm usado base 36 antes de mim.

TFeld
fonte
7

Chiclete , 125 bytes

0000000: 45 8f c5 01 03 31 0c 04 ff ae 62 4b 0b 99 02 c7  E....1....bK....
0000010: d8 7d 84 e7 f9 59 30 5e 41 59 4a 84 71 ef e6 3d  .}...Y0^AYJ.q..=
0000020: 4e c1 ea fd b7 42 48 91 66 d6 ae 6e da 89 d3 1c  N....BH.f..n....
0000030: ef 60 ba 97 ae 6e b6 74 2e a5 76 d9 ad ae e4 16  .`...n.t..v.....
0000040: 69 59 08 a6 a6 e8 23 d4 22 af 08 d0 20 7d 17 f0  iY....#."... }..
0000050: 8a 9b 7c 76 c2 61 7b c8 4b 01 41 23 50 24 32 87  ..|v.a{.K.A#P$2.
0000060: f5 98 9e 88 35 24 21 83 ac 50 b2 e0 a2 16 0e 42  ....5$!..P.....B
0000070: bb ba a5 bc ae 6e bd 76 b7 69 d9 f9 07           .....n.v.i...

Experimente online!

Dennis
fonte
Como você gerou isso? O mais próximo que eu consegui foi 127
musicman523
1
Com zopfli .
Dennis
Eu fiz uso zopfli, mas eu juro que tentei com e sem novas linhas à direita, com os espaços extras .... não poderia ficar sob 127
musicman523
6

05AB1E , 83 79 74 bytes

-4 bytes graças a Erik the Outgolfer

Produz uma lista de cadeias para salvar um byte.

•2ÖH₆Ôn₅Ò\ÊÑĆ¸Ý¾*£„ÔûC∞qΘœ™‚¹µ—₃₄fm•vNÈy×vyiðë¾¼’€€Ž»to‚쀀ªÜ€ƒ‰Ö’è}}}J27ô

Experimente online!

Explicação

2ÖH₆Ôn₅Ò\ÊÑĆ¸Ý¾*£„ÔûC∞qΘœ™‚¹µ—₃₄fm é a representação 255 base do número decimal:

73869469755353565353431353533323902433339443437469034389033390735363735903735903

Que codifica execuções de 1s e 0s, respectivamente, índices mesmo sendo se e índices 1irregulares são 0s. Isso avalia o número binário:

111111100011111111000000111
111111000011111100000000011
111110000011111000111110001
111100000011111000111110001
111000100011111000111110001
110001100011111111111000011
100011100011111111100001111
000111100011111110000111111
000000000000111100011111111
000000000000111000111111111
111111100011111000111111000
111111100011111000000000000
111111100011111000000000000

Código

•...•                                         Convert from base 255 to decimal
     v                                }       For each digit, do:
      NÈy×                                       is_even(index) repeated that many times
          v                          }           For each digit, do:
           yi                       }               If digit is truthy, then:
             ð                                         Push space
              ë                                     Else:
               ¾¼                                      Get and increment counter, starts at 0
                 ’€€Ž»to‚쀀ªÜ€ƒ‰Ö’                    Push "theanswertolifetheuniverseandeverything"
                                   è                   Get the character at that index
                                       J      Join whole stack
                                        27ô   Split into parts of 27
kalsowerus
fonte
Substitua "ÔAo îιË3š1ĆRÕ₃FWš{ÓÛÏ.!XµM§&¶ñD°3PŸ{óNι2Ðbмh"253öcom •—."Ôq‚Ā0Ál0j¿«ªžé¨0õ₄7“Ÿ!½ÏiæÆø-δq–Å05q½Yñá+•a -4.
Erik the Outgolfer
@EriktheOutgolfer graças, atualizei a minha resposta e agora eu finalmente saber o que estes •são para :)
kalsowerus
Boa resposta :). Espero que você continue aprendendo o idioma. Se você tiver alguma dúvida, sinta-se à vontade para conversar comigo.
Magic Octopus Urn
@MagicOctopusUrn Muito obrigado! :)
kalsowerus
6

Python 2 , 220 213 212 bytes

-1 byte por comutação ()*4para %39a partir @officialaimm

s=""
w=l=i=0
for g in`int("352G7FS4XC8J2Q2M2HNK7IZI65Z9TVUMHOZ6MR3HY46RQBLWY4PR",36)`[:-1]:
	for j in g*int(g):l+=1;s+=[' ',"theanswertolifetheuniverseandeverything"[w%39]][i%2]+"\n"*(l%27<1);w+=i%2
	i+=1
print s

Experimente online!

Essa é uma abordagem diferente das outras respostas do Python. Uso uma codificação hexadecimal base-36 (economizada em 7 bytes) de uma codificação RLE no estilo PNG da imagem (uma sequência de dígitos indicando o número de pixels repetidos consecutivos).

A sequência de dígitos é :

73869469755353565353431353533323902433339443437469034389033390735363735903735903

Então, eu percorro esses dígitos e alternadamente imprimo esse número de '' ou caracteres da paleta ('theanswer ...'). Quando mais de 9 caracteres são repetidos, eu simplesmente adiciono 0 e depois o restante.

Coty Johnathan Saxman
fonte
+1 para uma abordagem diferente. Você pode salvar um byte usando o "theanswertolifetheuniverseandeverything"[w%39] TIO #
officialaimm
Obrigado e anotado. Eu estava tentando trabalhar em conjunto com uma substituição 'ou' para a configuração do suporte de boolean tenho aqui agora, mas está atrapalhando minhas novas linhas ...
Coty Johnathan Saxman
Eu não sabia que o PNG usava esse algoritmo de compressão - eu pensei que era GIF.
wizzwizz4
Boa pegada. Não era PNG (nem GIF), mas na verdade RLE. Vou adicionar um link para a resposta.
Coty Johnathan Saxman
5

SOGL V0.12 , 74 bytes

"ō⅓׀?@C⁶¬IΧΖO‘@øŗč"βΘ⅔Μv∙KΩqψ3╥W≡A;2ļm½±iq╗∆Δ⁶Πqīσ‽ε⁰5τΩ⅜δσΞoΤi┘‽N¹\Λ:‘'    n

Experimente aqui!

"...‘              push "the answer to life the universe and everything". because of a bug-not-really-bug, the starting quote is required
     @øŗ           remove spaces
        č          chop it into characters
         "...‘     push a string of spaces and ŗ where ŗ gets replaced with each next characters of the character array
              ' n  split into an array of line length 27
dzaima
fonte
5

Permita-me responder minha própria pergunta ...

Carvão , 140 126 112 bytes

Ａ⟦⟧βＦ⁶⁸Ｆ⁻℅§”c#*U[“⎆Ｖl¶·δ‴ü"Ｉp8ξＺ{e/⪫¦σMＭ⪫¢Ｑ⁸UＬê←⪫W?—υ⁻$⌀)”ι³⁴«¿﹪鲧”m⌊0Ｙ℅¿№”XＪ-⁵η}Z¿8_*<o%!±Ÿ”Ｌ⊞Ｏβω ¿¬﹪Ｌ⊞Ｏυω²⁷⸿

Experimente online!

Você tem aqui um link para a versão detalhada mais próxima.

Explicação (consulte a versão detalhada para obter detalhes):

  • A )%*(+&(+)''%'%'('%'%&%#%'%'%%%$%-&%%%%+&&%&%)&(.&%*.%%2%'%(%)%'.)%'.sequência (68 bytes, 48 ​​bytes compactados) é uma representação da codificação RLE do desenho. Todo código de caracteres menos 34 é o número de espaços (posições pares) ou o número de caracteres de texto (posições ímpares) a serem impressos consecutivamente.
  • O algoritmo descompacta a string codificada em RLE e grava o próximo caractere da gtheanswertolifetheuniverseandeverythinstring (39 bytes, 27 bytes compactados) toda vez que um caractere que não é de espaço em branco é necessário para ser gravado. À medida que verifico o comprimento de uma lista para obter o próximo caractere e essa lista começa com um elemento, o último caractere da string é escrito na primeira posição.
  • A cada 27 caracteres escritos, insiro uma nova linha.

Agradecimentos

  • Muito obrigado a Neil e suas dicas incríveis por me permitir salvar 28 bytes e finalmente ser capaz de vencer o Bubblegum. :-)
Charlie
fonte
1
Se você usa Assign(Minus(1, c), c);, pode usar if (c) { ... } else Print(" ");.
Neil
Na verdade, se você usar for (68)e, em AtIndex("...", i)seguida, poderá usá Modulo(i, 2)-lo e não precisará cmais.
Neil
E se você usar if (Not(Modulo(Length(PushOperator(u, w)), 27))), também não precisará a.
Neil
Ah, e AtIndexfaz um automático Modulopara que Modulo(b, 39)possa ser justo b.
Neil
1
ué uma variável predefinida que é apenas uma matriz vazia (salva usando Ａ⟦⟧υ). Toda vez que você pressiona algo, seu comprimento aumenta em 1. Isso é mais curto do que uma atribuição explícita a ser incrementada.
Neil
5

JavaScript (ES6), 207 205 203 bytes

Retorna uma matriz de seqüências de caracteres com alguns espaços à direita.

let f =

_=>[16515968,33489856,k=58950624,k+16,k-40,31458204,7865230,1966983,462847,233471,117670784,k=134185856,k].map(n=>'heanswertolifetheuniverseandeverythingt '.replace(/./g,(_,i,s)=>s[n>>i&i<27?k++%39:39]))

console.log(f().join('\n'));
Expandir snippet

Arnauld
fonte
4

Retina , 183 bytes


7386¶6469¶555353¶465353¶33135353¶23239024¶133394¶034374¶090343¶090333¶735363¶735903¶735903¶theanswertolifetheuniverseandeverything
.*$
$&$&$&$&
(\d)(.)
$1$* $2$*
+s`1([ 1¶]+)(.)
$2$1

Experimente online! Explicação: O primeiro estágio adiciona a codificação RLE do bitmap da célula e o texto, que o segundo estágio duplica no tamanho correto, enquanto o terceiro estágio decodifica a codificação RLE. O quarto estágio move o texto para as células.

Neil
fonte
4

Gelatina , 83 bytes

“¡eu⁾ṃṣƬİḂṃ½)ṣṾṘƇ@^AṀẆṫ+¢ṗɲ⁾ṭḋZ`⁺×Ṗj½Ṇ-Þḣ2żṿƤc’BCẋ"`“ÆZ⁺ƙ{ÆߥŀŒ1gỤ3Ḍṭṁ ṃjɓ»ṁȯ€⁶s27Y

Experimente online!

Como funciona

“XX’BCẋ"`“YY»ṁȯ€⁶s27Y
“XX’                   a large number
    B                  binary
     C                 complement
      ẋ"`              1 becomes [1] and 0 becomes []
             ṁ         reshape
         “YY»             "theanswertolifetheuniverseandeverything"
              ȯ€⁶      replace [] with " "
                 s27   split into chunks of length 27
                    Y  join with newline
Freira Furada
fonte
3

Adicionar ++ , 1398 bytes

+32
&
&
&
&
&
&
&
+84
&
-12
&
-3
&
-69
&
&
&
&
&
&
&
&
+65
&
+13
&
+5
&
+4
&
-18
&
+13
&
-104
&
+22
&
&
&
&
&
&
+84
&
-5
&
-3
&
-3
&
-73
&
&
&
&
&
&
+70
&
-1
&
+15
&
-12
&
-3
&
+16
&
-7
&
-5
&
+13
&
-108
&
+22
&
&
&
&
&
+69
&
+13
&
+1
&
-14
&
-4
&
-65
&
&
&
&
&
+78
&
-10
&
+1
&
-69
&
&
&
&
&
+86
&
-17
&
+13
&
-104
&
+22
&
&
&
&
+89
&
-5
&
-12
&
+1
&
+5
&
-7
&
-71
&
&
&
&
&
+84
&
-12
&
-3
&
-69
&
&
&
&
&
+65
&
+13
&
+5
&
-105
&
+22
&
&
&
+87
&
-18
&
+13
&
-82
&
+84
&
-5
&
-3
&
-76
&
&
&
&
&
+73
&
-3
&
-1
&
-69
&
&
&
&
&
+84
&
-12
&
-3
&
-91
&
+22
&
&
+85
&
-7
&
-5
&
-73
&
&
+86
&
-17
&
+13
&
-82
&
&
&
&
&
&
&
&
&
&
&
+83
&
-14
&
-4
&
+13
&
-100
&
+22
&
+68
&
+1
&
+17
&
-86
&
&
&
+69
&
+13
&
+7
&
-89
&
&
&
&
&
&
&
&
&
+84
&
-12
&
+1
&
+5
&
-100
&
+93
&
+13
&
-12
&
-72
&
&
&
&
+69
&
-4
&
+13
&
-78
&
&
&
&
&
&
&
+83
&
+4
&
-18
&
+13
&
-104
&
+106
&
-5
&
-3
&
-3
&
-3
&
-1
&
+15
&
-12
&
-3
&
+16
&
-7
&
-5
&
-73
&
&
&
&
+86
&
-17
&
+13
&
-104
&
+105
&
-14
&
-4
&
+13
&
-10
&
+1
&
+17
&
-17
&
+13
&
+7
&
-5
&
-12
&
-72
&
&
&
+73
&
+5
&
-7
&
-93
&
+22
&
&
&
&
&
&
&
+84
&
-12
&
-3
&
-69
&
&
&
&
&
+65
&
+13
&
+5
&
-83
&
&
&
&
&
&
+87
&
-18
&
+13
&
-104
&
+22
&
&
&
&
&
&
&
+84
&
-5
&
-3
&
-76
&
&
&
&
&
+73
&
-3
&
-1
&
+15
&
-12
&
-3
&
+16
&
-7
&
-5
&
+13
&
-17
&
+13
&
-104
&
+22
&
&
&
&
&
&
&
+83
&
-14
&
-4
&
-65
&
&
&
&
&
+78
&
-10
&
+1
&
+17
&
-17
&
+13
&
+7
&
-5
&
-12
&
+1
&
+5
&
-7
&
P

Experimente online!

Parece que a codificação é a maneira mais curta (pelo menos em Add ++)

caird coinheringaahing
fonte
3

Vim, 239 pressionamentos de tecla

:h4<CR>3hy5bZZitheanswerto<Esc>p:%s/ \|,//g<CR>ye3P
lqqi<CR><Esc>qqw3li <Esc>lq3@wbhr<CR>16l@q@w3-@w6l@ql@w9l@qll3@whr<CR>3l9@w4l@q 2@w4l@q2@w4l@q9l2@wlr<CR>9l@w4klr<CR>4whr<CR>jj
el<C-v>3k"aD0jji <Esc>qqdiwukPi <Esc>q5@qwy04j$"ap6+<C-v>GPp3kw3i <Esc>2@q4kbXj2@qywh<C-v>4jp2je<C-v>jj4A <Esc>8j5i <Esc>b<C-v>jj2I <Esc>

Quebras de linha adicionadas para "legibilidade"

Explicação

A primeira linha é arrancada life, the universe and everythingde uma página de ajuda, que é um byte menor do que simplesmente digitando-a. Em seguida, transforma isso em:

theanswertolifetheuniverseandeverythingtheanswertolifetheuniverseandeverythingtheanswertolifetheuniverseandeverythingtheanswertolifetheuniverseandeverything

A segunda linha divide a string em:

the answer
toli fetheuniv
ersea nde ver
ything the ans
wer tol ife the
uni ver sean
dev ery thin
gth ean swer
tolifetheuni ver
seandeveryth ing
the ans wer
tol ifetheuniver
sea ndeverything

E então a linha final o indenta para fazer:

       the        answer
      toli      fetheuniv
     ersea     nde     ver
    ything     the     ans
   wer tol     ife     the
  uni  ver           sean
 dev   ery         thin
gth    ean       swer
tolifetheuni    ver
seandeveryth   ing
       the     ans      wer
       tol     ifetheuniver
       sea     ndeverything
BlackCap
fonte
3

Geléia , 76 bytes

“¡¢ʋỵṆ⁻kỴ⁷ṁḤæ ƊVṛĠ¥¡¢tṢ}ȧƘ=ẒṆ_`-p1ḷṠ’ḃ⁴ĖŒṙḂ¬R“£:(ḥB⁼Ṇ#¥Ṡ1ɗĠðȮ $¿⁹½ɓ»ṁȯ€⁶s27Y

Experimente online!

Dennis
fonte
2

Retina , 185 bytes


7!8&sw'6Bi6fe!Av¶5#sea5nde5v'4y%g5!5&s¶3w#1B5ife5!¶2A2v#92se&¶1dev3#y9%¶gth4e&7sw'Bife!A4v'se&dev#yth3ing¶7!5&s6w'7B5ife!Av'7sea5ndev#y%g
'
#¶
&
an
%
thin
#
er
!
the
A
uni
B
tol
\d
$*

Experimente online!

ovs
fonte
2

JavaScript, 215 bytes

solução baseada em guest44851

$=>'a21xb0k9qf30155yiv016ewp3018lkhz0ohfdb077or302cl5b0mgzr0b8hz028ghs7028gi67028gi67'.split(p=0).map(x=>parseInt(x,36).toString(2).slice(1).replace(/./g,x=>" theanswertolifetheuniverseandeverything"[+x&&1+p++%39]))
tsh
fonte
2

Ruby , 216 bytes

o=i=1
puts"6iffnqxq0opdbco5e3f1zk5d7eezo2j6zwly9z5yykqsc1hl5svaof".to_i(36).to_s(17).chars.map{|c|
o=!o
c.to_i(17).times.map{o ? (i+=1)&&"ngtheanswertolifetheuniverseandeverythi"[i%39]:" "}.join
}.join.scan /.{1,27}/

Experimente online!

Explicação Semelhante às soluções Python, mas usei a codificação de comprimento de execução antes de converter para a base 36. Portanto, a sequência de dados tem apenas 54 caracteres em vez de 68.

Mas ainda acabou por mais tempo, espero que possa ser jogado ainda mais.

Simon George
fonte
2

C (gcc) , 220 219 217 213 210 bytes

-1 byte graças ao ceilingcat

-3 bytes graças a Jerry Jeremiah

q,i,j,t;main(c){for(;c="HDIG@GEGJ@FFFDFD@EGFDFD@DDBDFDFD@CDCDLE@BDDDJE@ADEDHE@AMED@AMDD@HDFDGD@HDFM@HDFM"[t++];)for(c%=64,j=c?q=!q,c:2;--j;)putchar(c?q?32:"theanswertolifetheuniverseandeverything"[i++%39]:10);}

Experimente online!

gastropner
fonte
Uma função é apenas metade de um programa - basta usar um programa completo para 214 bytes
Jerry Jeremiah
@JerryJeremiah Muito verdadeiro; boa pegada! Também poderia raspar mais um byte.
gastropner em 30/10
1

JavaScript, 265 237 219 bytes

(i=0)=>'jwq80,13ntvk,26p62g,25g7w8,239k3c,zg4xc,7rpbk,1e9dc,b8mw,5mbc,4f9reg,4f9r0g,4f9r0g'.split`,`.map(b=>parseInt(b,36).toString(2).slice(1).replace(/./g,c=>'  theanswertolifetheuniverseandeverything'[+c||2+i++%39]))

Poucos bytes de desconto graças a @tsh.

JSFiddle


fonte
.substr -> .slice (1) salva alguns bytes
tsh
"A saída pode estar na lista de cadeias de caracteres", então pule ojoin
tsh
@tsh. Obrigado. . .
1

Pitão , 121 bytes

Isso continha muitos bytes que eu não conseguia aparecer no TIO, então aqui está um hexdump: 

00000000: 7558 6848 477c 2a64 6548 622c 5658 434d  uXhHG|*deHb,VXCM
00000010: 2290 8d8d 817e 7e7b 7875 7572 6663 5753  "....~~{xuurfcWS
00000020: 504d 4946 4343 3f3c 3939 3633 302d 2d2a  PMIFCC?<99630--*
00000030: 2721 211e 1b16 160d 0909 0300 225d 545d  '!!........."]T]
00000040: 3133 6a43 2202 1232 a464 b09d 7303 4244  13jC"..2.d..s.BD
00000050: 9386 74d2 e954 b89e e722 3132 2a34 2e22  ..t..T..."12*4."
00000060: 6179 1aa6 55ad c176 932b 6088 d5c5 556c  ay..U..v.+`...Ul
00000070: e4f4 5575 12a0 e7fb 1f                   ..Uu.....

Experimente online!

Você pode adicionar uma chamada para wc ou xxdno script bash para ver o comprimento dos bytes ou o hexdump que produzi acima.

Curiosamente, este programa demonstra um bug menor (?) No Pyth. Quaisquer bytes de retorno de carro (0x0d) são lidos como bytes de nova linha (0x0a) quando estão em literais de string. Isso me força a adicionar 6 bytes:X ... ]T]13 substituir os dez incorretos por treze.

Caso contrário, a idéia por trás desse código era bastante simples: registre cada posição em que ocorre uma execução de espaço em branco. Em seguida, emparelhe cada um desses índices com o número de espaços nessa execução. Em seguida, reconstrua a sequência original repetindo a frase quatro vezes e inserindo nos locais corretos. Se o número de espaços registrados for zero, uma nova linha será inserida.

FryAmTheEggman
fonte
1

Java (OpenJDK 8) , 258 252 251 bytes

z->{int i=0,x,j,N[]={16515968,33489856,x=58950624,x+16,x-40,31458204,7865230,1966983,462847,233471,117670784,x=134185856,x};for(int n:N)for(j=32;j-->0;n/=2)System.out.print(n%2<1?j<1?"\n":" ":"theanswertolifetheuniverseandeverything".charAt(i++%39));}

Experimente online!

É uma implementação bastante ingênua. Primeiro uma máscara, para os caracteres impressos, depois um rolo sobre o texto até concluir.

  • 6 bytes salvos graças a Carlos Alejo!
Olivier Grégoire
fonte
Você pode salvar alguns bytes com int[]{16515968,33489856,x=58950624,x+16,x-40,31458204,7865230,1966983,462847,233471,117670784,x=134185856,x}.
20917 Charlie
0

Javascript, desenho aproximado. 319 bytes

s=32
t="theanswertolifetheuniverseandeverything"
j=0
o=""
b=document.createElement('canvas'),c=b.getContext('2d')
b.width=b.height=s
c.font="25px Verdana"
c.fillText('42',0,20)
m=c.getImageData(0,0,s,s)
i=0
while(i<m.data.length) {
 d=m.data[i+3]
 o+=d?t[j%t.length]:" "
 if(d)j++
 i+=4
}
o.match(/.{1,32}/g).join("\n")

^ pelo que vale a pena, na verdade não muito, mas antes de excluir o código com falha.

sq2
fonte