Für diese Herausforderung besteht ein ASCII-Quilt aus einem Textblock mit einer Breite von 24 Zeichen und einer Höhe von 18 Zeilen, der die Zeichen =-<>/\in einem quiltartigen Muster enthält, das horizontal und vertikal symmetrisch ist.

Beispiel Quilt:

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

Alle Quilts haben die gleiche Form:

• Sie sind immer 24 mal 18.
• Die oberste Zeile (Zeile 1) und die unterste Zeile (Zeile 18) sind =durchgehend.
• Die Zeilen 2, 6, 13 und 17 sind -durchgehend.
• Die Zeilen 4 und 15 sind das gleiche zufällige horizontal symmetrische Muster von <und >.
• Alle anderen Leitungen (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) mit gefüllt /und \in einer völlig zufälligen Art und Weise , so dass die gesamte Bettdecke bleibt horizontal und vertikal symmetrisch .

Beachten Sie, dass die Formen der Zeichen genau übereinstimmen , wenn Sie die Steppdecke vertikal oder horizontal genau zur Hälfte falten . Verwechseln Sie dies nicht mit den übereinstimmenden Charakteren. zb zeile 3 und zeile 16 sind nicht identisch, sie sind vertikale spiegelbilder.

Herausforderung

Schreiben Sie ein Programm oder eine Funktion, die einen zufälligen ASCII-Quilt ausgibt oder zurückgibt.

Aufgrund der vielen fest codierten Zeilen und der Symmetrie kommt die einzige echte Zufälligkeit aus den ersten 12 Zeichen in den Zeilen 3, 4, 5, 7, 8, 9:

• Die ersten 12 Zeichen in Zeile 4 sollten eine beliebige Länge von 12 Zeichen <und haben >.
• Die ersten 12 Zeichen in den Zeilen 3, 5, 7, 8, 9 sollten 12 Zeichen lang /und \(unabhängig voneinander) sein.
• Diese zufälligen Zeichenfolgen werden dann entsprechend gespiegelt, um den gesamten Quilt zu erstellen.

Die kürzeste Antwort in Bytes gewinnt. Tiebreaker ist früherer Beitrag.

Sie können Pseudozufallszahlengeneratoren verwenden. (Nein, Sie brauchen nicht zu beweisen , dass alle 12 Zeichen String <>oder /\erzeugt werden kann , mit Ihnen die Sprache des PRNG.)

Die Ausgabe kann optional einen abschließenden Zeilenumbruch enthalten, jedoch keine abschließenden Leerzeichen oder andere Zeichen außer dem, was für den Quilt erforderlich ist.

CJam, 61 60 58 55 54 52 51 Bytes

Mit Hilfe von Sp3000 und Optimizer etwas verkürzt.

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

Teste es hier.

Erläuterung

Wie bei diesen symmetrischen ASCII-Kunstherausforderungen üblich, erstelle ich einen Quadranten und erweitere ihn dann vollständig durch zwei geeignete Spiegelungsoperationen.

Für diese Erklärung sollte ich mit der Funktion beginnen F, die ich irgendwo auf dem Weg definiere, da sie an drei Stellen für drei verschiedene Dinge verwendet wird:

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

Dies erwartet eine Ganzzahl oben auf dem Stapel und eine Zeichenfolge darunter. Sein Zweck ist es, die Zeichenfolge umzukehren und einige Zeichen auszutauschen, um die richtige Spiegelung zu erzielen. Die Ganzzahl ist entweder 1oder 3und gibt an, ob ( 1) sowohl Klammern als auch Schrägstriche ausgetauscht werden sollen oder ( 3) nur Klammern ausgetauscht werden sollen. So funktioniert es:

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

Nun zum Rest des Codes:

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

Die beiden Hälften und diese einzelne Zeile werden dann am Ende des Programms automatisch gedruckt.

Python 3, 257 229 192 185 176 149 143 Bytes

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)

Mit Hilfe von @xnor haben wir JS endlich eingeholt!

Beispielausgabe:

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

Erläuterung

(Etwas veraltet, wird später aktualisiert)

"444046402"codiert die Zeilen, wobei sich jede Ziffer auf den Startindex der entsprechenden 2-Zeichen-Teilzeichenfolge von bezieht '--==\/<>'. Jede einzelne Zeile wird durch wiederholtes Mischen der beiden Zeichen (unter Verwendung von sample(...,2), da random.shuffleleider vorhanden) und Verbinden der Zeichenfolgen von innen nach außen aufgebaut .

Ein vereinfachtes Beispiel dafür, wie die Erweiterung für die vierte Zeile aussehen könnte, ist:

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

was ergeben würde ><>><><<><:

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

Die Gesamtsteppdecke ist ebenfalls von innen nach außen gebaut, da der Bau mit der 9./10. Reihe beginnt und nach außen abläuft. Zu diesem Zweck beginnen wir mit einer leeren Liste L, in die wir beim Durchlaufen der Liste Zeilen vorne und hinten einfügen

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

Die n<"5"Bedingung ist, zu überprüfen, ob wir eine Reihe haben, die aus ><besteht. In diesem Fall hängen wir eine identische Reihe an die Rückseite an, ansonsten ist es umgekehrt.

Schließlich *_,=soll die Auswertung maperzwungen werden, damit das Drucken erfolgt, und es ist nur ein kürzerer Weg, dies zu tun print("\n".join(L)).

Ich hatte lange Zeit die Funktion

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

die nimmt einen string und konvertiert /\><in \/<>jeweils, aber ich habe es endlich geschafft, es loszuwerden :)

Python 2, 300 Bytes

Dieses Programm verwendet join, lambda, replace, sample, importund andere ausführliche Funktionen, so dass es keine Golfpreise gewinnt.

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

Der Code, bevor der Autogolfer ihn bekam:

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

Eine Beispielausgabe:

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

APL ( 53 58)

Es ist leider nicht ganz so symmetrisch wie ich dachte. Fix hat mich 5 Charaktere gekostet und jetzt bin ich raus.

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

Erläuterung:

• L←+,3-⌽: L ist eine Funktion, die das Argument gefolgt von 3 zurückgibt - die Umkehrung des Arguments
• L{L?12⍴2}¨⍳9: Erzeugt 9 Zeilen mit 12 Zufallswerten aus [1,2] plus deren Umkehrung, dann die Umkehrung dieser 9 Zeilen
• 732451451260688⊤⍨18/8: Liste generieren 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(hier liegt die verdammte Asymmetrie)
• +: Addieren Sie für jede Zeile die entsprechende Zahl zu jedem Wert
• ↑: Format als Matrix
• '==--/\<><'[... ]: Wählen Sie für jede der Zahlen in der Matrix das Zeichen aus der Zeichenfolge an dieser Position aus

Ausgabe:

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

PHP, 408 , 407 , 402 , 387 , 379 Bytes

Ich bin kein guter Golfer, aber dieses Problem klang lustig, also habe ich es ausprobiert.

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

Ungolfed Code

<?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";

?>

Die ungolfed-Version hat einen kleinen Bonus: Sie können eine Ganzzahl an seed übergeben rand()und jedes Mal den gleichen Quilt für einen seed erhalten:

php quilt.php 48937

Das ergibt zum Beispiel diese schöne, handgewebte Steppdecke:

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

Bearbeiten : Es stellte sich heraus, dass meine erste Version keinen korrekten Quilt zurückgegeben hat. Also habe ich es behoben. Komischerweise ist der Fix noch kürzer.

JavaScript (ES6) 169 195 201

Bearbeiten Sie 6 Bytes, die in @nderscore gespeichert wurden. Achtung, der Zeilenvorschub in Anführungszeichen ist signifikant und wird gezählt.

Edit2 vereinfachte Zeilenerstellung , ohne reverseundconcat

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

Führen Sie das Snippet zum Testen aus (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

Ich mag dieses, weil es mich dazu brachte, Backslashes in beiden Stringliteralen und zu missbrauchen String#tr. Ansonsten ist der Code nicht besonders clever, nur kompakt.

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

Vielen Dank an @Jakube für die Entwicklung dieser 57-Byte-Versionen.

Algorithmus sehr ähnlich zu Martins. (Überarbeitet) Erläuterung folgt.

Probieren Sie es online aus

Erläuterung:

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

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

Verwendung:

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

1 Byte dank @FUZxxl.

Erklärung folgt in Kürze.

Probieren Sie es hier online aus.

Python 295 287 227 Bytes

Nicht so toll, aber ich werde es trotzdem posten:

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

Wenn Sie eine Erklärung wünschen, fragen Sie mich einfach.

Javascript ( ES7-Entwurf ) 174 168 146

Einige Inspirationen von @ edc65

Edit: Danke an edc65 für einige Ideen zur Optimierung des Zeilenaufbaus.

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

Demonstration: ( nur 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>');

Kommentiert:

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

oder normal formatiert:

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

Erläuterung:

Die Zeichenfolge s:='====----/\/\/<><<>'zusammen mit dem Block dient f:=[:c|s at:(s indexOf:c)+i]hier sowohl zum Werfen der Zeichen als auch zum Umkehren der Muster ...

• Für i = 1 führt es eine horizontale Umkehrung durch ( /<-> \, <<-> >).

• Für i = 3 führt es eine vertikale Umkehrung durch ( /<-> \)

• Für i 1 oder 2 atRandom =, werfen Sie es unter /oder \, <oder>

'=-/</-///'codiert den Zeichentyp c, der den Block ffür die 9 ersten Zeilen speist .

#() , '=-/</-///' ist ein Verkettungstrick zum Umwandeln des Strings in ein Array und somit zum Sammeln in ein Array.

Der Rest ist eine einfache Verkettung nach dem Anwenden der horizontalen / vertikalen Symmetrie.

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

Quietschen 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

Oder formatiert:

|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

Erklärungen:

s:='==--/\<>'. codiert offensichtlich die vier möglichen Paare.

r:=(1<<108)atRandom. Wirf 108 Bits (in einer LargeInteger) für 9 Zeilen * 12 Spalten (wir werfen die == und - unnötigerweise, aber die Leistung ist nicht unser Problem).

h:=''ist die Zeichenkette, in der wir verketten werden (Schlemiel-Maler, weil ein Stream in Zeichen zu kostspielig wäre).

(16to:0by:-2),(0to:16by:2)do:[:i| iteriert in den Zeilen (* 2)

(11to:0by:-1),(0to:11) do:[:j| iteriert auf den Spalten

28266ist eine magische Zahl, die das in den ersten 9 Zeilen zu verwendende Paar codiert.
Es ist das Bitmuster 00 01 10 11 10 01 10 10 10, bei dem 00 '==', 01 '-', 10 '/ \' und 11 '<>' codiert.

101ist eine magische Zahl, die die horizontale und vertikale Umkehrung codiert.
Es ist das Bitmuster 0000 0000 0110 1010, das codiert, wann das erste (0) oder zweite (1) Zeichen jedes Paares '==' '-' '/ \' und '<>' umgekehrt (1) oder nicht (0) werden soll. für die vertikale symetrie und horizontale symetrie.

n:=3 bitAnd: 28266>>i gibt die Kodierung des Zeichenpaares für die Zeile i / 2 an (0 für '==', 1 für '-', 2 für '/ \' und 3 für '<>').

(r-1 bitAt: 6*i+j+1) Wählen Sie das Zufallsbit für die Zeile i / 2, Spalte j (1 ist der Rang des niedrigsten Bits, daher haben wir ein +1, k atRandom-Wurf im Intervall [1, k], daher haben wir ein -1).

(101 bitAt: 3-n*4+m+p) Wählen Sie das Umkehrbit: (3-n) * 4 ist der Versatz für die Gruppe von 4 Bits entsprechend dem Paarcode n, m ist der vertikale Umkehrversatz (0 für die ersten 9, 2 für die letzten 9 Zeilen), p ist der Versatz horizontaler Umkehrversatz (0 für die ersten 12, 1 für die letzten 12 Spalten) +1, weil der niedrige Bitrang 1 ist.

bitXor:führt die Umkehrung durch (sie beantwortet einen Versatz von 0 oder 1) und s at:2*n+1+bitXor_offsetwählt das richtige Zeichen in s aus.

Kostet aber (A>>a)+(B>>b) bitAnd: 1weniger Bytes, als (A bitAt:a+1)bitXor:(B bitAt:b+1)damit das BitXor umgeschrieben wurde und Offset +1 auf p weg ist ...

h,#[13] Ist ein hässlicher Quietschismus, können wir einen String mit einem ByteArray verketten (der Code für den Wagenrücklauf enthält).

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