¡Hazme una manta!

16

Quiero una manta que se vea así. Cada tira va encima, debajo, encima, debajo. ¿Puedes imprimirlo?

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

Los espacios finales al final de cada línea y las nuevas líneas finales son aceptables.

Recuerde, este es el código de golf , por lo que gana el código con la menor cantidad de bytes.

Tablas de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Mostrar fragmento de código

code-golf ascii-art kolmogorov-complexity Oliver Ni
fuente
El borde derecho parece desalineado.
Urna mágica del pulpo
¿El borde izquierdo no se superpone?
xnor
@xnor Lo siento, mi mal.
Oliver Ni
@carusocomputing fijo.
Oliver Ni
10
Si hubiera utilizado el Sandbox, esos problemas podrían haberse evitado antes de que esto ocurriera en main.
Mego

Respuestas:

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)

Gracias a Sp3000 por 6 bytes de convertir las operaciones aritméticas en bit a bit.

xnor
fuente
Whoa ... ¿cómo?
Oliver Ni
1
i+~j>>2&1^i+j>>1&2^i&4, ¿quizás?
Sp3000
@ Sp3000 Esa es una buena precedencia bit a bit. Tendré que recordar eso cuando combine booleanos derivados aritméticamente en un índice.
xnor
5

Pyth, 36 bytes

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

Pruébalo en línea: demostración

Explicación:

Podemos determinar el símbolo marcando 3 condiciones:

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

Si interpretamos [A,B,C]como un número binario, obtenemos la siguiente asignación:

01234567
 \// \/\

También podemos interpretar [A,B,C]como número decimal y realizar una búsqueda indexada modular en la cadena. Esto no hace la diferencia porque 10 mod 8 = 2.

Ahora al código:

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

sm...48asigna los números d(column-idx) [0, 1, ..., 47]a los caracteres e imprime la cadena combinada.

++BNdgenera la lista [N, N+d], +...t-Ndagrega N-d-1. Entonces tenemos la lista [N, N+d, N-d-1]. m<3%k8comprueba cada número calculado k, si 3 < k % 8, entonces esto le da a la lista las condiciones [A, B, C].

i...Tconvence esto a un número decimal y luego @" \// \/\\"realiza la búsqueda en la cadena.

Más o menos el mismo código en 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
fuente
Solo trato de familiarizarme con Pyth para que cualquier respuesta decente con una buena explicación reciba un voto positivo de mi parte. iba a probar Pyth después de mi experimento de base 3 :)
ElPedro
También debe publicar la respuesta de Python2 ...
Jerry Jeremiah
3

Perl, 209 + 17 = 226 bytes

Ejecutar con -mList::Util=max -M5.010(la segunda bandera es gratis). No está ganando ninguna competencia de conteo de bytes, pero esta es mi solución.

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

Legible:

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

Genera procesalmente cada segmento, luego repite el patrón 6 veces, luego genera el resultado total 3 veces.

Gabriel Benamy
fuente
Woah, ya no soy la respuesta más larga :) +1 por hacerlo en Perl de todos modos.
ElPedro
Podría haberlo hecho de la misma manera que todos los demás (solo imprimiendo un montón de líneas), pero decidí hacer las cosas algorítmicamente en lugar de explícitamente porque sentí que era más genial.
Gabriel Benamy el
Genial para mis estándares. He adoptado un enfoque que nunca antes había probado porque era un desafío interesante. Como dije, +1. Ningún insulto pretendido por mi comentario. Por eso he votado.
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","\\"))

Encontré el patrón más pequeño que pude encontrar en la manta (el patrón "debajo" y "sobre"), lo pegué en una lista y agregué algo de comprensión de la lista y manipulación de cadenas para desempaquetarlo todo. Sustituyó todas las barras invertidas escapadas por "b" y las reemplazó más tarde para guardar algunos bytes.

¡Gracias a Oliver por jugar 2 bytes!

Se eliminaron 34 bytes cambiando el patrón: todo el patrón para la mantilla ahora está en una sola lista, por lo que solo se necesita uno para el bucle para desenvolver el patrón.

TheCrazyInventor
fuente
1
Bienvenido a PPCG! bonito primer post! Puede afeitarse un byte en Python 2. Creo que no necesita los padres para imprimir.
Rɪᴋᴇʀ
1
Gracias Easterly Irk, he estado al acecho en code golf durante demasiado tiempo, así que decidí participar. :)
TheCrazyInventor
1
Puede guardar dos bytes quitando el espacio después 0*6yu*6
Oliver Ni
1
Puede guardar 4 bytes usando la "b" para barras diagonales inversas dobles y en cualquier lugar donde necesite una barra invertida simple, simplemente use escape: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: su código no parece generar una manta 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)

No es bonita ni inteligente. Simplemente establece variables para los grupos de cadenas más utilizados, luego las combina e imprime el resultado 3 veces. Puede intentar jugarlo más tarde si no encuentro un mejor enfoque.

1 byte guardado mediante el uso de entrada sin formato en una asignación. Gracias @ nedla2004

-2 asignando un par de variables pero aún no un competidor serio

ElPedro
fuente
1
Puede definir a como r "\\"
nedla2004
Gracias @ nedla2004 Buen punto. Lancé esto bastante rápido e iba a verlo más tarde. Ese es un buen comienzo :)
ElPedro
Sin *6embargo, está más interesado en encontrar una forma de evitar el elemento de cada tupla. ¿Algunas ideas?
ElPedro
1
No sé cómo podrías hacer eso, pero la última línea puede ser exec r"print'\n'.join(d);"*3.
nedla2004
Acabo de publicar una alternativa por interés. Valoramos sus comentarios sobre eso también.
ElPedro
2

SOML , 106 bytes

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

una versión no competitiva que utiliza una función que agregué recientemente: ( 83 67 66 bytes)

explicación:

  →$\\→#////→@”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
fuente
2

Ruby, 75 bytes

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

Mejor golf, usando una sola búsqueda de cadena de 8 bytes indexada por j & 4 además de los otros parámetros, en lugar de una cadena de 4 bytes modificable.

Ruby, 81 bytes

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

Imprime las rayas diagonales carácter por carácter. El carácter correcto se selecciona de una cadena de 4 caracteres dependiendo de la presencia / ausencia de cada cadena. El carácter de superposición varía según el filamento que se encuentre en la parte superior.

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
fuente
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

Sin golf:

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
fuente
2

05AB1E , 37 bytes

Utiliza la codificación CP-1252 .

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

Pruébalo en línea!

Explicación

Utiliza el mod-8 truco explicado por expertos en respuesta 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
fuente
2

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

OK, más largo que mi última (y cualquier otra) respuesta, pero estaría interesado en recibir comentarios sobre el enfoque.

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 debido a que @ nedla2004 está más en la pelota que yo

-2 tomando la lambda fuera del bucle y perdiendo 2 espacios de sangría

-1 usando en in' '*3lugar de in 0,1,2ya que no uso de htodos modos. Es solo un mostrador.

-3 ¿Por qué, por qué, por qué dejé una nueva línea y 2 sangrías entre el segundo para y la impresión? Ya es tarde. Volveremos mañana.

-14 Realmente puede perder el lambda por completo e incluir el decodificador de base 3 directamente después de la declaración de impresión. Parece desordenado, pero después de todo, este es el código de golf :)

-4 No tiene sentido establecer una variable para la lista entera. Solo úsalo directamente en el segundo bucle for.

-14 y ningún punto usando el bucle externo. Simplemente multiplique la tupla entera por 3 (robada descaradamente de @ nedla2004 para obtener menos de 200 :))

-3 Guardado 3 haciendo \ = 0, / = 1 y espacio = 2. Esto hace que la lista entera sea más corta ya que tres de los números de base 3 ahora tienen ceros a la izquierda

Cómo funciona (y lo hace)

Como solo se usan 3 caracteres:

  1. l es una lista de los 8 patrones repetitivos como equivalentes enteros de su representación de base 3 suponiendo que "" = 0, "\" = 1 y "/" = 2

  2. El lambda El primer código después de la declaración de impresión es un convertidor ligero de entero a una cadena de base 3

  3. El primer bucle se repite 3 veces y el segundo imprime cada línea con los caracteres de base 3 multiplicados por 6 y reemplazados por /, \ o espacio.

Estoy seguro de que podría usar una expresión regular en lugar del reemplazo anidado (), pero estoy demasiado cansado para intentarlo en este momento. Esto fue solo un experimento y más largo que mi esfuerzo anterior con Python, pero he publicado solo para cualquier comentario sobre el enfoque (y también porque nunca antes había trabajado en la base 3 y disfruté mucho trabajando en el convertidor).

ElPedro
fuente
1
Simplemente puede eliminar la primera división en la conversión de base 3.
nedla2004
Por alguna razón, eso me estaba causando problemas antes, pero solo lo intenté y funciona ahora. Muchas gracias por estar más despierto que yo. Volveré a editar mi respuesta (y me acabas de guardar 9 bytes :))
ElPedro
1
Reescribí la conversión de base 3, ya no es una lambda, tuve que hacer que fuera una función, pero podría volver a convertirse en una lambda. Puedes encontrar la función aquí .
nedla2004
Gracias. Creo que una combinación de los dos puede funcionar, pero probablemente sea un trabajo para mañana por la noche :) Gracias nuevamente por sus comentarios.
ElPedro
1
Lo bajé a 169, aquí .
nedla2004
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

La matriz numérica corresponde a cada componente de cada línea, traducida a la base 3: = 0, \= 1, /= 2, luego convertida a decimal. Sin embargo, las llamadas a gsub () son demasiado grandes.

Y, justo ahora, vi la respuesta de @ ElPedro. :-( Solo coincidencia.

jose_castro_arnaud
fuente
e.to_s(3).rjust(8,"0")→ ("%8s"%e.to_s(3)); gsub("0"," ").gsub("1","\\")..gsub("2","/")→ tr("013"," \\/"); "\n"→ $/; .join→ *"". También puede guardar un byte dividiendo todos los números en la matriz por 4 y reemplazándolos epor (e*4).
Jordan
Vaya, supongo que debería ser tr("021"," /\\").
Jordania
90 bytes: tio.run/##DcjNDkUwEEDhV5FJJG0zl6mhauG@CHJDws5PlMUNnr26Ol/Ofg5/…
Jordania
2

PHP 157126 bytes

Tomando los cambios en las listas de @Titus en los comentarios ... Estoy molesto, me perdí el punto 1 que debería haber captado, pero no sabía que existía strtr (), que es de donde proviene la mayoría de los ahorros: ¡buen trabajo Titus!

NUEVO:

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

ANTIGUO:

<?$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
";}

Debido a que todas las barras invertidas necesitan escapar, ahorra bastante espacio para empaquetarlas como caracteres diferentes y reemplazarlas para la salida, y luego, una vez que llamo a str_replace (), tiene sentido usarlo con la mayor frecuencia posible.

ToXik-yogurt
fuente
1
Puede eliminar la etiqueta abierta si la usa -r. Use estos cinco pasos para guardar otros 30 bytes: ideone.com/wt4HGB 1) use $a[...]directamente como str_replaceparámetro en lugar de asignarlo. 2) en strtrlugar de str_replace. 3) Use dígitos en lugar de letras. 4) Incluir la asignación en el eco. 5) No asignes $a, solo úsalo.
Titus
1

Pitón 2, 169 161 165 160 155 154 152

Basado en la respuesta de @ ElPedro, con pequeñas mejoras. Para ver la explicación, vea su respuesta . Este es Python 2, aunque parece haber paréntesis cerca del print.

Se guardaron 8 bytes usando una variable para replace. Eso funciona solo para cadenas, y usar una función para ello sería más largo.

Ahorré 4 bytes al ver que @ElPedro se dio cuenta de que no lo necesitaban, y yo tampoco.

Ahorró 5 bytes al no voltear el range(8), y en lugar de usar +=para agregar a r, agregando r al final del nuevo dígito. Pruébalo usando repl.it

Ahorró 5 bytes al robar la nueva lista de valores de @ ElPedro.

Se guardó 1 byte al eliminar el espacio entre el iny (.

Se guardaron 2 bytes al eliminar la variable 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
fuente
Puede guardar 1 eliminando el espacio entre iny (en el primero para
ElPedro
También he perdido tres bytes al reordenar la secuencia de los números que representan cada carácter en la lista de base 3. Vea mi respuesta para una explicación. siéntase libre de copiar. En lo que a mí respecta, este es un esfuerzo conjunto y estoy feliz de ver que mi idea original tenía al menos algo de potencial :)
ElPedro
No es necesario a=3**i. Solo usa for i in range(8):r=x / 3 ** i% 3 +rpara salvar un par. la prioridad del operador se encarga del resto :)
ElPedro
No estoy seguro de cómo delimitar los caracteres de conversión de cadena. El analizador los eliminó en mi último comentario, así que no solo copie y pegue de mi sugerencia o se romperá :)
ElPedro
Buen punto, lo entendí.
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";

Salida:

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

Lote, 152 bytes

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

El procesamiento de cadenas en Batch apesta, por lo que este es probablemente el mejor enfoque. La llamada y caída es muy ligeramente más corta que un forbucle anidado . ¡Al menos no tengo que citar mis barras invertidas!

Neil
fuente
0

APL, 110 bytes

Soy nuevo en APL, así que esta es una solución simplista.

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

Aquí está mi enfoque: tenga en cuenta que después de las primeras 8 líneas de la manta, el patrón se repite. Por lo tanto, solo necesito definir las primeras 8 líneas, y luego puedo repetirlas 3 veces. También tenga en cuenta que cada línea se repite después de los primeros 8 caracteres. Por lo tanto, para definir una sola línea solo necesito definir los primeros 8 caracteres y luego repetirlos 8 veces.

Aquí hay una solución sin golf:

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

Observé anteriormente que D es el reverso de B, E es el reverso de A y H es el reverso de F. En mi código real, aprovecho esto al no definir D, F o H y usar la función inversa ⊖:

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

ren
fuente
0

Rubí, 132 bytes

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

Respuesta muy simple.

dkudriavtsev
fuente
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
fuente