17

La tua sfida è quella di produrre esattamente il seguente riquadro:

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

La scatola è in altezza e larghezza 50, gli spazi sono due larghi.

È necessario scrivere una funzione o un programma che genera o restituisce una stringa e non accetta input.

Vince il minor numero di byte!

code-golf ascii-art kolmogorov-complexity

— Pavel
fonte

4

Qual è il motivo per cui la +scatola più interna ha solo 1 strato in alto e in basso? Ciò renderà le risposte basate su algoritmo un po 'più lunghe, poiché significa che i due livelli più interni non sono esattamente quadrati.

— ETHproductions

@Pavel OK. Ritiro ravvicinato ritirato :)

— Trauma digitale

4

Perché la restrizione su un programma completo?

— Rɪᴋᴇʀ

1

@Pavel perché? Non aggiunge nulla alla sfida.

— Rɪᴋᴇʀ

1

@Pavel ..... no. Voglio dire, sì, alcuni lo hanno, ma non è di gran lunga un requisito / standard per le sfide KG.

— Rɪᴋᴇʀ

10

Pyke, 20 17 byte

k25V". + "ohe@A.X

Provalo qui!

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

La funzione surround è stata creata per domande di complessità kolmogorov come questa!

— Blu
fonte

14

J , 25 byte

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

Provalo online!

Spiegazione

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
fonte

Penso che tu possa lasciare l'eco.

— Conor O'Brien,

@ ConorO'Brien Oh, la regola di output è cambiata. ... Hmm, ma se lo rimuovo echo, non sarà nemmeno una funzione, solo un valore. Sebbene J non abbia comunque funzioni a argomento zero.

— Zgarb,

Penso che sia permesso secondo la natura sostitutiva di J. In ogni caso, le funzioni costanti possono essere considerate come argomento zero.

— Conor O'Brien,

11

C, 115 byte

#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);}

Definisce una funzione f(chiama come f();) che stampa la stringa su STDOUT.

— Lynn
fonte

9

C, 535 478 477 byte

Ora c'è molto 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);}

Ecco l'output;

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

— cleblanc
fonte

2

Merda. Ammiro la tua dedizione.

— Rɪᴋᴇʀ

Ho modificato la restrizione, ora sono consentite funzioni che restituiscono una stringa.

— Pavel,

Mi sono appena reso conto che posso giocare a golf a pochi byte riscrivendo i loop for(;i++<51;e ora me ne vado da uno ovunque: - /

— Cleblanc

@cleblanc++i

— dkudriavtsev

MFW Ho iniziato a cercare di capirlo: i.imgur.com/TLV9gJ4.png +1

— Magic Octopus Urn

6

Haskell, 72 byte

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

@ La soluzione di Zgarb a Haskell. Ho anche provato a costruire la scatola aggiungendo strati attorno al core ["..",".."], ma è più lunga di 9 byte (81 byte).

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

— Nome del modello
fonte

5

Impilato, non competitivo, 35 byte

Provalo qui!

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

Ungolfed:

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

Abbastanza semplice. surroundè una funzione che circonda un'entità con un'entità di riempimento. Ad esempio, lo (0) 1 surroundè ((1 1 1) (1 0 1) (1 1 1)). $surroundè surrounduna funzione, non valutata. foldprende un valore iniziale, quindi qualcosa da ripiegare, quindi una funzione. In questo caso, surroundè folded, che circonda la stringa inizialmente vuota ''(equivalente ε) con ogni carattere della stringa.

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

Si tratta innanzitutto di creare una stringa di caratteri $' + .'che, quando moltiplicata per un numero, ripete ogni carattere. Questo ci lascia con: ++ ... Questo viene quindi lanciato su una stringa. Quindi, ripetiamo questa stringa tre volte e infine anteponiamo a ., dandoci la stringa desiderata.

Un approccio diverso per 39 byte:

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

#\è insert e accetta il carattere iniziale della stringa come valore iniziale. Funziona anche solo su array.

— Conor O'Brien
fonte

Com'è difficile, la sfida è stata sollevata solo poche ore fa.

— Pavel

@Pavel Ci lavoro sempre su questo

— Conor O'Brien il

4

JavaScript (ES6), 117 byte

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())

Espandi frammento

La soluzione non ricorsiva mi ha portato 128 byte:

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`)

Dove \nrappresenta il carattere letterale di newline.

— Neil
fonte

4

C, 97 byte

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
fonte

3

Gelatina , 18 byte

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

Provalo online!

Lo stesso approccio della risposta J di Zgarb: 12ŒRAè abs([-12 … 12]), x2ripete ogni elemento due volte, »þ`crea una tabella dei massimi, ị“ + .”indicizza ciclicamente in una stringa e si Yunisce con nuove righe.

— Lynn
fonte

3

05AB1E , 39 35 33 byte

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

Provalo online!

•â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.

33 Versione di byte che ora è più interessante perché Emigna ha commentato salvandomi 2 byte:

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

Provalo online!

— Urna di polpo magico
fonte

1

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

— Emigna,

… .+•â3fM~•3BSè.pvy¤25yg-×«Â«})Â«»per 34 byte sulla "versione più fredda".

— Emigna,

Cool non è stata la scelta corretta della parola haha. "Meno ghetto", forse?

— Magic Octopus Urn

Adoro il tuo uso del comando prefisso. Brillante!

— Emigna,

1

@Emigna i prefissi formano un triangolo, se trasponi il triangolo e lo ruoti, quindi combinalo con i prefissi originali potresti essere in grado di radere i byte. Quello era il piano principale a cui non riuscivo.

— Magic Octopus Urn

2

MATL , 21 byte

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

Provalo online!

'. + '    % 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
fonte

2

Rubino, 77 byte

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

— Level River St
fonte

Penso che puoi sostituire l'espressione dell'indice con [i%26-13,i/52].map(&:abs).max%4(salva un byte)

— Conor O'Brien,

2

Carbone , 25 byte

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

Provalo online! Il collegamento contiene la modalità dettagliata per la spiegazione

— ASCII-only
fonte

2

Python 3 , 89 byte

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

Provalo online!

— Perdente Suora
fonte

1

Haskell, 385 byte

    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

Il primo round di code golf qui ... non vedo l'ora di vedere come gli altri affrontano questo.

Produzione:

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

— Brander
fonte

3

1) Hai tonnellate di spazi bianchi non necessari. 2) mettere tutte le definizioni delle funzioni all'interno di wherein un'unica riga e utilizzare ;per la separazione. 3) f:f:[]è f:[f] and d: '': '': [] `è d:" ". 4) maccetta un parametro ma non lo utilizza. In linea me t. 5) definire una nuova funzione #da sostituire replicate: c#x=c<$[1..8*n+x]e chiamarla come d#2e ' '#(-6). 6) mod 2 == 0può essere sostituito con even, o capovolgere la prova e l'uso odde il giocatore di otherwise: 1<2. ...

— nimi,

2

... tutto sommato:

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

Ottava, 53 byte

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

Genera pattern ripetuti da 1 a 8 dal centro verso l'esterno e usalo come indice per l'estrazione di elementi di . ++ .

Provalo online!

— rahnema1
fonte

1

Bash, 191 byte

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

Probabilmente può ridursi, ma era più piccolo dei miei tentativi algoritmici.

— throx
fonte

1

C #, 203 byte

Programma completo e leggibile:

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();
    }
}

Funzione golfizzata :

()=>{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
fonte

1

05AB1E , 33 byte

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

Provalo online!

Spiegazione

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
fonte

Spiegazione a venire?

— Pavel,

@Pavel: certo! :)

— Emigna,

1

PowerShell , 171 151 byte

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

Provalo online!

Ho-hum risposta. Sono sicuro che c'è un modo più breve (date le lunghezze delle altre risposte, sono fiducioso), ma questo mostra alcuni trucchi accurati.

Spiegazione:

1..12|%{' . +'[$_%4]} genera una matrice di stringhe (di un carattere di lunghezza), nel modello corretto di cui abbiamo bisogno. Provalo online!

Aggiungiamo quindi |%{($a+=$_+$_)})+"$a."quale prende l'array e lo espande lateralmente in base alla riga precedente. Provalo online!

Queste stringhe vengono poi inviati in un ciclo, |%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}. Ad ogni iterazione, scegliamo il carattere corretto (un segno più, un punto o uno spazio), quindi utilizziamo la .PadRightfunzione per riempire il numero appropriato di caratteri. Provalo online!

Ora abbiamo le fondamenta dell'angolo in alto a destra. Dobbiamo invertire ciascuna stringa |%{,($_+-join$_[($z=25..0)])*2}e aggiungerle insieme in modo da poter ottenere la cima del blocco. Questo viene fatto con il -joincomando e l'indicizzazione all'indietro 25..0. Inoltre, incapsuliamo le stringhe in un array ,(...)e le facciamo raddoppiare in *2modo da ottenere il massimo. Provalo online!

Tutto questo viene archiviato $xe incapsulato in parentesi in modo da posizionare le stringhe sulla tubazione. Alla fine, facciamo retromarcia $x(assicurandoci di eliminare la riga centrale duplicata-duplicata, altrimenti ne avremmo quattro ..nel mezzo) e lasciamo quelli in cantiere. Un implicito Write-Outputinserisce una nuova riga tra le stringhe, quindi la otteniamo gratuitamente.

— AdmBorkBork
fonte

Uscita una bella scatola

Pyke, 20 17 byte

J , 25 byte

Spiegazione

C, 115 byte

C, 535 478 477 byte

Haskell, 72 byte

Impilato, non competitivo, 35 byte

JavaScript (ES6), 117 byte

C, 97 byte

Gelatina , 18 byte

05AB1E , 39 35 33 byte

MATL , 21 byte

Rubino, 77 byte

Carbone , 25 byte

Python 3 , 89 byte

Ottava, 53 byte

Bash, 191 byte

C #, 203 byte

05AB1E , 33 byte

PowerShell , 171 151 byte

Spiegazione: