17

Votre défi consiste à afficher exactement la case suivante:

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

La boîte est de hauteur et largeur 50, les espaces sont larges de deux.

Vous devez écrire une fonction ou un programme qui génère ou renvoie une chaîne et ne prend aucune entrée.

Le moins d'octets gagne!

code-golf ascii-art kolmogorov-complexity

— Pavel
source

4

Une raison pour laquelle la +boîte la plus intérieure n'a qu'une seule couche en haut et en bas? Cela rendra les réponses basées sur des algorithmes un peu plus longues, car cela signifie que les deux couches les plus internes ne sont pas exactement carrées.

— ETHproductions

@ Pavel OK. Fermer le vote rétracté :)

— Digital Trauma

4

Pourquoi la restriction sur un programme complet?

— Rɪᴋᴇʀ

1

@Pavel pourquoi? Cela n'ajoute vraiment rien au défi.

— Rɪᴋᴇʀ

1

@ Pavel ..... non. Je veux dire, oui, certains l'ont, mais ce n'est pas de loin une exigence / norme pour les défis KG.

— Rɪᴋᴇʀ

10

Pyke, 20 17 octets

k25V". + "ohe@A.X

Essayez-le ici!

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

La fonction surround a été conçue pour des questions de complexité kolmogorov comme celle-ci!

— Bleu
source

14

J , 25 octets

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

Essayez-le en ligne!

Explication

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
source

Je pense que vous pouvez laisser l'écho.

— Conor O'Brien

@ ConorO'Brien Oh, la règle de sortie a changé. ... Hmm, mais si je supprime echo, ce ne sera même pas une fonction, juste une valeur. Bien que J n'ait de toute façon aucune fonction à zéro argument.

— Zgarb

Je pense que cela est autorisé selon la nature de la réponse de J. Dans tous les cas, les fonctions constantes peuvent être considérées comme des arguments zéro.

— Conor O'Brien

11

C, 115 octets

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

Définit une fonction f(appelez comme f();) qui imprime la chaîne dans STDOUT.

— Lynn
source

9

C, 535 478 477 octets

Maintenant ça fait beaucoup de 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);}

Voici la sortie;

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

— cleblanc
source

2

Putain de merde. J'admire votre dévouement.

— Rɪᴋᴇʀ

J'ai changé la restriction, les fonctions qui retournent une chaîne sont maintenant autorisées.

— Pavel

Je viens de réaliser que je peux jouer au golf quelques octets en for(;i++<51;

— réécrivant

@cleblanc++i

— dkudriavtsev

MFW J'ai commencé à essayer de comprendre ceci: i.imgur.com/TLV9gJ4.png +1

— Urne Magic Octopus

6

Haskell, 72 octets

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

@ Solution de Zgarb à Haskell. J'ai également essayé de construire la boîte en ajoutant des couches autour du noyau ["..",".."], mais c'est 9 octets de plus (81 octets).

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

— nimi
source

5

Empilé, non compressif, 35 octets

Essayez-le ici!

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

Non golfé:

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

Assez facile. surroundest une fonction qui entoure bien une entité avec une entité de remplissage. Par exemple, (0) 1 surroundest ((1 1 1) (1 0 1) (1 1 1)). $surroundest surrounden fonction, non évalué. foldprend une valeur initiale, puis quelque chose à replier, puis une fonction. Dans ce cas, surroundest folded, entourant la chaîne initialement vide ''(équiv. ε) De chaque caractère de la chaîne.

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

Il s'agit d'abord de créer une chaîne de caractères $' + .'qui, multipliée par un nombre, répète chaque caractère. Cela nous laisse avec: ++ ... Ceci est ensuite converti en chaîne. Ensuite, nous répétons cette chaîne trois fois, et finalement ajoutons un ., en nous donnant la chaîne souhaitée.

Une approche différente pour 39 octets:

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

#\est insert et prend le caractère initial de la chaîne comme valeur de départ. Il ne fonctionne également que sur les tableaux.

— Conor O'Brien
source

Comment est-ce non compétitif, le défi a été relevé il y a seulement quelques heures.

— Pavel

@ Pavel, je travaille toujours là-dessus

— Conor O'Brien

4

JavaScript (ES6), 117 octets

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

Développer l'extrait

La solution non récursive m'a pris 128 octets:

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

Où \nreprésente le caractère de nouvelle ligne littéral.

— Neil
source

4

C, 97 octets

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
source

3

Gelée , 18 octets

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

Essayez-le en ligne!

Cette même approche que la réponse J de Zgarb: 12ŒRAest abs([-12 … 12]), x2répète tous les éléments deux fois, »þ`crée une table de valeurs maximales, ị“ + .”cyclique des index dans une chaîne, et Yrejoint par de nouvelles lignes.

— Lynn
source

3

05AB1E , 39 35 33 octets

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

Essayez-le en ligne!

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

Version 33 octets qui est plus cool maintenant car Emigna a commenté me sauver 2 octets:

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

Essayez-le en ligne!

— Urne de poulpe magique
source

1

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

— Emigna

… .+•â3fM~•3BSè.pvy¤25yg-×«Â«})Â«»pour 34 octets sur la "version plus froide".

— Emigna

Cool n'était pas le bon choix de mot haha. "Moins Ghetto", peut-être?

— Magic Octopus Urn

J'adore votre utilisation de la commande prefix. Brillant!

— Emigna

1

@Emigna les préfixes forment un triangle, si vous transposez le triangle et le faites pivoter, puis combinez-le avec les préfixes d'origine, vous pourrez peut-être raser les octets. C'était le plan principal auquel je n'ai pas pu arriver.

— Magic Octopus Urn

2

MATL , 21 octets

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

Essayez-le en ligne!

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

2

Rubis, 77 octets

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

— Level River St
source

Je pense que vous pouvez remplacer l'expression d'index par [i%26-13,i/52].map(&:abs).max%4(enregistre un octet)

— Conor O'Brien

2

Fusain , 25 octets

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

Essayez-le en ligne! Le lien contient un mode détaillé pour l'explication

— ASCII uniquement
source

2

Python 3 , 89 octets

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

Essayez-le en ligne!

— Leaky Nun
source

1

Haskell, 385 octets

    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

Première ronde de golf à code ici ... impatient de voir comment les autres s'y attaqueront.

Production:

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

— brander
source

3

1) Vous avez des tonnes d'espaces blancs inutiles. 2) mettre toutes les définitions de fonctions dans le wheredans une seule ligne et les utiliser ;pour la séparation. 3) f:f:[]est f:[f] and d: '': '': [] `est d:" ". 4) mprend un paramètre mais ne l'utilise pas. En ligne met t. 5) définir une nouvelle fonction #à remplacer replicate: c#x=c<$[1..8*n+x]et l'appeler comme d#2et ' '#(-6). 6) mod 2 == 0peut être remplacé par even, ou retourner le test et l' utilisation oddet de le golfeur otherwise: 1<2. ...

— nimi

2

... dans l' ensemble:

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

Octave, 53 octets

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

Générez un motif répétitif de 1 à 8 du centre vers l'extérieur et utilisez-le comme index pour l'extraction des éléments de . ++ .

Essayez-le en ligne!

— rahnema1
source

1

Bash, 191 octets

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

Peut probablement devenir plus petit, mais était plus petit que mes tentatives algorithmiques.

— throx
source

1

C #, 203 octets

Programme complet et lisible:

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

Fonction 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
source

1

05AB1E , 33 octets

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

Essayez-le en ligne!

Explication

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
source

Explication à venir?

— Pavel

@ Pavel: bien sûr! :)

— Emigna

1

PowerShell , 171 151 octets

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

Essayez-le en ligne!

Ho-hum réponse. Je suis sûr qu'il existe un moyen plus court (compte tenu de la longueur des autres réponses, je suis confiant), mais cela montre quelques astuces intéressantes.

Explication:

1..12|%{' . +'[$_%4]}génère un tableau de chaînes (d'un caractère), dans le modèle correct dont nous avons besoin. Essayez-le en ligne!

Nous ajoutons ensuite celui |%{($a+=$_+$_)})+"$a."qui prend le tableau et le développe latéralement en fonction de la ligne précédente. Essayez-le en ligne!

Ces chaînes sont ensuite envoyées dans une boucle, |%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}. À chaque itération, nous choisissons le bon caractère (soit un plus, un point ou un espace), puis nous utilisons la .PadRightfonction pour remplir le nombre approprié de caractères. Essayez-le en ligne!

Maintenant, nous avons la fondation du coin supérieur droit. Nous devons inverser chaque chaîne |%{,($_+-join$_[($z=25..0)])*2}et les ajouter ensemble afin de pouvoir obtenir le haut du bloc. Cela se fait avec la -joincommande et l'indexation en arrière 25..0. De plus, nous encapsulons les chaînes dans un tableau ,(...)et les faisons doubler *2pour obtenir tout le haut. Essayez-le en ligne!

Tout cela est stocké dans $xet encapsulé dans des parens, de sorte qu'il place les chaînes sur le pipeline. Enfin, nous inversons $x(en étant sûr de couper la ligne du milieu duplicate-duplicate, sinon nous en aurions quatre ..au milieu) et de les laisser sur le pipeline. Un implicite Write-Outputcolle une nouvelle ligne entre les chaînes, donc nous l'obtenons gratuitement.

— AdmBorkBork
source

Sortie d'une jolie boîte

Pyke, 20 17 octets

J , 25 octets

Explication

C, 115 octets

C, 535 478 477 octets

Haskell, 72 octets

Empilé, non compressif, 35 octets

JavaScript (ES6), 117 octets

C, 97 octets

Gelée , 18 octets

05AB1E , 39 35 33 octets

MATL , 21 octets

Rubis, 77 octets

Fusain , 25 octets

Python 3 , 89 octets

Octave, 53 octets

Bash, 191 octets

C #, 203 octets

05AB1E , 33 octets

PowerShell , 171 151 octets

Explication: