Pour ce défi, une courtepointe art ASCII sera un bloc de texte de 24 caractères de large et 18 lignes de haut, contenant les caractères =-<>/\dans un motif semblable à une courtepointe qui est horizontalement et verticalement symétrique.

Exemple de courtepointe:

========================
------------------------
//\\//\\\//\/\\///\\//\\
<<><<>>>>><<>><<<<<>><>>
/\\/\\\\/\/\/\/\////\//\
------------------------
/\/////\\///\\\//\\\\\/\
\///\/\/\\\\////\/\/\\\/
\///\/\/\\\\////\/\/\\\/
/\\\/\/\////\\\\/\/\///\
/\\\/\/\////\\\\/\/\///\
\/\\\\\//\\\///\\/////\/
------------------------
\//\////\/\/\/\/\\\\/\\/
<<><<>>>>><<>><<<<<>><>>
\\//\\///\\/\//\\\//\\//
------------------------
========================

Toutes les courtepointes ont la même forme:

• Ils sont toujours 24 par 18.
• La ligne du haut (ligne 1) et la ligne du bas (ligne 18) sont =tout au long.
• Les lignes 2, 6, 13 et 17 sont -tout le chemin à travers.
• Les lignes 4 et 15 sont le même motif aléatoire symétrique horizontalement de <et >.
• Toutes les autres lignes (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) sont remplies /et \d'une manière complètement aléatoire de telle sorte que la courtepointe entière reste horizontalement et verticalement symétrique .

Notez que lorsque vous pliez la courtepointe exactement en deux, verticalement ou horizontalement, les formes des caractères correspondent exactement. Ne confondez pas cela avec les personnages eux-mêmes qui correspondent. par exemple, la ligne 3 et la ligne 16 ne sont pas identiques, ce sont des images miroir verticales.

Défi

Écrivez un programme ou une fonction qui imprimera ou retournera une courtepointe art ASCII aléatoire.

En raison des nombreuses lignes codées en dur et de la symétrie, le seul véritable caractère aléatoire provient des 12 premiers caractères des lignes 3, 4, 5, 7, 8, 9:

• Les 12 premiers caractères de la ligne 4 doivent pouvoir être n'importe quelle chaîne de longueur 12 des caractères <et >.
• Les 12 premiers caractères des lignes 3, 5, 7, 8, 9 doivent pouvoir être n'importe quelle chaîne de 12 caractères /et \(indépendamment les uns des autres).
• Ces chaînes aléatoires sont ensuite reflétées en conséquence pour créer l'intégralité de la courtepointe.

La réponse la plus courte en octets l'emporte. Tiebreaker est un post antérieur.

Vous pouvez utiliser des générateurs de nombres pseudo-aléatoires. (Non, vous n'avez pas besoin de prouver que les 12 caractères de <>ou /\peuvent être générés avec le PRNG de votre langue.)

La sortie peut éventuellement contenir une nouvelle ligne de fin, mais pas d'espaces de fin ni d'autres caractères en plus de ce qui est nécessaire pour la courtepointe.

CJam, 61 60 58 55 54 52 51 octets

Raccourci un peu avec l'aide de Sp3000 et Optimizer.

"=-/</-///"{C*1{"<\/>"%1$W%\_W%er}:F~+mrC<1FN}%s3F(

Testez-le ici.

Explication

Comme d'habitude avec ces défis d'art ASCII symétriques, je génère un quadrant, puis je l'étends au maximum par deux opérations de mise en miroir appropriées.

Pour cette explication, je devrais commencer par la fonction F, que je définis quelque part en cours de route, car elle est utilisée à trois endroits pour trois choses différentes:

{"<\/>"%1$W%\_W%er}:F

Cela attend un entier en haut de la pile et une chaîne en dessous. Son but est d'inverser la chaîne et également d'échanger certains caractères, pour obtenir la bonne mise en miroir. L'entier est soit 1ou 3et indique si ( 1) les crochets et les barres obliques doivent être échangés ou ( 3) seuls les crochets doivent être échangés. Voici comment cela fonctionne:

"<\/>"            "Push a string with all four relevant characters.";
      %           "% applied to a string and an integer N (in any order) selects every
                   Nth character, starting from the first. So with N = 1 this just
                   leaves the string unchanged, but with N = 3 it returns a string
                   containing only < and >.";
       1$         "Copy the string we want to mirror.";
         W%       "% also takes negative arguments. Giving it -1 reverses the string.";
           \_     "Swap the two strings and duplicate the <\/> or <> string.";
             W%   "Reverse that one. Due to the symmetry of this string, we'll now
                   have the characters to be swapped at corresponding indices.";
               er "Perform element-wise transliteration on the reversed input string
                   to complete the mirroring operation.";

Maintenant, pour le reste du code:

"=-/</-///"                            "This string encodes the 9 different line types.
                                        Note that for the /\ and <> lines we only use
                                        one of the characters. This idea is due to
                                        Sp3000. Thanks! :)";
           {                   }%      "Map this block onto the characters.";
            C*                         "Repeat the character 12 times, turning it into
                                        a string.";
              1{...}:F~                "Define and call F on the resulting string. The
                                        reversal doesn't do anything, but the character
                                        swapping creates strings containing both \/ and
                                        <>.";
                       +mr             "Add the two halves together and shuffle them.";
                          C<           "Truncate to 12 characters. We've now got our
                                        random half-lines.";
                            1F         "Call F again to mirror the half-line.";
                              N        "Push a newline.";
                                 s     "Join all those separate strings together by
                                        converting the array to a string.";
                                  3F   "Perform one more mirroring operation on the
                                        half-quilt, but this time only swap < and >.
                                        This yields the correct full quilt, except
                                        there are two newlines in the centre.";
                                    (  "This slices the leading newline off the second
                                        half and pushes it onto the stack.";

Les deux moitiés et cette seule nouvelle ligne sont ensuite imprimées automatiquement à la fin du programme.

Python 3, 257 229 192 185 185 176 149 143 octets

from random import*
k,*L=80703,
while k:s=eval("''"+".join(sample('--==<>\/'[k%4*2:][:2],2))"*12);L=[s]+L+[s[::(-1)**k]];k//=4
*_,=map(print,L)

Avec l'aide de @xnor, nous avons enfin rattrapé JS!

Exemple de sortie:

========================
------------------------
///////////\/\\\\\\\\\\\
>><<<>><<<><><>>><<>>><<
/\/\\/\/\\/\/\//\/\//\/\
------------------------
//\\////\\/\/\//\\\\//\\
/////\\\/\/\/\/\///\\\\\
/\\//\\/////\\\\\//\\//\
\//\\//\\\\\/////\\//\\/
\\\\\///\/\/\/\/\\\/////
\\//\\\\//\/\/\\////\\//
------------------------
\/\//\/\//\/\/\\/\/\\/\/
>><<<>><<<><><>>><<>>><<
\\\\\\\\\\\/\///////////
------------------------
========================

Explication

(Légèrement obsolète, sera mis à jour plus tard)

"444046402"code les lignes, chaque chiffre faisant référence à l'index de départ de la sous-chaîne de 2 caractères appropriée de '--==\/<>'. Chaque ligne individuelle est construite à l'envers via le brassage répété des deux caractères (en utilisant sample(...,2), car il random.shuffleest malheureusement en place) et la jonction de chaînes.

Un exemple simplifié de ce à quoi pourrait ressembler l'extension pour la quatrième ligne:

''.join(['<','>']).join(['>','<']).join(['>','<']).join(['<','>']).join(['>','<'])

ce qui donnerait ><>><><<><:

               ''
    <>         .join(['<','>'])
   >  <        .join(['>','<'])
  >    <       .join(['>','<'])
 <      >      .join(['<','>'])
>        <     .join(['>','<'])

La courtepointe globale est également construite à l'envers, car la construction commence avec les 9ème / 10ème rangées, en travaillant vers l'extérieur. Pour ce faire, nous commençons par une liste vide L, que nous ajoutons des lignes au recto et au verso au fur et à mesure

L=[s]+L+[[s,s[::-1]][n<"5"]]

La n<"5"condition est de vérifier si nous avons une ligne composée ><, auquel cas nous ajoutons une ligne identique à l'arrière, sinon son inverse.

Enfin, *_,=est de forcer l'évaluation de mapsorte que l'impression se produise, et c'est juste un moyen plus court de le faire print("\n".join(L)).

Pendant longtemps j'ai eu la fonction

g=lambda s:s.translate({60:62,62:60,92:47,47:92})

qui prend une chaîne et convertit /\><en \/<>respectivement, mais j'ai finalement réussi à m'en débarrasser :)

Python 2, 300 octets

Ce programme utilise join, lambda, replace, sample, importet d'autres fonctions détaillées, il ne gagnera donc pas de prix de golf.

from random import*
f=lambda a,b,t:t.replace(a,'*').replace(b,a).replace('*',b)
k=lambda a:''.join(sample(a*12,12))
c='-'*24
e=k('<>')
h=e+f('<','>',e[::-1])
j=[d+f('/','\\',d[::-1])for d in[k('\\/')for i in'quilt']]
g=['='*24,c,j[0],h,j[1],c]+j[2:]
print'\n'.join(g+[f('/','\\',d)for d in g[::-1]])

Le code avant que le golfeur automatique ne s'en empare:

from random import *

change = lambda a,b,t: t.replace(a,'*').replace(b,a).replace('*',b)
pick = lambda a: ''.join(sample(a*12, 12))

innerline = '-' * 24
line4h = pick('<>')
line4 = line4h + change('<', '>', line4h[::-1])
diag = [d + change('/', '\\', d[::-1]) for d in [pick('\\/') for i in 'quilt']]

quilt = ['='*24, innerline, diag[0], line4, diag[1], innerline] + diag[2:]
print '\n'.join(quilt + [change('/', '\\', d) for d in quilt[::-1]])

Un exemple de sortie:

========================
------------------------
\\\\/\////\\//\\\\/\////
<><<>>>><><><><><<<<>><>
/\\\\////\\\///\\\\////\
------------------------
\\\\//\///\\//\\\/\\////
//\//\\\\/\/\/\////\\/\\
\/\\\\/\//\/\/\\/\////\/
/\////\/\\/\/\//\/\\\\/\
\\/\\////\/\/\/\\\\//\//
////\\/\\\//\\///\//\\\\
------------------------
\////\\\\///\\\////\\\\/
<><<>>>><><><><><<<<>><>
////\/\\\\//\\////\/\\\\
------------------------
========================

APL ( 53 58)

Ce n'est pas tout à fait aussi symétrique que je pensais qu'il était, malheureusement. La correction m'a coûté 5 caractères et maintenant je suis hors course.

L←+,3-⌽⋄'==--/\<><'[↑(732451451260688⊤⍨18/8)+L{L?12⍴2}¨⍳9]

Explication:

• L←+,3-⌽: L est une fonction qui retourne son argument suivi de 3 - l'inverse de son argument
• L{L?12⍴2}¨⍳9: générer 9 lignes de 12 valeurs aléatoires à partir de [1,2] plus leur inverse, puis l'inverse de ces 9 lignes
• 732451451260688⊤⍨18/8: générer la liste 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(c'est là que se trouve la fichue asymétrie)
• +: pour chaque ligne, ajoutez le nombre correspondant à chaque valeur
• ↑: format comme matrice
• '==--/\<><'[... ]: pour chacun des nombres de la matrice, sélectionnez le caractère de la chaîne à cette position

Sortie:

========================
------------------------
///////\\///\\\//\\\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\//\/\\\///\/\\/////
------------------------
/\///\\/\/\/\/\/\//\\\/\
\////////\//\\/\\\\\\\\/
\\/\\\//\///\\\/\\///\//
//\///\\/\\\///\//\\\/\\
/\\\\\\\\/\\//\////////\
\/\\\//\/\/\/\/\/\\///\/
------------------------
/////\\/\///\\\/\//\\\\\
<<><<><><<<<>>>><><>><>>
\\\\\\\//\\\///\\///////
------------------------
========================

PHP, 408 , 407 , 402 , 387 , 379 octets

Je ne suis pas un bon golfeur, mais ce problème semblait amusant, donc je l'ai essayé.

<?$a=str_replace;$b=str_repeat;function a($l,$a,$b){while(strlen($s)<$l){$s.=rand(0,1)?$a:$b;}return$s;}$c=[$b('=',12),$b('-',12),a(12,'/','\\'),a(12,'<','>'),a(12,'/','\\'),$b('-',12)];while(count($c)<9){$c[]=a(12,'/','\\');}for($d=9;$d--;){$c[$d].=strrev($a(['/','<','\\','>',1,2],[1,2,'/','<','\\','>'],$c[$d]));$c[]=$a(['/','\\',1],[1,'/','\\'],$c[$d]);}echo implode("
",$c);

Code non golfé

<?php

    function randomString($length, $a, $b) {
        $string = '';
        while(strlen($string) < $length) {
            $string .= rand(0, 1) ? $a : $b;
        }
        return $string;
    }

    if(isset($argv[1])) {
        srand(intval($argv[1]));
    }

    $lines = [
        str_repeat('=', 12),
        str_repeat('-', 12),
        randomString(12, '/', '\\'),
        randomString(12, '<', '>'),
        randomString(12, '/', '\\'),
        str_repeat('-', 12)
    ];
    while(count($lines) < 9) {
        $lines[] = randomString(12, '/', '\\');
    }

    for($index = count($lines); $index--;) {
        $lines[$index] .= strrev(str_replace(['/', '<', '\\', '>', 1, 2], [1, 2, '/', '<', '\\', '>'], $lines[$index]));
        $lines[] = str_replace(['/', '\\', 1], [1, '/', '\\'], $lines[$index]);
    }

    echo implode("\n", $lines) . "\n";

?>

La version non golfée a un petit bonus: vous pouvez lui passer un entier à la graine rand()et obtenir la même courtepointe à chaque fois pour une graine:

php quilt.php 48937

Cela se traduit, par exemple, par cette belle couette tissée à la main:

========================
------------------------
/\\\////\\\/\///\\\\///\
><>><>><<<><><>>><<><<><
/\\\///\//\/\/\\/\\\///\
------------------------
/\\/\\\/\\/\/\//\///\//\
/\\\\/\//\\/\//\\/\////\
\/\\/\/\////\\\\/\/\//\/
/\//\/\/\\\\////\/\/\\/\
\////\/\\//\/\\//\/\\\\/
\//\///\//\/\/\\/\\\/\\/
------------------------
\///\\\/\\/\/\//\///\\\/
><>><>><<<><><>>><<><<><
\///\\\\///\/\\\////\\\/
------------------------
========================

Edit : Il s'avère que ma première version n'a pas renvoyé une courtepointe correcte. Je l'ai donc corrigé. Assez drôle, la correction est encore plus courte.

JavaScript (ES6) 169 195 201

Modifier 6 octets enregistrés thx @nderscore. Attention, la nouvelle ligne à l'intérieur des guillemets est importante et comptée.

Édition de ligne simplifiée Edit2 , pas besoin de reverseetconcat

F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

Exécutez l'extrait de code pour tester (dans Firefox)

F=(o='')=>[...z='/\\/-/<\\-='].map((c,i,_,y=[z,'\\/\\-\\>/-='],q=[for(_ of-z+z)Math.random(Q=k=>q.map(v=>r=y[v^!k][i]+r+y[v^k][i],r='')&&r+`
`)*2])=>o=Q()+o+Q(i!=5))&&o

Q.innerHTML=F()

<pre id=Q style='font-size:9px;line-height:9px'>

Ruby, 162 155

J'aime celui-ci car il m'a fait apprendre à abuser des barres obliques inverses dans les littéraux de chaîne et String#tr. Le code n'est pas terriblement intelligent autrement, juste compact.

a='/\\'
b='\\\/'
t=Array.new(9){x=''
12.times{x+=a[rand(2)]}
x+x.reverse.tr(a,b)}
t[0]=?=*24
t[1]=t[5]=?-*24
t[3].tr!a,'<>'
puts t,((t.reverse*'
').tr a,b)

Pyth, 57 59 61

J"\<>/"K"\/"L+b_mXdK_Kbjbym+d_XdJ_JmsmOk12[\=\-K-JKK\-KKK

J"\<>/"K"\/"jbu++HGXHK_Km+d_XdJ_JmsmOk12[KKK\-K-JKK\-\=)Y

Merci beaucoup à @Jakube d'avoir proposé ces versions de 57 octets.

Algorithme très similaire à celui de Martin. (Révisé) Explication à venir.

Essayez-le en ligne

Explication:

=G"\<>/"                            : Set G to be the string "\<>/"
K"\/"                               : Set K to be the string "\/"
Jm+d_XdG_GmsmOk12[\=\-K"<>"K\-KKK;  : Set J to be the top half of the carpet
                 [\=\-K"<>"K\-KKK;  : Make a list of possible chars for each row
          msmOk12                   : for each element of that list,
                                    : make a list of 12 randomly chosen characters
                                    : from it, then join them
Jm+d_XdG_G                          : for each element of that list,
                                    : make a new list with the old element,
                                    : and its horizontal reflection
jb+J_mXdK_KJ                        : Print the whole carpet
     mXdK_KJ                        : For each element of J make its vertical reflection

J, 56 54 octets

'=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2

Usage:

   '=/\<>--></\'{~(-,|.)0,(3(2})8$5,3#1)+(,1-|.)"1?8 12$2
========================
------------------------
///\\\\/\///\\\/\////\\\
><<><><>><>><<><<><><>><
\\/\//\\/\//\\/\//\\/\//
------------------------
\/\/\//////\/\\\\\\/\/\/
/\/\\//\//\\//\\/\\//\/\
//\\\\/////\/\\\\\////\\
\\////\\\\\/\/////\\\\//
\/\//\\/\\//\\//\//\\/\/
/\/\/\\\\\\/\//////\/\/\
------------------------
//\/\\//\/\\//\/\\//\/\\
><<><><>><>><<><<><><>><
\\\////\/\\\///\/\\\\///
------------------------
========================

1 octet grâce à @FUZxxl.

Explication à venir.

Essayez-le en ligne ici.

Python 295 287 227 octets

Pas génial mais je le posterai quand même:

from random import*
m,d=[],dict(zip("\/<>=-","/\><=-"))
v=lambda w:[d[x]for x in w]
for e in '=-/>/-///':f=[choice([e,d[e]])for x in[0]*12];t=''.join(f+v(f[::-1]));print t;m+=''.join(e=='/'and v(t)or t),
print'\n'.join(m[::-1])

Si vous voulez une explication, demandez-moi.

Javascript ( ES7 projet ) 174 168 146

Inspiration tirée de @ edc65

Edit: Merci à edc65 pour quelques idées pour optimiser la construction des lignes.

F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

Démonstration: ( Firefox uniquement )

F=(o='')=>[for(i of'555357531')(z=[for(_ of c='==--/\\<>golf')Math.random(r=x=>z.reduce((s,y)=>c[w=i^y^x]+s+c[w^1],'')+`
`)*2],o=r()+o+r(i<7))]&&o

document.write('<pre>' + F() + '</pre>');

Commenté:

// define function, initialize output to ''
F = (o = '') =>
    // loop through character indexes of first 9 lines
    [
        for (i of '555357531')(
            // build array of 12 random 0/1's, initialize character list
            z = [
                for (_ of c = '==--/\\<>golf')
                    Math.random(
                        // define function for generating lines
                        // if x is true, opposite line is generated
                        r = x =>
                            z.reduce(
                                (s, y) => 
                                    c[w = i ^ y ^ x] + s + c[w ^ 1],
                                ''
                            ) + `\n`
                    ) * 2
            ],
            // build new lines and wrap output in them
            // x true in the second line for indexes < 7 (not character '>')
            o = r() + o + r(i < 7)
        )
    ]
    // return output
    && o

Pharo 4, 236

|s i f v h|s:='====----/\/\/<><<>'.f:=[:c|s at:(s indexOf:c)+i].v:=#(),'=-/</-///'collect:[:c|h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].i:=1.h,(h reverse collect:f)].i:=3.String cr join:v,(v reverse collect:[:k|k collect:f])

ou formaté normalement:

|s i f v h|
s:='====----/\/\/<><<>'.
f:=[:c|s at:(s indexOf:c)+i].
v:=#() , '=-/</-///'
  collect:[:c|
    h:=(String new:12)collect:[:x|i:=2atRandom.f value:c].
    i:=1.
    h,(h reverse collect:f)].
i:=3.
String cr join:v,(v reverse collect:[:k|k collect:f])

Explication:

La chaîne s:='====----/\/\/<><<>'avec le bloc f:=[:c|s at:(s indexOf:c)+i]sont ici à la fois pour lancer les caractères et pour inverser les motifs ...

• Pour i = 1, il effectue une réversion horizontale ( /<-> \, <<-> >).

• Pour i = 3, il effectue une réversion verticale ( /<-> \)

• Pour i = 1 ou 2 atRandom, il lance parmi /ou \, <ou>

'=-/</-///'code le type de caractère cqui alimentera le bloc fpour les 9 premières lignes.

#() , '=-/</-///' est une astuce de concaténation pour transformer la chaîne en tableau et ainsi collecter en tableau.

Le reste est une simple concaténation après application de la symétrie horizontale / verticale.

========================
------------------------
\\/\/\\\\/\/\/\////\/\//
>>>><><><>><><<><><><<<<
\/\/\//\///\/\\\/\\/\/\/
------------------------
/\//\/\/////\\\\\/\/\\/\
\\//\//\\\/\/\///\\/\\//
////\\/\/\//\\/\/\//\\\\
\\\\//\/\/\\//\/\/\\////
//\\/\\///\/\/\\\//\//\\
\/\\/\/\\\\\/////\/\//\/
------------------------
/\/\/\\/\\\/\///\//\/\/\
>>>><><><>><><<><><><<<<
//\/\////\/\/\/\\\\/\/\\
------------------------
========================

Squeak 4.X, 247

|r s h m n p|s:='==--/\<>'.r:=(1<<108)atRandom.h:=''.m:=0.(16to:0by:-2),(0to:16by:2)do:[:i|n:=3bitAnd:28266>>i.p:=0.(11to:0by:-1),(0to:11)do:[:j|h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).j=0and:[p:=1]].i=0and:[m:=2].h:=h,#[13]].h

Ou formaté:

|r s h m n p|
s:='==--/\<>'.
r:=(1<<108)atRandom.
h:=''.
m:=0.
(16to:0by:-2),(0to:16by:2) do:[:i|
  n:=3 bitAnd: 28266>>i.
  p:=0.
  (11to:0 by:-1),(0to:11) do:[:j|
    "h:=h,(s at:n*2+1+((r-1bitAt:6*i+j+1)bitXor:(101bitAt:3-n*4+m+p))). <- originally"
    h:=h,(s at:n*2+1+(r-1>>(6*i+j)+(101>>(3-n*4+m+p))bitAnd:1)).
    j=0and:[p:=1]].
  i=0and:[m:=2].
  h:=h,#[13]].
h

Explications:

s:='==--/\<>'. encode évidemment les quatre paires possibles.

r:=(1<<108)atRandom. lancer 108 bits (dans un LargeInteger) pour 9 lignes * 12 colonnes (nous jetons les == et - inutilement mais les performances ne sont pas notre problème).

h:=''est la chaîne où nous allons concaténer (peintre Schlemiel car un Stream serait trop coûteux en caractères).

(16to:0by:-2),(0to:16by:2)do:[:i| itère sur les lignes (* 2)

(11to:0by:-1),(0to:11) do:[:j| itère sur les colonnes

28266est un nombre magique codant la paire à utiliser sur les 9 premières lignes.
Il s'agit du modèle de bits 00 01 10 11 10 01 10 10 10, où 00 code «==», 01 «-», 10 «/ \» et 11 «<>».

101est un nombre magique codant la réversion horizontale et verticale.
C'est le motif binaire 0000 0000 0110 1010, codant quand inverser (1) ou non (0) le premier (0) ou le deuxième (1) caractère de chaque paire '==' '-' '/ \' et '<>', pour la symétrie verticale et la symétrie horizontale.

n:=3 bitAnd: 28266>>i donne le codage de la paire de caractères pour la ligne i / 2 (0 pour '==', 1 pour '-', 2 pour '/ \' et 3 pour '<>').

(r-1 bitAt: 6*i+j+1) choisissez le bit aléatoire pour la colonne i / 2 de la colonne j (1 est le rang du bit le plus bas, nous avons donc un tirage aléatoire +1, k dans l'intervalle [1, k], nous avons donc un -1).

(101 bitAt: 3-n*4+m+p) choisissez le bit d'inversion: (3-n) * 4 est le décalage pour le groupe de 4 bits correspondant au code de paire n, m est le décalage de réversion vertical (0 pour les 9 premiers, 2 pour les 9 dernières lignes), p est le décalage de réversion horizontal (0 pour les 12 premières, 1 pour les 12 dernières colonnes) +1 car le rang de bits faible est 1.

bitXor:effectue la réversion (il répond à un décalage 0 ou 1), et s at:2*n+1+bitXor_offsetchoisissez le bon caractère dans s.

Mais (A>>a)+(B>>b) bitAnd: 1coûte moins d'octets (A bitAt:a+1)bitXor:(B bitAt:b+1)qu'ainsi le bitXor a été réécrit et le décalage +1 sur p a disparu ...

h,#[13] est un laid grincement, nous pouvons concaténer une chaîne avec un ByteArray (contenant du code pour le retour chariot).

========================
------------------------
/\/\\\/\//\/\/\\/\///\/\
><>><<>>>><<>><<<<>><<><
////\\////\\//\\\\//\\\\
------------------------
/\\\/\\/\\//\\//\//\///\
\/\\/\//////\\\\\\/\//\/
\\\//\\\////\\\\///\\///
///\\///\\\\////\\\//\\\
/\//\/\\\\\\//////\/\\/\
\///\//\//\\//\\/\\/\\\/
------------------------
\\\\//\\\\//\\////\\////
><>><<>>>><<>><<<<>><<><
\/\///\/\\/\/\//\/\\\/\/
------------------------
========================