Esta es mi almohada

66

... me ayudarás a inmortalizarlo?

ingrese la descripción de la imagen aquí

He tenido esta almohada hace unos años, y aparentemente es hora de deshacerse de ella. ¿Puede escribir una función o programa que pueda traer conmigo y usar para recrear esta almohada cuando quiera recordar un poco?

Debe funcionar sin argumentos de entrada.

El resultado debería verse exactamente así (las líneas y espacios finales están bien).

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

Este es el código de golf, por lo que gana el código más corto en bytes.

Tabla de clasificación

Mostrar fragmento de código

code-golf  ascii-art  kolmogorov-complexity 
— Stewie Griffin
fuente
77
Estoy un poco decepcionado de que el patrón no sea un poco más complejo, para representar los diferentes grosores de línea de la almohada.
— Sparr el
44
@Sparr Lo intenté, pero no logré que se viera bien usando solo caracteres ASCII. Pensé que esto estaba lo suficientemente cerca :)
— Stewie Griffin
3
Acababa de agregar espacios
— Sparr el
1
'aparentemente': P
— Pysis el
77
Ahora puede comprar una almohada en blanco e imprimir el fragmento ganador en ella.
— coredump

Respuestas:

24

05AB1E , 18 15 bytes

Código:

„/\5×{4Å6×»6F=R

Explicación:

„/\               # Push the string "/\"
   5×             # Repeat 5 times: "/\/\/\/\/\"
     {            # Sort, resulting in: "/////\\\\\"
      4Å6         # Create a list of 6's with length 4: [6, 6, 6, 6]
         ×        # Vectorized string multiplication
          »       # Join by newlines
           6F     # Do the following six times..
             =    #   Print with a newline without popping
              R   #   Reverse the string

Utiliza la codificación CP-1252 . Pruébalo en línea!

— Adnan
fuente
2
Wow ... dos tomas diferentes, el mismo número de bytes ...
— Oliver Ni
30

/// , 116 bytes

/a/\\\\\\\\\\\\\\\///b/\\\\\\\\\\\\\\\\//A/aaaaa//B/bbbbb//C/ABABABABABAB
//D/BABABABABABA
/CCCCDDDDCCCCDDDDCCCCDDDD

Pruébalo en línea!

Editar : los \\\\\\\\\\\\\\\/y \\\\\\\\\\\\\\\\son en realidad un solo / y \, respectivamente.

Editar : -3 porque pensé en eliminarlo i. Creo que esto no puede ser más golfizado.

— Erik el Outgolfer
fuente
15

Python 2, 49 bytes

b,a='\/';exec("print(a*5+b*5)*6;"*4+"a,b=b,a;")*6

Gracias a Mitch Schwartz por este método limpio que guarda un byte. La idea es imprimir cuatro líneas de ('\\'*5+'/'*5)*6, intercambiar los roles de barra diagonal y barra diagonal inversa, y luego hacer todo el proceso 6 veces. Los dos caracteres se almacenan en ay b, y se intercambian como a,b=b,a. El doble bucle es doble al generar la siguiente cadena de código y luego ejecutarla con exec:

print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;print(a*5+b*5)*6;a,b=b,a;

50 bytes:

s='/'*5+'\\'*5;exec("print s*6;"*4+"s=s[::-1];")*6

Hace la cadena de línea, la imprime cuatro veces y luego la invierte, luego lo hace 6 veces. Lo hace generando el siguiente código y luego ejecutándolo:

print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1];print s*6;print s*6;print s*6;print s*6;s=s[::-1]

Estas son algunas de las iteraciones de mi golf:

for c in([1]*4+[-1]*4)*3:print('/'*5+'\\'*5)[::c]*6

for i in range(24):print('/\\'*5+'\/'*5)[i/4%2::2]*6

for c in range(24):print('\\'*5+'/'*5)[::(c&4)/2-1]*6

for i in range(24):print('/'*5+'\\'*5)[::1-i/4%2*2]*6

for c in([1]*4+[0]*4)*3:print('\/'*5+'/\\'*5)[c::2]*6

for c in([1]*4+[0]*4)*3:print('\/'[c]*5+'/\\'[c]*5)*6

for c in(['/\\']*4+['\/']*4)*3:print(c[0]*5+c[1]*5)*6

for c in([5]*4+[-5]*4)*3:print('/'*c+'\\'*5+'/'*-c)*6

print((('/'*5+'\\'*5)*6+'\n')*4+(('\\'*5+'/'*5)*6+'\n')*4)*3

for x in(['/'*5+'\\'*5]*4+['\\'*5+'/'*5]*4)*3:print x*6

a='/'*5;b='\\'*5
for x in([a+b]*4+[b+a]*4)*3:print x*6

s='/'*5+'\\'*5
for x in([s]*4+[s[::-1]]*4)*3:print x*6

s=('/'*5+'\\'*5)*9
exec("print s[:60];"*4+"s=s[5:];")*6

a='/'*5;b='\\'*5
for i in range(24):print[a+b,b+a][i/4%2]*6
— xnor
fuente
12

05AB1E, 15 bytes

„/\5×{R6×6FR4F=

Pruébalo en línea!

Explicación:

„/\             # Push "/\"
   5×           # Repeat string five times: "/\/\/\/\/\"
     {          # Sort: "/////\\\\\"
      R         # Reverse: "\\\\\/////
       6×       # Repeat string six times
         6F     # Repeat the following six times:
           R    #   Reverse
            4F  #   Repeat the following four times:
              = #     Print without popping

Utiliza la codificación CP-1252 .

— Oliver Ni
fuente
8

JavaScript (ES6), 68 60 58 bytes

Una función recursiva. Varias optimizaciones inspiradas en la respuesta chocochaos .

f=(n=1440)=>n--?'/\\'[n/240&1^n/5&1]+(n%60?'':`
`)+f(n):''

Manifestación

Mostrar fragmento de código

— Arnauld
fuente
Creo que puedes omitir el primero &1y guardar dos bytes
— Henrik Christensen
@HenrikChristensen Eso solo funcionaría n < 480. Para n >= 480, necesitaríamos paréntesis: (n/240^n/5)&1.
— Arnauld
8

Chicle , 30 bytes

00000000: d307 8118 1020 9dc5 3544 3523 f8a4 b386  ..... ..5D5#....
00000010: aae6 e113 cfa3 f13c 1acf a3f1 0c00       .......<......

Respuesta obligatoria de Bubblegum.

— LegionMammal978
fuente
¡Oh Dios mío, este lenguaje es increíble!
— Pedro A
7

Haskell, 77 70 57 bytes

a%b=(<*[1..a]).([1..b]>>)
unlines$4%3$5%6<$>["/\\","\\/"]

Boring concats y replicates en lugar de jugar con los senos. Viejo era:

unlines[["\\/"!!(ceiling$sin(pi*x/5)*sin(pi*y/4))|x<-[0.5..59]]|y<-[0.5..23]]
— Angs
fuente
6

Brainfuck, 140 bytes

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

:-RE

— 0WJYxW9FMN
fuente
3
¡Oh mira! La solución brainfuck es ocho bytes más corta que la solución Java. Es hora de que los codificadores de Java cambien a brainfuck ...
— 0WJYxW9FMN
Java contraataca
— cliffroot
6

Python 2, 86 80 76 74 73 bytes

for z in range(24):a=('/'*5+'\\'*5)*24;print((a+a[::-1])*3)[z*60:z*60+60]

Probablemente podría jugar un poco más, pero es un comienzo.

Editar

Guardado 6 al eliminar algunos corchetes innecesarios

Otros 4 usando una sola cadena y luego invirtiéndola

Gracias @Adnan. Anoche tuve una noche tarde y todavía no estoy completamente despierto: p

-1 moviendo *24a la variable en lugar de usarla dos veces

— ElPedro
fuente
44
Creo que *6*4es lo mismo que *24? : p
— Adnan el
6

Brainfuck, 149 bytes

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

El mejor intérprete EVAR!

Esto utiliza 6 celdas (sin envoltura, sin módulo). Aquí están:

0A 00 2F 00 5C 00

Las 00celdas se usan para los contadores de bucle. Aquí, los contadores se completan con valores iniciales:

0A 06 2F 04 5C 03

El contador más a la izquierda es para el bucle más interno (sí, uso bucles anidados de profundidad 3). Tenga en cuenta que la cuarta celda ( 04contador) se usa dos veces, una /////\\\\\...vez y una vez \\\\\/////...cada vez.

0A, 2Fy 5Cson los caracteres \n, /y \, respectivamente.

— Erik el Outgolfer
fuente
6

Python 2.7 66 -> 56 -> 55 bytes

a="/"*5+"\\"*5;b=a[::-1];c=6*a+"\n";d=6*b+"\n";e=4*c+4*d;print e*3

nuevo en el código de golf

a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3

Gracias Stewie Griffin

Olvidé un espacio en blanco tonto;)

— Ivar Matstoms
fuente
2
Bienvenido a PPCG! Buena primera respuesta :) ¿Puedes omitir algunas de las variables intermedias? Al menos dy etal vez más. No he probado esto, pero debe ser estrecha: print(4*c+4*(6*b+"\n"))*3. Son 5 bytes menos.
— Stewie Griffin
3
55 bytes:a="/"*5+"\\"*5;print(4*(6*a+"\n")+4*(6*a[::-1]+"\n"))*3
— Stewie Griffin el
6

Brainfuck, 179 bytes

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

Sé que este no es el mejor puntaje en el hilo, pero quería probar brainfuck y probarlo.

Editar: debo haber cometido un error al copiar el texto. Esta versión debería funcionar

— Axel Matstoms
fuente
Bienvenido al sitio!
— DJMcMayhem
No funciona para mi El navegador cuelga con este intérprete , y uno personal muestra una salida de 5 líneas no esperada: /////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\ cuatro veces, luego infinito \ .
— aluriak
Sí, funciona :)
— aluriak
5

Pyke, 16 bytes

"/\"6*5m*n+4*sD3

Después de la actualización de hoy que permitió "en literales de cadena, 17 bytes

"/\\"6*5m*n+4*sD3

Pruébalo aquí!

— Azul
fuente
5

MATL , 18 16 bytes

'\/'6:&+thK5&Y")

Pruébalo en línea!

Explicación

'\/'   % Push this string
6:     % Push array [1 2 3 4 5 6]
&+     % 6×6 matrix with all pair-wise additions from that array
th     % Concatenate horizontally with itself. Gives a 6×12 matrix
K      % Push 4
5      % Push 5
&Y"    % Repeat each entry of the matrix 4 times vertically and 5 times horizontally
       % This gives a 24×60 matrix
)      % Index (modularly) into the string. This produces the desired 24×60 char array
— Luis Mendo
fuente
5

Pyth, 22 bytes

V6V4V12p*5?%+bN2\\\/)k

Probarlo aquí .

Explicación:

V6                     Loop 6 times, with N from 0 to 5:
  V4                   Loop 4 times, with H from 0 to 3:
    V12                Loop 12 times, with b from 0 to 11:
      p                Print without newline
        *              The repetition
          5            5 times of
          ?            if
            %          the remainder
              + b N    when the sum of b and N
              2        is divided by 2
          \\           then the "\" character
          \/           else the "/" character
    )                  End
                       (implicitly print with newline)
  k                    k (empty string)
                       (implicit end)
                       (implicit end)

Lo siento si la explicación es un poco difícil de entender, pero fue un poco complicada.

— RK.
fuente
5

V , 22 21 bytes

Editar Un byte ganado, gracias @DjMcMayhem:

5á\5á/05ä$4Ä5x$p4Ä3ä}

Los cambios son:

  • Y4P-> 4ÄUse la línea duplicada V en lugar del comando integrado Vim (esto agregará una línea en blanco al final del párrafo)
  • 3äG-> 3ä}Duplicar el párrafo en lugar del búfer completo (para evitar la línea en blanco generada por el cambio anterior)

Publicación original

5á\5á/05ä$Y4P5x$p4Ä3äG

Pruébalo en línea

Descompuesto así:

5á\                    Write 5 \
   5á/                 Write 5 / after
      0                Go to the beginning of the line
       5ä$             Copy the text to the end of the line and repeat it 5 times
          Y4P          Copy the line and create 4 new copies
             5x$p      Delete the 5 first characters and put them at the end of the line
                 4Ä    Duplicate this line
                   3äG Duplicate the whole text
— statox
fuente
¡Es genial ver a alguien más usando V! Hasta hace poco, solo he sido yo. Si alguna vez necesita ayuda con él, no dude en enviarme un ping en el byte diecinueve
— DJMcMayhem
Sí @DrMcMoylex su lenguaje parece divertido de usar :-) He tenido un problema en este caso: al principio me quería utilizar 5á\5á/05ä$5Ä5x$p4Ä3äGes decir, sustituir Y4Ppor 4Ä, pero por una razón que no entiendo que copia una línea en blanco adicional ... Si es posible ilumíneme sobre esto sería bueno. Además, si encuentro algo de tiempo libre, con gusto contribuiría al idioma (especialmente el número 4 )
— statox
Ah, sí, eso me ha preocupado muchas veces. Es un problema conocido. El problema es que Äes sinónimo de ddno Y. Esto generalmente no es un problema, pero causa algunos problemas si el búfer tiene solo una línea o si está en la última línea.
— DJMcMayhem
En realidad, me he dado cuenta, este enfoque todavía funcionaría si reemplazó 3äGcon 3ä}ya que no será un tirón ese último salto de línea. v.tryitonline.net/…
— DJMcMayhem
Ok, creo que entiendo por qué no funcionó ahora. Y buena manera de ganar 1 byte, ¡gracias!
— Statox
4

En realidad , 21 bytes

"/\"5*SR6*;4α@R4α+3αi

Pruébalo en línea!

-1 byte de Adnan

Explicación:

"/\"5*SR6*;4α@R4α+3αi
"/\"5*                 "/\" repeated 5 times
      SR               sort and reverse (result: "\\\\\/////")
        6*             repeat string 6 times (forms one row)
          ;4α          copy and push a list containing 4 copies
             @R4α+     push a list containing 4 copies of the reversed string, append to previous list (now we have one row of diamonds)
                  3α   repeat pattern vertically 2 more times
                    i  flatten and implicitly print
— Mego
fuente
¿Puedes hacer algo como "/\"5*Spara crear la cadena de barras?
— Adnan
@Adnan ¡Gran idea!
— Mego
4

Ruby, 46 bytes

Crea la siguiente cadena (70 caracteres, un conjunto más de lo necesario) luego alterna entre muestrear caracteres 0..59y 5..64de ella.

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

código y salida

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*5,60]}

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

error interesante (un 7 en lugar de un 5)

24.times{|i|puts ((?/*5+?\\*5)*7)[i/4%2*7,60]}

/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\
— Level River St
fuente
4

APL, 30 bytes

A←240⍴'/////\\\\\'⋄24 60⍴A,⊖A

Soy bastante nuevo en APL (estoy usando APLX, pero esto debería funcionar en la mayoría de las implementaciones de APL), por lo que esta es una solución bastante simplista.

Explicación:

A ← 240 ⍴ '/////\\\\\' ⍝ set A to be a 240 character vector populated with '/////\\\\\'
⋄                      ⍝ statement separator
24 60 ⍴ A,⊖A           ⍝ populate a 24 by 60 character matrix with the concatenation 
                          of A and the reverse of A (⊖A)
— ren
fuente
4

C, 66 61 bytes

5 bytes guardados gracias a orlp.

Impresión directa de caracteres por caracteres. 61 caracteres por fila, el último es nueva línea (ASCII 10) y los otros alternan entre /47 y \92.

i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);‌​}

//call like this
main(){f();}
— Level River St
fuente
61 bytes: i;f(){for(i=1463;i;)putchar(i--%61?i%61/5+i/244&1?92:47:10);}.
— orlp
@orlp gracias, sabía que tenía que haber una mejor manera con el i--pero no tuve tiempo para buscarlo.
— Level River St el
3

Python 2, 63 bytes

a='\n'.join([('/'*5+'\\'*5)*6]*4);print'\n'.join([a,a[::-1]]*3)

Para Python 3, haga esto (65 bytes):

a='\n'.join([('/'*5+'\\'*5)*6]*4);print('\n'.join([a,a[::-1]]*3))
— Erik el Outgolfer
fuente
1
Esto usa el mismo método que mi respuesta Jelly .
— Erik the Outgolfer
Un método más eficiente que el mío para empezar
— ElPedro el
@ElPedro Básicamente, acabo de hacer una manipulación de cadenas / matrices. El truco es que he preparado una cadena más grande: /////\\\\\/////...cuatro veces, separadas por nuevas líneas
— Erik the Outgolfer
3

J, 31 28 19 bytes

4#_60]`|.\5#72$'/\'

Uso

   4#_60]`|.\5#72$'/\'
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////\\\\\/////
— millas
fuente
3

Octava, 50 48 bytes

Función anónima:

@()repmat([A=repmat(47,4,5) B=A*2-2;B A ''],3,6)

Puedes probar en línea aquí . Simplemente ejecute el comando anterior y luego ejecute la función con ans().

Esencialmente, esto crea una matriz del valor 47 que es 4 alto y 5 ancho. Luego crea una segunda matriz de valor 92 que es del mismo tamaño.

Las dos matrices se concatenan en un tablero de ajedrez [A B;B A]. El también ''se concatena para forzar la conversión a cadenas de caracteres.

Finalmente, toda la matriz se replica 3 veces hacia abajo y 6 veces para formar el tamaño final.

  • Guardado 2 bytes, gracias @StewieGriffin
— Tom Carpenter
fuente
no necesita una función anónima; guardar 3 bytes
— Tasos Papastylianou
@TasosPapastylianou hay, de lo contrario se imprimirá ans=antes de la almohada. Tenerlo en la función evita esto, ya que se espera que devuelva la respuesta a una variable en lugar de mostrarla.
— Tom Carpenter, el
Eso es solo semántica. Quiero decir, si vas a ser pedante, me preocuparía más por los mensajes de advertencia de 3 líneas que aparecen en su lugar: p También las reglas habituales establecen que debe ser una salida de un comando de terminal directo o un llamado función de manejar. Lo que significa que debe asignar su función anónima a un identificador (o agregar otros 5 bytes para tener en cuenta la necesidad de pring ans()). Lo cual no tiene sentido, ya que ans() todavía se imprime anscuando se ejecuta.
— Tasos Papastylianou
@TasosPapastylianou ans()es un identificador de función invocable, por lo que no es necesario asignarlo a algo con, por ejemplo a=@..., porque está implícitamente asignado anscomo un identificador. Además, no se imprime ans=cuando se ejecuta a menos que se lo pidas específicamente al no hacer nada con el valor devuelto y no agregar un ;. Si lo hiciera disp(ans()), solo imprimiría la salida exacta (no ans=). Pero sí, la advertencia es molesta, sin embargo, eso no sucedió anteriormente, por lo que no es un idioma específico, sino un intérprete específico.
— Tom Carpenter
Ok, estaremos de acuerdo en no estar de acuerdo. A mi modo de ver, si confía disp(ans())antes de obtener su salida, entonces necesita agregar 12 bytes a su respuesta. Mi propia opinión es que esta es la forma en que la octava presenta su resultado y está bien.
— Tasos Papastylianou
3

PHP, 73 69 bytes

for($s='/\\';$i<1440;$i++)echo$i%60<1?'
':'',$s[($i/5+($i/240|0))%2];

Manifestación

http://ideone.com/z7N1Md

— chocochaos
fuente
1
69 bytes: for($s='/\\';$i<1440;$i++)echo$i%60<1?'\n':'',$s[($i/5+($i/240|0))%2];(reemplace el \ncon una nueva línea real). echono es una función, por lo tanto, no necesita paréntesis. Además, echopuede recibir múltiples valores, separados por una coma. Esto realmente elimina la necesidad de esos paréntesis. Y luego, dentro de su $s[...], el cálculo más externo tampoco necesita paréntesis, ya que está contenido dentro []. Usar $s[($i/5+($i/240|0))%2]tiene el mismo efecto y es más corto.
— Ismael Miguel el
Gracias, actualizado! Ni siquiera sabía que el eco aceptaba múltiples parámetros ^ _ ^
— chocochaos el
echoy printacepta múltiples parámetros. Pero printrequiere paréntesis con múltiples parámetros cuando se usa en el incremento, condición o asignación de un bucle.
— Ismael Miguel
Puede eliminar eso <1, cambiando las expresiones echo$i%60?'':' ',, nueva línea como expresión 3 en el ternario.
— Progrock el
3

Java 7, 120 bytes

String c(){String r="";for(int i=0;i<1440;r+=(i%60<1?"\n":"")+(i/60%8<4?i%10<5?"/":"\\":i%10<5?"\\":"/"),i++);return r;}

Empujó todo en un bucle. Beats Brainfuck, misión cumplida.

Véalo en línea: https://ideone.com/pZjma3

— acantilado
fuente
3

Vim, 44 27 bytes

EDITAR Gran cantidad de bytes ganados gracias a @DrMcMoylex:

5i\<esc>5a/<esc>0y$5PY4P5x$pY3PyGPP

Respuesta original:

No estoy seguro de que realmente se ajuste a las reglas de este sitio, pero pensé que fue divertido probarlo:

i\<esc>59.:s;\v(.{5})\1;\1/////;g<CR>Y4P5x$pY3PyGPP

Que se puede descomponer así:

i\<esc>                       Insert a \
59.                           Repeat 59 time the insertion
:s;\v(.{5})\1;\1/////;g<CR>   Match 5 characters followed by the same 5 characters
                              And replace them by these 5 characters followed by 5 /
Y4P                           Copy the line and repeat it 4 times
5x$p                          On the current line delete 5 characters and put them 
                              at the end of the line
Y3P                           Copy the line and repeat it 3 times
yG                            Copy all the lines
PP                            Repeat them 2 times
— statox
fuente
Oh hola statox, bienvenido al sitio! Esto se ajusta totalmente a las reglas. Practico golf principalmente en vim. Para que lo sepas, puedes hacer 5i/<esc>5a\<esc>0y$5Pal principio para guardar 9 bytes.
— DJMcMayhem
Hola DrMcMoylex (¿nombre nuevo? :-)) me alegro de verte aquí y que mi respuesta encaja. También gracias por su sugerencia,
— editaré
2
Jaja, sí, cambié temporalmente mi nombre debido a este desafío , jajaja. Lo cambiaré de nuevo en 30 días
— DJMcMayhem
3

Brainfuck, 168 bytes

++++++[>++++++++<-]>-<+++++++++[>>++++++++++<<-]>>++<<+++++[>>>++<<<-]>>>>+++[>++++[>++++++[<<<<<.....>.....>>>>-]<<<.>>-]++++[>++++++[<<<<.....<.....>>>>>-]<<<.>>-]<-]
— Mitchell Humphrey
fuente
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.