17

Su desafío es generar exactamente el siguiente cuadro:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................

La caja es de altura y ancho 50, los espacios son dos de ancho.

Debe escribir una función o programa que genere o devuelva una cadena y no tome ninguna entrada.

¡Pocos bytes ganan!

code-golf ascii-art kolmogorov-complexity

— Pavel
fuente

44

¿Alguna razón por la cual el +cuadro más interno solo tiene 1 capa en la parte superior e inferior? Eso hará que las respuestas basadas en algoritmos sean un poco más largas, ya que significa que las dos capas más internas no son exactamente cuadradas.

— ETHproductions

@Pavel OK. Voto cerrado retraído :)

— Trauma digital

44

¿Por qué la restricción en un programa completo?

— Rɪᴋᴇʀ

1

@Pavel ¿por qué? Realmente no agrega nada al desafío.

— Rɪᴋᴇʀ

1

@Pavel ..... no. Quiero decir, sí, algunos tienen eso, pero no es, de lejos, un requisito / estándar para los desafíos de KG.

— Rɪᴋᴇʀ

10

Pyke, 20 17 bytes

k25V". + "ohe@A.X

Pruébalo aquí!

k                 - out = ""
 25V              - repeat 25 times:
          oh      -     (o++)+1
            e     -    ^//2
    ". + "   @    -   " + ."[^] (wraps around)
              A.X -  out = surround(out, ^)

La función de sonido envolvente se creó para preguntas de complejidad kolmogorov como esta.

— Azul
fuente

14

J , 25 bytes

echo'. + '{~4|>./~2#|i:12

Pruébalo en línea!

Explicación

echo'. + '{~4|>./~2#|i:12
                     i:12  Range from -12 to 12.
                    |      Take absolute values,
                  2#       duplicate every element,
                /~         compute "multiplication table"
              >.           using maximum,
            4|             take mod 4 of every element,
    '. + '{~               index into this string,
echo                       print char matrix for everyone to see.

— Zgarb
fuente

Creo que puedes dejar el eco.

— Conor O'Brien

@ ConorO'Brien Oh, la regla de salida cambió. ... Hmm, pero si elimino echo, ni siquiera será una función, solo un valor. Aunque J no tiene funciones de argumento cero de todos modos.

— Zgarb

Creo que eso está permitido según la naturaleza de respuesta de J. En cualquier caso, las funciones constantes pueden considerarse como argumento cero.

— Conor O'Brien

11

C, 115 bytes

#define M(x,y)x<(y)?x:y
f(i){for(i=2549;i;i--)putchar(i%51?". + "[(M(i%51-1,M(50-i%51,M(i/51,49-i/51))))/2%4]:10);}

Define una función f(llamar como f();) que imprime la cadena en STDOUT.

— Lynn
fuente

9

C, 535 478 477 Bytes

Ahora que es mucho golf: - /

i;main(j){for(;++i<51;puts(""))for(j=0;++j<51;)putchar(i<3|i>48?46:j<3|j>48?46:i>4&i<47&j>4&j<47?i<7|(i>44&i<47)|(j>2&j<7)|(j>44&j<47)?43:j>8&j<43&((i>8&i<11)|(i>40&i<43))?46:i>9&i<41&((j>8&j<11)|(j>40&j<43))?46:i>13&i<37&((j>12&j<15)|(j>36&j<39))?43:((i>12&i<15)|(i>36&i<39))&j>12&j<39?43:i>17&i<33&((j>16&j<19)|(j>32&j<35))?46:((i>16&i<19)|(i>32&i<35))&j>16&j<35?46:i>21&i<29&((j>20&j<23)|(j>28&j<31))?43:((i>20&i<23)|(i>28&i<31))&j>20&j<31?43:i>24&i<27&j>24&j<27?46:32:32);}

Aquí está la salida;

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................

— cleblanc
fuente

2

Mierda Admiro tu dedicación.

— Rɪᴋᴇʀ

He cambiado la restricción, las funciones que devuelven una cadena están permitidas ahora.

— Pavel

Me acabo de dar cuenta de que puedo jugar unos pocos bytes reescribiendo los bucles for(;i++<51;y ahora estoy libre por uno en todas partes: - /

— cleblanc

@cleblanc++i

— dkudriavtsev

MFW Empecé a tratar de entender esto: i.imgur.com/TLV9gJ4.png +1

— Urna de pulpo mágico el

6

Haskell, 72 bytes

q=(\n->[n,n]).abs=<<[-12..12]
unlines[[". + "!!mod(max x y)4|y<-q]|x<-q]

La solución de @ Zgarb en Haskell. También intenté construir el cuadro agregando capas alrededor del núcleo ["..",".."], pero es 9 bytes más largo (81 bytes).

e!b=e:e:b++[e,e];s#c=(c!)<$>(c<$s!!0)!s
unlines$foldl(#)["..",".."]" + . + . + ."

— nimi
fuente

5

Apilado, no competitivo, 35 bytes

Pruébalo aquí!

ε'.'3$' + .'2*tostr*+$surroundfold

Sin golf:

'' '.  ++  ..  ++  ..  ++  ..' $surround fold

Bastante sencillo. surroundes una función que, bueno, rodea a una entidad con una entidad de relleno. Por ejemplo, (0) 1 surroundes ((1 1 1) (1 0 1) (1 1 1)). $surroundes surroundcomo una función, no evaluada. foldtoma un valor inicial, luego algo para doblar, luego una función. En este caso, surroundse folded, que rodea la cadena inicialmente vacía ''(equiv. ε) Con cada carácter de la cadena.

'.'3$' + .'2*tostr*+

Esto es hacer primero una cadena de caracteres $' + .'que, cuando se multiplica por un número, repite cada carácter. Esto nos deja con: ++ ... Esto se convierte en una cadena. Luego, repetimos esta secuencia tres veces, y finalmente anteponemos una ., dándonos la secuencia deseada.

Un enfoque diferente para 39 bytes:

' .'3$' + .'2*tostr*+toarr$surround#\out

#\se inserta y toma el carácter inicial de la cadena como valor inicial. También solo funciona en matrices.

— Conor O'Brien
fuente

Cómo es que esto no es competitivo, el desafío surgió hace solo unas horas.

— Pavel

@Pavel Siempre estoy trabajando en esto

— Conor O'Brien el

4

JavaScript (ES6), 117 bytes

f=(n=12,c=`. + `[n%4],t=c.repeat(n*4+2))=>n?t+`
${t}
${f(n-1).replace(/^|$/gm,c+c)}
${t}
`+t:`..
..`
console.log(f())

Expandir fragmento

La solución no recursiva me llevó 128 bytes:

console.log([...Array(100)].map((_,i,a)=>a.map((_,j)=>`. + `[j=j>50?j-50:51-j,(i>j?i:j)%8>>1],i=i>50?i-50:51-i).join``).join`\n`)

Donde \nrepresenta el carácter literal de nueva línea.

— Neil
fuente

4

C, 97 bytes

i,x,y;main(){for(;i<2550;putchar(++i%51?". + "[(x*x<y*y?y:x)&3]:10))x=i%51/2-12,y=i/102-12;}

— orlp
fuente

3

Jalea , 18 bytes

12ŒRAx2»þ`ị“ + .”Y

Pruébalo en línea!

El mismo enfoque que la respuesta J de Zgarb: 12ŒRAes abs([-12 … 12]), x2repite cada elemento dos veces, »þ`crea una tabla de máximos, ị“ + .”indexa cíclicamente en una cadena y se Yune mediante nuevas líneas.

— Lynn
fuente

3

05AB1E , 39 35 33 bytes

•â3fM~•3B…012… .+‡.pvyD¤sg25s-×«Â«})Â«»

Pruébalo en línea!

•â3fM~•3B                               # Push 1100220011002200110022001
         …012… .+‡                      # Push ..  ++  ..  ++  ..  ++  .
                  .p                    # All prefixes of the above string.
                    vy            }     # For each prefix.
                      D¤sg25s-×         # Repeat the last letter until length is 25.
                               «Â«      # Concat, bifurcate, concat.
                                   )Â«» # Wrap to array, bifurcate, concat, print.

Versión de 33 bytes que ahora es más fresca porque Emigna comentó que me ahorró 2 bytes:

". + "DøJ3×'.«.pvy¤25yg-×«Â«})Â«»

Pruébalo en línea!

— Urna de pulpo mágico
fuente

1

". + "DøJ3×'.«.pvy¤25yg-×«Â«})Â«»por 33 bytes.

— Emigna

… .+•â3fM~•3BSè.pvy¤25yg-×«Â«})Â«»para 34 bytes en la "versión más fresca".

— Emigna

Cool no era la elección correcta de la palabra jaja. "¿Menos Ghetto", tal vez?

— Magic Octopus Urn

Me encanta tu uso del comando prefijo. ¡Brillante!

— Emigna

1

@Emigna, los prefijos forman un triángulo, si transpone el triángulo y lo gira, luego combínelo con los prefijos originales, puede eliminar los bytes. Ese era el plan principal al que no podía llegar.

— Urna de pulpo mágico

2

MATL , 21 bytes

'. + '[]25:"TTYaQ]2/)

Pruébalo en línea!

'. + '    % Push this string
[]        % Push empty array. This will be used as "seed"
25:"      % Do the following 25 times
  TTYa    %   Extend the array with a frame of zeros
  Q       %   Add 1 to each entry
]         % End
2/        % Divide by 2
)         % Index modularly into the string. Non-integer indices are rounded
          % Implicitly display

— Luis Mendo
fuente

2

Ruby, 77 bytes

-623.upto(676){|i|print i%26>0?". + "[[(i%26-13).abs,(i/52).abs].max%4]*2:$/}

— Level River St
fuente

Creo que puede reemplazar la expresión de índice con [i%26-13,i/52].map(&:abs).max%4(guarda un byte)

— Conor O'Brien

2

Carbón de leña , 25 bytes

Ｆ…¹¦²⁶⁺×ι§. + ÷ι²¶‖Ｏ↗‖Ｃ↑←

Pruébalo en línea! El enlace contiene un modo detallado para explicación

— Solo ASCII
fuente

2

Python 3 , 89 bytes

r=range(-24,26)
for i in r:print("".join([". + "[max(abs(i//2),abs(j//2))%4]for j in r]))

Pruébalo en línea!

— Monja permeable
fuente

1

Haskell, 385 bytes

    b 0 = ["..", ".."]
b n = f:f:s:s:m (b (n - 1)) ++s:s:f:f:[]
    where f = replicate (8*n+2) $ d
          s = l++replicate ((8*n)-6) ' ' ++r
          m (x:xs) = map (\x -> l ++ x ++ r ) $ t
          l = d:d:' ':' ':[]
          r = reverse l
          t = b (n - 1)
          d :: Char
          d | n `mod` 2 == 0 = '.'
            | n `mod` 2 == 1 = '+'
main = mapM_ putStrLn $ b 6

Primera ronda de golf de código aquí ... esperando ver cómo otros abordan esta.

Salida:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................

— brander
fuente

3

1) Tienes toneladas de espacios en blanco innecesarios. 2) coloque todas las definiciones de funciones dentro de whereuna sola línea y úselas ;para la separación. 3) f:f:[]es f:[f] and d: '': '': [] `es d:" ". 4) mtoma un parámetro pero no lo usa. En línea my t. 5) definir una nueva función #para reemplazar replicate: c#x=c<$[1..8*n+x]y llamarlo como d#2y ' '#(-6). 6) mod 2 == 0se puede reemplazar con even, o voltear la prueba y el uso oddy el golfista otherwise:1<2 . ...

— nimi

2

... en general:

b n=f:f:s:s:map(\x->l++x++r)(b$n-1)++s:s:f:[f]where f=d#2;s=l++' '#(-6)++r;l=d:d:"  ";r=reverse l;d|odd n='+'|1<2='.';c#x=c<$[1..8*n+x]

.

— nimi

1

Octava, 53 bytes

 '.  ++  .'(mod(bsxfun(@max,x=[24:-1:0 0:24],x'),8)+1)

Genere un patrón repetitivo de 1 a 8 desde el centro hacia afuera y úselo como índice para la extracción de elementos de . ++ .

¡Pruébelo en línea!

— rahnema1
fuente

1

Bash, 191 bytes

echo H4sIAGUcgFgAA73VOw7AIAyD4b2n6F6J+x+v6k5CnPy1F6ZPAvNaS80li4/cUvrkKWdGapOak3O5DDmVS5G8XI5k5ZIkLpclUbk02ZfLk125f5B4JIljLY59cZwxx31x3H3HO5aFIo7/pZIpqWZClHSJmg55AeBhTxb2CQAA|base64 -d|gunzip

Probablemente puede volverse más pequeño, pero era más pequeño que mis intentos algorítmicos.

— Throx
fuente

1

C #, 203 bytes

Programa completo y legible:

using System;
public class P
{
    public static void Main(string[] a)
    {
        Func<string> f = () =>
        {
            var z = 25;
            var t = "";
            Func<int, string> c = (q) => q % 4 == 0 ? ".." : (q % 4 != 2 ? "  " : "++");
            for (var y = 0; y < z; y++)
            {
                var l = "";
                for (var x = 0; x < z; x++)
                        l += ((y > z / 2) ? (x >= y | x < z - y) : (x < y | x >= z - y)) ? c(x):c(y);
                l += "\n";
                t += l + l;
            }
            return t;
        };

        Console.Write(f());
        Console.ReadKey();
    }
}

Función de golf :

()=>{var z=25;var t="";Func<int,string>c=(q)=>q%4==0?"..":(q%4!=2?"  ":"++");for(var y=0;y<z;y++){var l="";for(var x=0;x<z;x++)l+=((y>z/2)?(x>=y|x<z-y):(x<y|x>=z-y))?c(x):c(y);l+="\n";t+=l+l;}return t;};

— CSharpie
fuente

1

05AB1E , 33 bytes

14G" . +"NL¤¸13N-.×«€D¨Â«èD})¨Â«»

Pruébalo en línea!

Explicación

14G                               # for N in [1 ... 13]
   " . +"                         # push this string
         NL                       # push range [1 ... N]
           ¤¸13N-.×               # push a list of 13-N repetitions 
                                  # of the last element of the above range
                   «              # concatenate the two ranges
                    €D            # duplicate each element
                      ¨           # remove the last element
                       Â«         # concatenate a reversed copy to the list
                         è        # use the elements of the list to index into the string
                          D       # duplicate the resulting string
                           }      # end loop
                            )     # wrap the strings in a list
                             ¨    # remove the last element
                              Â«  # concatenate a reversed copy
                                » # join the list on newlines

— Emigna
fuente

Explicación por venir?

— Pavel

@Pavel: ¡por supuesto! :)

— Emigna

1

PowerShell , 171 151 bytes

($x=(1..12|%{' . +'[$_%4]}|%{($a+=$_+$_)})+"$a."|%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}|%{,($_+-join$_[25..0])*2});$x[23..0]

Pruébalo en línea!

Ho-hum respuesta. Estoy seguro de que hay un camino más corto (dada la longitud de las otras respuestas, estoy seguro), pero esto muestra algunos buenos trucos.

Explicación:

1..12|%{' . +'[$_%4]} genera una matriz de cadenas (de un carácter de longitud), en el patrón correcto que necesitamos. Pruébalo en línea!

Luego agregamos el |%{($a+=$_+$_)})+"$a."que toma la matriz y la expande hacia los lados según la fila anterior. Pruébalo en línea!

Esas cadenas se envían en forma de bucle, |%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}. En cada iteración, elegimos el carácter correcto (ya sea un signo más, un punto o un espacio), y luego usamos la .PadRightfunción para rellenar el número apropiado de caracteres.Pruébalo en línea!

Ahora, tenemos los cimientos de la esquina superior derecha. Necesitamos invertir cada cadena |%{,($_+-join$_[($z=25..0)])*2}y agregarlas juntas para que podamos obtener la parte superior del bloque. Esto se hace con el -joincomando y la indexación hacia atrás 25..0. Además, encapsulamos las cadenas en una matriz ,(...)y las duplicamos *2para obtener toda la parte superior. Pruébalo en línea!

Todo eso se almacena $xy encapsula en parens, por lo que coloca las cadenas en la tubería. Finalmente, retrocedemos $x(asegurándonos de cortar la fila del medio duplicado-duplicado, de lo contrario tendríamos cuatro ..en el medio) y los dejamos en la tubería. Un implícito Write-Outputpega una nueva línea entre las cadenas, por lo que lo obtenemos de forma gratuita.

— AdmBorkBork
fuente

Salida de una bonita caja

Pyke, 20 17 bytes

J , 25 bytes

Explicación

C, 115 bytes

C, 535 478 477 Bytes

Haskell, 72 bytes

Apilado, no competitivo, 35 bytes

JavaScript (ES6), 117 bytes

C, 97 bytes

Jalea , 18 bytes

05AB1E , 39 35 33 bytes

MATL , 21 bytes

Ruby, 77 bytes

Carbón de leña , 25 bytes

Python 3 , 89 bytes

Octava, 53 bytes

Bash, 191 bytes

C #, 203 bytes

05AB1E , 33 bytes

PowerShell , 171 151 bytes

Explicación: