Me faça um cobertor!

16

Eu quero um cobertor que se parece com isso. Cada faixa passa por cima, por baixo, por cima, por baixo. Você pode imprimi-lo?

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

Espaços à direita no final de cada linha e novas linhas à direita são aceitáveis.

Lembre-se, isso é código-golfe , então o código com o menor número de bytes vence.

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

# Perl, 43 + 2 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Mostrar snippet de código

code-golf ascii-art kolmogorov-complexity Oliver Ni
fonte
A borda direita parece desalinhada.
Magic Octopus Urn
A borda esquerda não se sobrepõe?
Xnor
@ xnor Desculpe, meu mal.
Oliver Ni
@carusocomputing Fixed.
Oliver Ni
10
Se você tivesse usado o Sandbox, esses problemas poderiam ter sido evitados antes que isso acontecesse.
Mego

Respostas:

8

Python 2, 84 bytes

R=range(24)
for i in R:print''.join(" \// \/\\"[i+~j>>2&1^i+j>>1&2^i&4]for j in R*2)

Graças ao Sp3000 por 6 bytes, transformou as operações aritméticas em operações bit a bit.

xnor
fonte
Whoa ... como ????
Oliver Ni
1
i+~j>>2&1^i+j>>1&2^i&4, possivelmente?
Sp3000 10/11/16
@ Sp3000 Essa é uma boa precedência bit a bit. Vou ter que lembrar que, ao combinar booleanos derivados aritmeticamente em um índice.
Xnor
5

Pitão, 36 bytes

V24sm@" \// \/\\"im<3%k8++BNdt-NdT48

Experimente online: Demonstração

Explicação:

Podemos determinar o símbolo verificando 3 condições:

A := row % 8 > 3
B := (row + column) % 8 > 3
C := (row - column - 1) % 8 > 3

Se interpretarmos [A,B,C]como um número binário, obteremos o seguinte mapeamento:

01234567
 \// \/\

Também podemos interpretar [A,B,C]como número decimal e executar uma pesquisa indexada modular na string. Isso não faz diferença porque10 mod 8 = 2 .

Agora para o código:

V24itera N(row-idx) sobre [0, 1, ..., 23].

sm...48mapeia os números d(column-idx) [0, 1, ..., 47]para chars e imprime a string combinada.

++BNdgera a lista [N, N+d], +...t-Ndacrescenta N-d-1. Então, nós temos a lista [N, N+d, N-d-1]. m<3%k8verifica cada número calculado k, se 3 < k % 8, portanto, isso fornece a lista com as condições [A, B, C].

i...Tconventa isso para um número decimal e, em seguida, @" \// \/\\"faz a pesquisa na string.

Mais ou menos o mesmo código em Python2: 98 bytes :

R=range(8)
for r in R*3:print''.join(" \// \/\\"[4*(r>3)+2*((r+c)%8>3)+((r-c-1)%8>3)]for c in R*6)
Jakube
fonte
Apenas tentando entender Pyth para que qualquer resposta decente com uma boa explicação receba um voto positivo de mim. ia tentar Pyth depois da minha experiência base 3 :)
ElPedro
Você deve publicar a resposta python2 bem ...
Jerry Jeremias
3

Perl, 209 + 17 = 226 bytes

Corra com -mList::Util=max -M5.010(o segundo sinalizador é gratuito). Não está ganhando nenhuma competição de contagem de bytes, mas aqui está a minha solução.

for(0..7){@b=(1)x8;@b[$_+3..$_+7]=(3)x4;@b[7-$_..10-$_]=(2)x4;for$c(0..2){$b[$c+8]=max$b[$c+8],$b[$c];$b[5-$c]=max$b[5-$c],$b[13-$c];}push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6;}say for@a,@a,@a

Legível:

for(0..7){
    @b=(1)x8;
    @b[$_+3..$_+7]=(3)x4;
    @b[7-$_..10-$_]=(2)x4;
    for$c(0..2){
        $b[$c+8]=max$b[$c+8],$b[$c];
        $b[5-$c]=max$b[5-$c],$b[13-$c];
    }
    push@a,sprintf("%-8s",join("",@b[3..10])=~tr[123][ /\\]r)x6
}
say for@a,@a,@a

Gera processualmente cada segmento, repete o padrão 6 vezes e, em seguida, gera o resultado total 3 vezes.

Gabriel Benamy
fonte
Woah, eu não sou mais o answe mais :) +1 por fazê-lo em Perl de qualquer maneira.
ElPedro 9/11
Eu poderia ter feito da mesma maneira que todos os outros (apenas imprimindo várias linhas), mas decidi fazer as coisas algoritmicamente, em vez de explicitamente, porque achei que era mais legal.
Gabriel Benamy
Legal pelos meus padrões. Eu adotei uma abordagem que nunca havia tentado antes, porque era um desafio interessante. Como eu disse, +1. Nenhum insulto pretendido pelo meu comentário. É por isso que eu votei.
ElPedro
3

Python 3, 174 172 138 bytes

print("\n".join(o*6for o in("bbbb////"," bb//// ","  ////  "," ////bb ","////bbbb","b//  bbb","bb    bb","bbb  //b")*3).replace("b","\\"))

Encontrei o menor padrão que encontrei no cobertor (o padrão "abaixo" e "acima"), coloquei-o em uma lista e adicionei alguma compreensão da lista e manipulação de cordas para desempacotar tudo. Substituiu todas as barras invertidas escapadas por "b" e as substituiu mais tarde para economizar alguns bytes.

Agradecimentos a Oliver por jogar fora 2 bytes!

Retirou 34 bytes alterando o padrão - todo o padrão para o cobertor agora está em uma única lista, portanto, apenas um loop for é necessário para desembrulhar o padrão.

TheCrazyInventor
fonte
1
Bem-vindo ao PPCG! bom primeiro post! Você pode raspar um byte no python 2, eu acho que não precisa dos parâmetros para impressão.
Rɪᴋᴇʀ
1
Obrigado Easterly Irk, estou espreitando no código de golfe há muito tempo, então decidi participar. :)
TheCrazyInventor
1
Você pode economizar dois bytes removendo o espaço após 0*6eu*6
Oliver Ni
1
Você poderia salvar 4 bytes utilizando o "b" para barras invertidas duplas e em qualquer lugar você precisa de uma única barra invertida apenas usar escapar:print((("\n".join(o*6 for o in("bb////"," b//// "," //// "," ////b ",""))+"\n".join(u*6 for u in("////bb","\\// b\\","b b","b\\ //\\","")))*3).replace("b","\\\\"))
dzaima
dzaima: seu código não parece gerar uma cobertura válida.
TheCrazyInventor
3

Python 2, 171 170 168 bytes

a,b,c=r"\\","/"*4," "
f,g=c*2,c+a+b+c
d=(a*2+b)*6,g*6,(f+b+f)*6,g[::-1]*6,(b+a*2)*6,('\\//'+f+a+"\\")*6,(a+f*2+a)*6,(a+"\\"+f+'//\\')*6
for e in 0,1,2:print'\n'.join(d)

Não é bonito nem inteligente. Apenas define variáveis ​​para os grupos de strings mais frequentemente usados, depois as combina e imprime o resultado 3 vezes. Pode tentar jogar mais tarde se não encontrar uma abordagem melhor.

1 byte salvo usando a entrada bruta na atribuição a. Obrigado @ nedla2004

-2 atribuindo algumas variáveis, mas ainda não sendo um concorrente sério

ElPedro
fonte
1
Você pode definir a como r "\\"
nedla2004 09/11
Obrigado @ nedla2004 Bom ponto. Reunimos isso muito rapidamente e veríamos mais tarde. Isso é um bom começo :)
ElPedro
*6Porém, o mais interessado em encontrar uma maneira de contornar cada elemento da tupla. Alguma ideia?
ElPedro 9/11
1
Não sei como você poderia fazer isso, mas a última linha pode ser exec r"print'\n'.join(d);"*3.
precisa saber é o seguinte
Acabei de publicar uma alternativa apenas por interesse. Gostaria de valorizar seus comentários sobre isso também.
ElPedro
2

SOML , 106 bytes

3{"\\\\////”6*p" \\//// ”6*p"  ////  ”6*p" ////\\ ”6*p"////\\\\”6*p"\//  \\\”6*p"\\    \\”6*p"\\\  //\”6*p

uma versão não concorrente usando uma função que eu adicionei recentemente: ( 83 67 66 bytes)

explicação:

  →$\\→#////→@”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~”
  →$                                                                in the further code replace "$" with "  "
    \\→#                                                            replace "#" with "\\"
        ////→@                                                      replace "@" with "////"
              ”6*p"→~3{"##@~ #@ ~$@$~ @# ~@##~\//$#\~#$$#~#\$//\~” the code to exchange stuff in

so that results in:
”6*p"→~3{"\\\\////~ \\//// ~  ////  ~ ////\\ ~////\\\\~\//  \\\~\\    \\~\\\  //\~”
”6*p"→~3{"A~B~C~D~E~F~G~H~”  modified version of the program (removing "/","\" and " " and replaced with A,B,C,ect.)
”6*p"→~                      replace in the further program "~" with ”6*p" which is:
”                            end string
 6*                          repeat the last thing in stack 6 times
   p                         output the result
    "                        start a string
resulting program: 
3{"A”6*p"B”6*p"C”6*p"D”6*p"E”6*p"F”6*p"G”6*p"H”6*p"”
shortened example:
3{"A”6*p"B”6*p"H”6*p"”
3{                      repeat 3 times
  "A”                   push "A" (original: "\\\\////")
     6*p                output it multiplied by 6
        "B”             push "B" (original: " \\//// ")
           6*p          output it multiplied by 6
              "H”       push "H" (original: "\\\  //\")
                 6*p    output it multiplied by 6
                    "”  push an empty string (shorter to do ~” than ”6*p)
dzaima
fonte
2

Ruby, 75 bytes

1152.times{|i|$><<"\\/ /\\\\ /"[(i+j=i/48)/4&1|(i-j)/2&2|j&4]+$/*(i%48/47)}

Melhor golfe, usando uma única pesquisa de string de 8 bytes indexada por j & 4, além dos outros parâmetros, em vez de uma string de 4 bytes modificável.

Ruby, 81 bytes

1152.times{|i|j=i/48%8;$><<"\\#{'/\\'[j/4]} /"[(i+j)/4&1|(i-j)/2&2]+$/*(i%48/47)}

Imprime as listras diagonais, caractere por caractere. O caractere correto é selecionado a partir de uma sequência de 4 caracteres, dependendo da presença / ausência de cada sequência. O caractere de sobreposição varia de acordo com o fio que está no topo.

Comentado

1152.times{|i|j=i/48%8;        #Iterate through all printable chars. j is line number.
  $><<"\\#{'/\\'[j/4]} /"[     #Print a char from "\/ /" if j/4 even or "\\ /" if odd. character changes depending which strand on top.
   (i+j)/4&1|(i-j)/2&2]+       #Print \ if (i+j)/4==0, / if (i-j)/2&2 >0, space if both false. As above if both true. 
   $/*(i%48/47)                #If on column 47, print a newline.
}
Level River St
fonte
2

Perl, 132 131 113 bytes

@a=((0)x4,1..4);map{say+(map$a[7-$_]?$a[$_]*$r?'/':'\\':$a[$_]?'/':$",0..7)x6;push@a,shift@a;$_%4||($r=!$r)}0..23

Ungolfed:

use strict;
use warnings;
use feature 'say';

my @a = ((1) x 4, (0) x 4);  # print '\' if true
my @b = ((0) x 4, (1) x 4);  # print '/' if true
my $r = 0;                   # print '\' over '/' if true

for (0 .. 23) {
    say((map { $a[$_] ? ($b[$_] * $r ? '/' : '\\') : ($b[$_] ? '/' : ' ') } 0 .. 7) x 6);
    unshift(@a, pop(@a));    # circular shift to left
    push(@b, shift(@b));     # circular shift to right
    $r = !$r if !($_ % 4);   # change print priority
}
Denis Ibaev
fonte
2

05AB1E , 37 bytes

Usa a codificação CP-1252 .

24FNU48FXXN+XN-<)8%3›J" \// \/\"è?}¶?

Experimente online!

Explicação

Usa o truque mod-8 habilmente explicado na resposta pyth de Jakube .

24F                                    # for N in [0 ... 23] do:
   NU                                  # save N in X
     48F                               # for N in [0 ... 48] do:
        XXN+XN-<)                      # push [X,X+N,X-N-1]
                 8%                    # mod each by 8
                   3›                  # compare with 3
                     J                 # join
                      " \// \/\"è?     # index into string and print
                                  }    # end inner loop
                                   ¶?  # print newline
Emigna
fonte
2

Python, 245 236 234 233 230 216 212 198 195 bytes

OK, mais do que a minha última (e qualquer outra) resposta, mas estaria interessado em comentários sobre a abordagem.

for a in(40,4496,6200,5456,3240,1188,720,228)*3:print((`a%6561/2178`+`a%2178/729`+`a%729/243`+`a%243/81`+`a%81/27`+`a%27/9`+`a%9/3`+`a%3/1`)*6).replace('0','\\').replace('1','/').replace('2',' ')

Editar

-9 devido a @ nedla2004 estar mais na bola do que eu

-2 tirando o lambda para fora do loop e perdendo 2 espaços de recuo

-1 usando em in' '*3vez de in 0,1,2desde que eu não uso de hqualquer maneira. é apenas um balcão.

-3 Por que, por que, por que deixei uma nova linha e 2 travessões entre o segundo para e a impressão ??? Está tarde. Irá revisitar amanhã.

-14 Pode realmente perder completamente o lambda e incluir apenas o decodificador base 3 diretamente após a declaração de impressão. Parece confuso, mas, afinal, este é o código de golfe :)

-4 Nenhum ponto configurando uma variável para a lista inteira. Basta usá-lo diretamente no segundo for loop.

-14 e nenhum ponto usando o loop externo. Apenas multiplique a tupla inteira por 3 (roubado descaradamente de @ nedla2004 para obter menos de 200 :))

-3 Salva 3 criando \ = 0, / = 1 e espaço = 2. Isso torna a lista inteira mais curta, já que três dos números da base 3 agora têm zeros à esquerda

Como funciona (e funciona)

Como apenas 3 caracteres são usados:

  1. l é uma lista dos 8 padrões de repetição como equivalentes inteiros de sua representação base 3, assumindo que "" = 0, "\" = 1 e "/" = 2

  2. O lambda O primeiro código após a declaração de impressão é um conversor leve de número inteiro para uma sequência base 3

  3. O primeiro loop faz um loop 3 vezes e o segundo imprime cada linha com os 3 caracteres base multiplicados por 6 e substituídos por /, \ ou espaço.

Tenho certeza de que poderia usar uma regex em vez da substituição aninhada (), mas estou cansada demais para tentar agora. Este foi apenas um experimento e foi mais longo que o meu esforço anterior em Python, mas postou apenas quaisquer comentários sobre a abordagem (e também porque nunca trabalhei na base 3 antes e gostei muito de trabalhar no conversor).

ElPedro
fonte
1
Você pode remover a primeira divisão na conversão base 3.
precisa saber é o seguinte
Por alguma razão, isso estava me causando problemas mais cedo, mas tentei e funciona agora. muito obrigado por estar mais acordado do que eu. Eu vou re-editar a minha resposta (e você acabou de me salvou 9 bytes :))
ElPedro
1
Reescrevi a conversão da base 3, ela não é mais um lambda, tive que transformá-lo em uma função, mas pode ser convertida novamente em um lambda. Você pode encontrar a função aqui .
precisa saber é o seguinte
Obrigado. Acho que uma combinação dos dois pode funcionar, mas provavelmente é um trabalho para amanhã à noite :) Obrigado novamente por seus comentários.
ElPedro
1
Eu reduzi para 169 aqui .
precisa saber é o seguinte
2

Ruby, 135 bytes

puts [3320,1212,720,2172,6520,4144,2920,3184].map{|e|(e.to_s(3).rjust(8,"0").gsub("0"," ").gsub("1","\\").gsub("2","/"))*6+"\n"}.join*3

A matriz numérica corresponde a cada componente de cada linha, convertida na base 3: = 0, \= 1, /= 2 e depois convertida em decimal. As chamadas gsub () são muito grandes, no entanto.

E, agora mesmo, vi a resposta da @ ElPedro. :-( Apenas coincidência.

jose_castro_arnaud
fonte
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". Você também pode salvar um byte dividindo todos os números na matriz por 4 e substituindo epor (e*4).
Jordan
Opa, acho que deveria ser tr("021"," /\\").
Jordan
90 bytes: tio.run/##DcjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5/…
Jordan
2

PHP 157 126 bytes

Tomando as alterações nas listas @Titus nos comentários ... Estou chateado por ter perdido o ponto 1, que eu deveria ter pego, mas não sabia que existia strtr (), que é onde a maioria das economias ocorre - bom trabalho Titus!

NOVO:

while($i<32)echo$b=strtr([3322,' 322 ','0220',' 223 ',2233,12013,3003,13021][$i++%8],['  ','\\','//','\\\\']),"$b$b$b$b$b\n";

VELHO:

<?$a=[zzyy,' zyy ',syys,' yyz ',yyzz,xysxz,zssz,xzsyx];while($i<32){$b=$a[$i++%8];$b=str_replace([z,x,y,s],['\\\\','\\','//','  '],$b);echo"$b$b$b$b$b$b
";}

Como todas as barras invertidas precisam escapar, economiza bastante espaço para empacotá-las como caracteres diferentes e substituí-las pela saída, e quando chamo str_replace (), faz sentido usá-lo o mais rápido possível.

ToXik-yogHurt
fonte
1
Você pode remover a marca aberta se você usar -r. Siga estas cinco etapas para salvar outros 30 bytes: ideone.com/wt4HGB 1) use $a[...]diretamente como str_replaceparâmetro em vez de atribuí-lo. 2) em strtrvez de str_replace. 3) Use dígitos em vez de letras. 4) Inclua a atribuição no eco. 5) Não atribua $a, apenas use.
Titus
1

Python 2, 169 161 165 160 155 154 152

Baseado na resposta do @ ElPedro, com pequenas melhorias. Para ver a explicação, veja a resposta deles . Este é o Python 2, embora pareça haver parênteses perto do print.

Economizou 8 bytes usando uma variável para replace.Isso funciona apenas para strings e o uso de uma função seria mais longo.

Economizei 4 bytes ao ver que o @ElPedro percebeu que eles não precisavam de l, e eu também não.

Salva 5 bytes não invertendo range(8)e, em vez de usar +=para acrescentar r, adicionando r ao final do novo dígito. Experimente usando repl.it

Economizou 5 bytes roubando a nova lista de valores do @ ElPedro.

Economizou 1 byte removendo o espaço entre ine( .

Salva 2 bytes removendo a variável a.

for x in(40,4496,6200,5456,3240,1188,720,228)*3:
 r=''
 for i in range(8):r=`x/3**i%3`+r
 print(r*6).replace('0','\\').replace('1','/').replace('2',' ')
nedla2004
fonte
Você pode salvar 1 removendo o espaço entre ine (o primeiro de
ElPedro 10/11
Também perdi três bytes reordenando a sequência de quais números representam cada caractere na lista base 3. Veja minha resposta para explicação. sinta-se livre para copiar. Tanto quanto eu estou em causa este é um esforço conjunto e eu estou feliz de ver que a minha idéia original tinha pelo menos algum potencial :)
ElPedro
Você não precisa a=3**i. Basta usar for i in range(8):r=x / 3 ** i% 3 +rpara salvar um casal. precedência do operador cuida do resto :)
ElPedro
Não sabe ao certo como delimitar os caracteres de conversão de string. O analisador removido-los no meu último comentário por isso não basta copiar e colar de minha sugestão ou ele vai quebrar :)
ElPedro
Bom ponto, eu entendi.
nedla2004
1

PHP, 184 bytes

<?$p=['1111////',' 11//// ','  ////  ',' ////11 ','////1111','1//  111','11    11','111  //1'];for($j=0;$j<3;$j++)for($i=0;$i<8;$i++)echo str_replace(1,'\\',str_repeat($p[$i],6))."\n";

Resultado:

C:\PHP>php make-me-a-blanket.php
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
\\\\////\\\\////\\\\////\\\\////\\\\////\\\\////
 \\////  \\////  \\////  \\////  \\////  \\//// 
  ////    ////    ////    ////    ////    ////  
 ////\\  ////\\  ////\\  ////\\  ////\\  ////\\ 
////\\\\////\\\\////\\\\////\\\\////\\\\////\\\\
\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\\//  \\\
\\    \\\\    \\\\    \\\\    \\\\    \\\\    \\
\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\\\\  //\
Mario
fonte
0

Lote, 152 bytes

@call:l
@call:l
:l
@for %%s in (\\\\//// " \\//// " "  ////  " " ////\\ " ////\\\\ "\//  \\\" "\\    \\" "\\\  //\")do @echo %%~s%%~s%%~s%%~s%%~s%%~s

O processamento de strings no Lote é péssimo, portanto essa é provavelmente a melhor abordagem. O call-and-fall-through é muito ligeiramente mais curto que um forloop aninhado . Pelo menos não preciso citar minhas barras invertidas!

Neil
fonte
0

APL, 110 bytes

Eu sou novo na APL, então essa é uma solução simplista.

A←48⍴'\\\\////'⋄B←48⍴' \\//// '⋄C←48⍴'  ////  '⋄F←48⍴'\//  \\\'⋄G←48⍴'\\    \\'⋄24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

Aqui está minha abordagem: observe que, após as primeiras 8 linhas do cobertor, o padrão se repete. Portanto, eu só preciso definir as 8 primeiras linhas e depois posso repeti-las 3 vezes. Observe também que cada linha se repete após os 8 primeiros caracteres. Portanto, para definir uma única linha, só preciso definir os 8 primeiros caracteres e depois repeti-los 8 vezes.

Aqui está uma solução não destruída:

A←48⍴'\\\\////'⋄ ⍝ set A to a 48 element vector (48⍴) of repeated '\\\\////'s
B←48⍴' \\//// '⋄ ⍝ set B to a 48 element vector (48⍴) of repeated ' \\//// 's
C←48⍴'  ////  '⋄ ⍝ ...
D←48⍴' ////\\ '⋄ ⍝ Note that this is actually the reverse of vector B
E←48⍴'////\\\\'⋄ ⍝ Note that this is actually the reverse of vector A
F←48⍴'\//  \\\'⋄
G←48⍴'\\    \\'⋄
H←48⍴'\\\  //\'⋄ ⍝ Note that this is actually the reverse of vector F

24 48 ⍴ A,B,C,D,E,F,G,H ⍝ Make a 24 by 48 character matrix (24 48⍴) by concatenating A,B...H
                        ⍝ and repeating the string until the matrix is full

Observei acima que D é o inverso de B, E é o inverso de A e H é o inverso de F. No meu código real, aproveito isso não definindo D, F ou H e usando a função reversa ⊖:

24 48⍴A,B,C,(⊖B),(⊖A),F,G,⊖F

ren
fonte
0

Ruby, 132 bytes

puts Zlib.inflate Base64.decode64 "eJzt0bENADAMAsGeKdggC/3+cyQRC+A2ipuT3RgJgHWGUjm6VXb2Vjn/3KpJ/qtIPlp1v+XSKZKPVk3y/x5+D6/3sAEUXQ+Q"

resposta muito simples.

dkudriavtsev
fonte
0

Haskell, 96 bytes

f n=n`mod`8`div`4
putStr$unlines[["\\ //\\ \\/"!!(f(x-y)+2*f(x+y)+4*f y)|x<-[0..47]]|y<-[0..23]]
Angs
fonte