Os caminhantes juntam-se! - logo de Alan Walker

13

Talvez você conheça Alan Walker da sua sempre popular música Faded. Agora, seus "seguidores" se chamam Walkers e têm um logotipo, aqui está uma versão simplificada:

\\
 \\              //\\  
  \\            //  \\            //
   \\          //    \\          //
    \\        //      \\        //
     \\      //        \\      //
      \\    //          \\    //
       \\  //    //\\    \\  //
        \\//    //  \\    \\//
         //    //    \\    \\
        //\\  //      \\  //\\
           \\//        \\//  \\
                              \\

O objetivo deste desafio é imprimir este logotipo.

REGRAS:

  1. Se você retornar uma lista de seqüências de caracteres de uma função conforme os meta-padrões, forneça um rodapé que a imprima na tela.
  2. Todos os caracteres do logotipo acima devem estar lá. Sem atalhos!
  3. O menor número de bytes vence!
code-golf  ascii-art  kolmogorov-complexity 
— Dat
fonte
pode haver espaços extras no final de cada linha (como eles não mudam a aparência da saída)? Pode haver novas linhas iniciais / anexas?
— Dzaima 17/08/19
@ dzaima, sim você pode.
— Dat
+1 para Alan Walker !!
— HighlyRadioactive

Respostas:

14

Carvão , 31 30 29 27 bytes

Ｆ²«Ｊι⁰↙χ↖↖⁵↙↙⁵↖↖²Ｐ↖χ↙↗χ↘↘¹²

Experimente online! Link é a versão detalhada do código. Infelizmente Copy, não faz o que eu quero neste caso, então tenho que fazer um loop. Explicação:

Ｆ²«Ｊι⁰

Desenhe tudo duas vezes, mas com o cursor iniciando um caractere para a direita na segunda vez.

   ↙χ↖↖⁵↙↙⁵↖↖²Ｐ↖χ

Desenhe o W principal da direita para a esquerda, mas deixe o cursor próximo ao V. invertido

   ↙↗χ↘↘¹²

Desenhe o V. invertido

— Neil
fonte
Você "apenas" vence as soluções ingênuas por 20 bytes: P
— Stephen
1
@StepHen A economia de 46% não é ruim, dada a sobrecarga de definir um loop-se, em primeiro lugar ...
— Neil
O espelhamento não é mais curto para isso?
— Stephen
5
@StepHen Corrigir muito os custos de assimetria. Melhor que pude fazer foi de 35 bytes: Ｆ²«Ｊι⁰↘χ↗↗⁵Ｍ⁵↑←↙χ»‖Ｍ↥\\¶ \\Ｆ²«Ｊι⁰↖³.
— Neil
13

JavaScript (ES6), 172 139 bytes

let f =

_=>`1
3s1
5o5o
7k9k
9gdg
bchc
d8l8
f48194
h08590
i899
g14d41
n0h05
1p`.replace(/.p?/g,n=>' '.repeat((n=parseInt(n,36))/2)+(c='/\\'[n&1])+c)

O.innerText = f()
<pre id=O>
Expandir snippet

Quão?

O logotipo consiste basicamente em grupos de espaços seguidos por um //ou outro \\e feeds de linha.

Espaços e padrões finais são codificados usando os valores da base 36:

  • O bit menos significativo fornece o padrão final: 0for //, 1for \\.
  • Todos os outros bits fornecem o número de espaços antes do padrão final.

Tudo pode ser codificado dessa maneira com um único dígito base-36, exceto a última linha que consiste em 30 espaços seguidos por \\, levando a 30 * 2 + 1 = 61 = 1pna base-36. Isso pdeve ser interpretado como 12 espaços seguidos por, \\mas esse padrão não aparece em lugar algum. Assim, podemos simplesmente lidar com este caso especial no custo de 2 bytes extras na expressão regular: /.p?/.

Primeira versão, 186 bytes

NB: Este foi enviado antes da atualização do logotipo.

Mostrar snippet de código

— Arnauld
fonte
Bem jogado. Fiz uma facada nisso antes de verificar as respostas; terminou com algo semelhante à sua versão de 172 bytes.
— Shaggy
7

brainfuck , 579 bytes

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

Experimente online!

Gera as constantes 47 92 32 10na memória e as seleciona e gera como apropriado.

— Conor O'Brien
fonte
Estou bastante certo de que este pode ser golfed para baixo, especialmente essa última parte
— Stan Strum
@StanStrum Sinta-se à vontade para tentar. Eu tentei, mas não consegui encontrar uma maneira agradável de expressá-lo, especialmente considerando a verbosidade de BF em condicionais.
— Conor O'Brien
4

Bubblegum , 77 76 bytes

Hexdump:

0000000: 75cf c109 8000 0c43 d17b a6c8 0659 28fb  u......C.{...Y(.
0000010: cf21 05cb a782 3de9 4b5a b495 5b9f 4946  .!....=.KZ..[.IF
0000020: 870f dac3 f8ea 5704 51b9 2284 c611 0114  ......W.Q.".....
0000030: 9029 f09e ec67 2362 21e1 075e 2136 29b9  .)...g#b!..^!6).
0000040: 08b9 bf97 8939 cf33 ebbf d33e            .....9.3...>

Experimente online!

Limiar de chiclete. : P

— totalmente humano
fonte
3

/// , 166 bytes

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

Experimente online!

— Conor O'Brien
fonte
3

C (gcc) , 377 bytes

char*r="2\\01 2\\14 2/2\\02 2\\12 2/2 2\\12 2/03 2\\10 2/4 2\\10 2/04 2\\8 2/6 2\\8 2/05 2\\6 2/8 2\\6 2/06 2\\4 2/10 2\\4 2/07 2\\2 2/4 2/2\\4 2\\2 2/08 2\\2/4 2/2 2\\4 2\\2/09 2/4 2/4 2\\4 2\\08 2/2\\2 2/6 2\\2 2/2\\011 2\\2/8 2\\2/2 2\\030 2\\";char d[9];main(i){do{if(*r==48)puts(""),r++;for(i=0;isdigit(*r);d[i++]=*r++);for(d[i]=0,i=atoi(d);i--;putchar(*r));}while(*r++);}

Experimente online!

— cleblanc
fonte
— ceilingcat 27/07/19
3

Haskell, 161 160 bytes

foldr(\a->(++(' '<$[1..fromEnum a-last(96:[64|a<'`'])])++last("\\\\":["//"|a<'`'])))""<$>words"` `Na LbLb JdJc HfHd FhFe DjDf Bd`DBg @dbD@h ddDI `BfB`H b@h@k ~"

Experimente online!

Os espaços anteriores \\são codificados como letras minúsculas e antes //como letras maiúsculas, onde o número de espaços é o valor ASCII menos 96 (ou 64). Zero espaços é `/ @. Os espaços de cada linha são armazenados na ordem inversa, porque são consumidos pela dobra à direita.

— nimi
fonte
2

Carvão , 51 bytes

Ｐ↘¹²→↘¹²↑Ｐ↗⁵→↗⁵↓Ｐ↘⁵→↘⁵↑Ｐ↗χ→↗χＭ¹¹↓Ｍ⁵←Ｐ↖¹²←↖¹²↓Ｐ↙χ←↙χ

Experimente online!

Carvão , 50 bytes

Ｐ↘χ→↘χ↑Ｐ↗⁵→↗⁵Ｍ⁵↑←Ｐ↙χ←↙χＭχ↗‖ＭＭ¹⁸←Ｐ↖²←↖²Ｊ²⁷¦⁹Ｐ↘²→↘²¦

Experimente online!

— Stephen
fonte
2

Carvão , 50 31 bytes

Ｆ²«↘¹²↗↗⁵↘↘⁵↗↗⁹Ｍχ↓Ｍ⁴←↖¹²↙↙χＪ¹¦⁰

Experimente online! Link é a versão detalhada.

Eu tentei. (Além disso, vou apontar que fiz isso completamente sozinho, mesmo que pareça um pouco com o outro. [Shiz, fiz novamente. A propósito, ainda é diferente: P])

— totalmente humano
fonte
1

Geléia , 65 bytes

“<fṭY2Ẹ<ƭẹ£ʋ¥¹)Œ<Ẓ⁹ḣ⁶ıĠ\ṃṛ?04|ẏḌẉƙ+’b36⁶ẋ“ÇỴ$ñ⁵FḄ’Bị⁾\/¤ẋ€2¤żFs36

Experimente online!

Retorna uma lista de caracteres. O link TIO possui um rodapé para imprimir em linhas separadas.

— Erik, o Outgolfer
fonte
1

PHP, 186 bytes:

Ambas as versões requerem PHP 5.5 ou posterior.

Corra com -nrou experimente-os online

a compactação de espaço oferece a alternativa mais curta:

(barra invertida dupla mapeada para 0, barra dupla para f, letras compactadas em dígitos)

while(~$c="0
1077f0
2066f2066f
3055f4055f
408f608f
506f806f
604f5504f
702f4f0402f
80f4f2040f
9f4f4040
8f02f602f0
560f80f20
87870"[$i++])echo+$c?str_pad("",$c):strtr($c,["\\\\",f=>"//"]);

O PHP 7.1 gera avisos; substitua +$cpor $c>0para corrigir.

bitmap codificado em base 64 ( 187 bytes ):

(espaço mapeado para 00, nova linha para 01, barra invertida para 10e barra invertida para 11, em seguida, concatenou 3 "pixels" cada para um caractere, precedido 1e convertido de binário em ASCII)

for(;$c=ord("d`@@@@yB@@@@p`@@@M@`@@C@H@@@t@`@@p@H@@M@B@@p@@`@M@@`C@@@H@t@@`pC`BCP@@l@p`Bt@@C@L@`BP@@xL@BCd@@@K@@Bpd@@@@@@@@@B"
[$i++]);)for($b=6;$b;)echo[" ","
","\\\\","//"][3&$c>>$b-=2];

(primeira quebra de linha por conveniência de leitura; a outra é essencial)

— Titus
fonte
1

Chiclete , 74 bytes

00000000: 758c 4b11 0400 0885 eea6 a081 85e8 9f63  u.K............c
00000010: 4fb2 7f4f 0e30 4f07 e5ed 7615 8613 e16f  O..O.0O...v....o
00000020: 321c ab89 d484 4a22 2591 8a48 45a0 2052  2.....J"%..HE. R
00000030: 809e dfd5 481e 3d0d 7a24 4d96 bc43 b2fd  ....H.=.z$M..C..
00000040: 96d3 cdbf fff9 7fa7 f300                 ..........

Experimente online!

— ovs
fonte
1

PowerShell , 221 220 bytes

$ofs=''
"b
 b$(' '*14)/b
$((2..6|%{' '*$_+"b$(($a=' '*(14-++$i*2)))/$(' '*$i*2)b$a/`n"}))   4b  /4/b4b  /
44b/4/  b4b/
44 /4/4b4b
44/b  /4  b  /b
44   b/44b/  b
$(' '*30)b"-replace4,'    '-replace'/','//'-replace'b','\\'

Experimente online!

Abordagem bastante ingênua ( e 50 bytes pior que a resposta do JS, encolher ). Alguém sabe como fazer vários -replaces no PowerShell?

-1 byte graças a Veskah.

— AdmBorkBork
fonte
— Veskah 14/03/19
@Veskah Economia simples de bytes. Obrigado!
— AdmBorkBork
1

Python 2 , 180 bytes

print''.join(c<'3'and'\\/\n\\/'[int(c)::3]or' '*(int(c,36)-2)for c in'0230g104240e140e1250c160c1260a180a127081a08128061c0612904161060412a0161406012b16160602a1041804102d01a01402w0')

Experimente online!

A codificação é base 36:

0 => \\
1 => //
2 => \n

e caso contrário,

n => (n-2) spaces
— Chas Brown
fonte
1

C # (compilador interativo do Visual C #) , 122 bytes (121 caracteres)

_=>@"
A
9;13) +!(# 0$(	-) 
4	(	€".SelectMany(j=>(j%2>0?"//":@"\\").PadLeft(j/4)+(j%4>1?"\n":""))

Experimente online!

Explicação

Cada parte do logotipo tem apenas 0 + espaços com um \\ou um //no final, além de talvez uma nova linha. Existem 52 deles. Em seguida, codificamos cada segmento em um caractere:

  • Pegue o número de espaços em cada segmento e adicione 2 a esse número.

  • Bit desloque o número para a esquerda 2 vezes.

  • Se o segmento terminar com // , bit a bit OU o número por um.

  • Se o segmento terminar com uma nova linha, bit a bit OU o número por dois.

  • Pegue o número e jogue-o em um char.

  • Repita para cada segmento.

Aqui estão todos os 52 segmentos e o valor numérico em que eles codificam:

10,12,65,10,16,57,16,59,20,49,24,51,24,41,32,43,28,33,40,35,32,25,48,27,36,17,25,8,24,19,40,9,25,16,24,11,45,25,24,26,41,8,17,32,17,10,52,9,40,9,18,128
— Modalidade de ignorância
fonte
j>>2->j/4
— somente ASCII
124 . Também acho que você pode colocar os bytes nulos se você criar manualmente o URL
— ASCII-only
na explicação: deslocamento de bits para a esquerda , não para a direita. Também lista de strings é apenas se você voltar cada linha como a sua própria corda ... você vai precisar do string.Concataqui para que seja válido ...
— ASCII-only
próximo , isso é 143, enquanto o normal é 141
— somente ASCII
@ Somente ASCII Tenho certeza de que retornar uma lista de strings como essa é permitido, mas adicionarei outra solução por precaução. No entanto, isso é válido: tio.run/##Sy7WTS7O/…
— Modalidade de ignorância
0

C (gcc) , 144 140 139 bytes

-4 bytes graças ao ceilingcat .

Cada caractere na sequência codifica um número de espaços a serem usados ​​antes de uma determinada sequência. Se for uma letra minúscula (ou um backtick), a sequência será "\" e, se for maiúscula ou @, será "//". Um espaço significa uma nova linha.

f(c,i){for(i=0;c="` aN` bLbL cJdJ dHfH eFhF fDjD gBD`dB h@Dbd@ IDdd H`BfB` k@h@b ~"[i++];)printf("%*s",c%32+2,c<33?"\n":c<96?"//":"\\\\");}

Experimente online!

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