Per questa sfida, una trapunta d'arte ASCII sarà un blocco di testo di 24 caratteri di larghezza e 18 righe di altezza, contenente i caratteri =-<>/\in un modello a trapunta che è simmetrico in orizzontale e in verticale.

Esempio di trapunta:

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

Tutte le trapunte hanno la stessa forma:

• Sono sempre 24 per 18.
• La linea superiore (linea 1) e la linea inferiore (linea 18) sono =completamente trasversali.
• Le linee 2, 6, 13 e 17 sono -completamente trasversali.
• Le linee 4 e 15 sono lo stesso modello casuale simmetrico orizzontale di <e >.
• Tutte le altre linee (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) sono riempite /e \in modo completamente casuale in modo che l'intera trapunta rimanga simmetrica orizzontalmente e verticalmente .

Si noti che quando si piega la trapunta esattamente a metà, sia in verticale che in orizzontale, le forme dei personaggi corrispondono esattamente. Non confonderlo con i personaggi stessi abbinati. ad esempio la linea 3 e la linea 16 non lo sono identiche, sono immagini speculari verticali.

Sfida

Scrivi un programma o una funzione che stamperà o restituirà una trapunta artistica ASCII casuale.

A causa delle molte linee codificate e della simmetria, l'unica vera casualità proviene dai primi 12 caratteri sulle linee 3, 4, 5, 7, 8, 9:

• I primi 12 caratteri nella riga 4 dovrebbero essere in grado di contenere qualsiasi stringa di lunghezza 12 dei caratteri <e >.
• I primi 12 caratteri nelle righe 3, 5, 7, 8, 9 dovrebbero essere in grado di essere qualsiasi stringa di lunghezza 12 dei caratteri /e\ (indipendentemente l'uno dall'altro).
• Queste stringhe casuali vengono quindi rispecchiate di conseguenza per creare l'intera trapunta.

Vince la risposta più breve in byte. Tiebreaker è post precedente.

È possibile utilizzare generatori di numeri pseudocasuali. (No, non è necessario dimostrare che tutte e 12 le stringhe di caratteri di <>o /\possano essere generate con il PRNG della tua lingua.)

L'output può contenere facoltativamente una nuova riga finale, ma nessun spazio finale o altri caratteri oltre a quello necessario per la trapunta.

CJam, 61 60 58 55 54 52 51 byte

Abbreviato un po 'con l'aiuto di Sp3000 e Optimizer.

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

Provalo qui.

Spiegazione

Come di consueto con queste sfide simmetriche di arte ASCII, sto generando un quadrante e quindi lo espongo al massimo con due opportune operazioni di mirroring.

Per questa spiegazione dovrei iniziare con la funzione F, che sto definendo da qualche parte lungo la strada, perché è usata in tre punti per tre cose diverse:

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

Questo si aspetta un numero intero nella parte superiore dello stack e una stringa sotto quella. Il suo scopo è di invertire la stringa e anche scambiare alcuni caratteri, per ottenere il mirroring giusto. Il numero intero è 1o 3e indica se ( 1) sia le parentesi che le barre devono essere scambiate o ( 3) solo le parentesi devono essere scambiate. Ecco come funziona:

"<\/>"            "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.";

Ora per il resto del codice:

"=-/</-///"                            "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.";

Le due metà e quella nuova riga vengono quindi stampate automaticamente alla fine del programma.

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

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)

Con l'aiuto di @xnor, abbiamo finalmente raggiunto JS!

Uscita campione:

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

Spiegazione

(Leggermente obsoleto, verrà aggiornato in seguito)

"444046402"codifica le righe, con ogni cifra che fa riferimento all'indice iniziale della sottostringa a 2 caratteri di '--==\/<>'. Ogni singola riga è costruita al rovescio tramite ripetuti shuffle dei due caratteri (usando sample(...,2), poiché random.shufflepurtroppo è sul posto) e unendo le stringhe.

Un esempio semplificato di come potrebbe essere l'espansione per la quarta riga è:

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

che produrrebbe ><>><><<><:

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

Anche la trapunta generale è costruita al rovescio, poiché la costruzione inizia con la nona / decima fila, lavorando verso l'esterno. Per fare ciò, iniziamo con un elenco vuoto L, che aggiungiamo le righe all'inizio e alla fine del percorso

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

La n<"5"condizione è quella di verificare se abbiamo una riga composta ><, nel qual caso aggiungiamo una riga identica al retro, altrimenti il ​​suo contrario.

Infine, *_,=è quello di forzare la valutazione di maptale stampa, ed è solo un modo più breve per farlo print("\n".join(L)).

Per molto tempo ho avuto la funzione

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

che prende una stringa e converte /\><a \/<>, rispettivamente, ma ho finalmente riuscito a sbarazzarsi di esso :)

Python 2, 300 byte

Questo programma utilizza join, lambda, replace, sample, importe altre funzioni dettagliate, quindi non vincerà alcun premio di 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]])

Il codice prima che l'auto-golfista lo prendesse:

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 output di esempio:

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

APL ( 53 58)

Sfortunatamente non è così simmetrico come pensavo. Fix mi è costato 5 personaggi e ora sono fuori gioco.

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

Spiegazione:

• L←+,3-⌽: L è una funzione che restituisce il suo argomento seguito da 3 - il contrario del suo argomento
• L{L?12⍴2}¨⍳9: genera 9 righe di 12 valori casuali da [1,2] più il loro contrario, quindi il contrario di quelle 9 linee
• 732451451260688⊤⍨18/8: genera la lista 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(ecco dove sta la dannata asimmetricità)
• +: per ogni riga, aggiungere il numero corrispondente a ciascun valore
• ↑: formato come matrice
• '==--/\<><'[... ]: per ciascuno dei numeri nella matrice, selezionare il carattere dalla stringa in quella posizione

Produzione:

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

PHP, 408 , 407 , 402 , 387 , 379 byte

Non sono un buon giocatore di golf, ma questo problema sembrava divertente, quindi ho provato.

<?$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);

Codice Ungolfed

<?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 versione non golfata ha un piccolo bonus: puoi passarle un numero intero per seed rand()e ottenere la stessa trapunta ogni volta per un seed:

php quilt.php 48937

Ciò si traduce, ad esempio, in questa bellissima trapunta tessuta a mano:

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

Modifica : risulta che la mia prima versione non ha restituito una trapunta corretta. Quindi l'ho risolto. Abbastanza divertente, la correzione è ancora più breve.

JavaScript (ES6) 169 195 201

Modifica 6 byte salvati grazie a @nderscore. Attenzione, la nuova riga all'interno dei backquotes è significativa e contata.

Modifica2 costruzione di file semplificata, senza bisogno di reverseeconcat

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

Esegui snippet per testare (in 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

Mi piace questo perché mi ha fatto imparare ad abusare di barre rovesciate in entrambi i letterali di stringhe e String#tr. Il codice non è terribilmente intelligente altrimenti, solo compatto.

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

Grazie mille a @Jakube per aver creato queste versioni a 57 byte.

Algoritmo molto simile a quello di Martin. (Rivisto) Spiegazione a venire.

Provalo online

Spiegazione:

=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 byte

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

Uso:

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

1 byte grazie a @FUZxxl.

Spiegazione in arrivo.

Provalo online qui.

Pitone 295 287 227 byte

Non eccezionale, ma lo posterò comunque:

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

Se vuoi una spiegazione, chiedimi pure.

Javascript ( ES7 Draft ) 174 168 146

Qualche ispirazione presa da @ edc65

Modifica: grazie a edc65 per alcune idee per ottimizzare la costruzione di righe.

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

Dimostrazione: ( solo Firefox )

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>');

ha commentato:

// 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])

o formattato normalmente:

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

Spiegazione:

La corda s:='====----/\/\/<><<>'insieme al blocco f:=[:c|s at:(s indexOf:c)+i]sono qui sia per lanciare i personaggi sia per invertire gli schemi ...

• Per i = 1, esegue l'inversione orizzontale ( /<-> \, <<-> >).

• Per i = 3, esegue l'inversione verticale ( /<-> \)

• Per i = 1 o 2 atRandom, si lancia tra /o \,< o>

'=-/</-///' codifica il tipo di carattere c che alimenterà il blocco fper le prime 9 righe.

#() , '=-/</-///' è un trucco di concatenazione per trasformare la stringa in una matrice e quindi collezionarla in una matrice.

Il resto è semplice concatenazione dopo aver applicato la simmetria orizzontale / 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

O formattato:

|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

spiegazioni:

s:='==--/\<>'. ovviamente codifica le quattro coppie posibili.

r:=(1<<108)atRandom. lanciare 108 bit (in un LargeInteger) per 9 righe * 12 colonne (lanciamo == e - inutilmente ma le prestazioni non sono il nostro problema).

h:=''è la stringa in cui concateneremo (pittore di Schlemiel perché uno Stream sarebbe troppo costoso nei personaggi).

(16to:0by:-2),(0to:16by:2)do:[:i| sta ripetendo le righe (* 2)

(11to:0by:-1),(0to:11) do:[:j| sta ripetendo le colonne

28266è un numero magico che codifica la coppia da utilizzare sulle prime 9 righe.
È lo schema di bit 00 01 10 11 10 01 10 10 10, in cui 00 codifica '==', 01 '-', 10 '/ \' e 11 '<>'.

101è un numero magico che codifica l'inversione orizzontale e verticale.
È lo schema di bit 0000 0000 0110 1010, che codifica quando invertire (1) o meno (0) il primo (0) o il secondo (1) carattere di ciascuna coppia '==' '-' '/ \' e '<>', per la simmetria verticale e la simmetria orizzontale.

n:=3 bitAnd: 28266>>i fornisce la codifica della coppia di caratteri per la riga i / 2 (0 per '==', 1 per '-', 2 per '/ \' e 3 per '<>').

(r-1 bitAt: 6*i+j+1) scegli il bit casuale per la riga i / 2 colonna j (1 è il rango del bit più basso, quindi abbiamo un lancio casuale di 1, k at casuale nell'intervallo [1, k], quindi abbiamo un -1).

(101 bitAt: 3-n*4+m+p) scegli il bit di inversione: (3-n) * 4 è l'offset per il gruppo di 4 bit corrispondente al codice di coppia n, m è l'offset di inversione verticale (0 per i primi 9, 2 per le ultime 9 righe), p è il offset di inversione orizzontale (0 per i primi 12, 1 per le ultime 12 colonne) +1 perché il livello di bit basso è 1.

bitXor: esegue l'inversione (risponde a un offset 0 o 1) e s at:2*n+1+bitXor_offset seleziona il carattere giusto in s.

Ma (A>>a)+(B>>b) bitAnd: 1costa meno byte di(A bitAt:a+1)bitXor:(B bitAt:b+1) così il bitXor è stato riscritto e l'offset +1 su p è andato ...

h,#[13] è un brutto squittismo, possiamo concatenare una stringa con un ByteArray (contenente il codice per il ritorno a capo).

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