Bu zorluk için, bir ASCII sanat yorganı, karakterleri =-<>/\yatay ve dikey olarak simetrik olan bir yorgan benzeri düzende içeren, 24 karakter genişliğinde ve 18 satır uzunluğunda bir metin bloğu olacaktır .

Örnek yorgan:

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

Tüm yorganlar aynı biçimdedir:

• Her zaman 24'e 18.
• Üst satır (satır 1) ve alt satır (satır 18) =tüm yol boyunca.
• 2, 6, 13 ve 17 numaralı hatlar -tüm yol boyunca.
• Satır 4 ve 15, aynı rastgele yatay olarak simetrik paterndir <ve >.
• Diğer tüm hatları (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) ile doldurulur /ve \bütün yorgan kalacak şekilde tamamen rasgele bir şekilde , yatay ve dikey simetrik .

Yorganı katlarken, yarı dikey, dikey veya yatay olarak, karakterlerin şekillerinin tam olarak eşleştiğine dikkat edin. Bunu, karakterlerin kendileri ile eşleştirmesiyle karıştırmayın. örneğin, çizgi 3 ve çizgi 16 aynı değildir , dikey ayna görüntüleridir.

Meydan okuma

Rasgele bir ASCII art yorganını basacak veya döndürecek bir program veya işlev yazın.

Çok sayıda kodlanmış satır ve simetri nedeniyle, tek gerçek rasgelelik, 3, 4, 5, 7, 8, 9 satırlarındaki ilk 12 karakterden gelir:

• 4. satırdaki ilk 12 karakter, karakterlerden herhangi bir uzunlukta 12 karakterden oluşmalı <ve >.
• 3, 5, 7, 8, 9 satırlarındaki ilk 12 karakter, karakterlerin herhangi bir uzunluğu 12 karakterden oluşmalı /ve \(birbirinden bağımsız) olmalıdır.
• Bu rasgele dizeler daha sonra tüm yorganın yapılması için buna göre yansıtılır.

Bayt cinsinden en kısa cevap kazanır. Tiebreaker daha önce yayınlandı.

Sahte ve sayı üreteçlerini kullanabilirsiniz. (Hayır, 12 karakterli dizenin tamamının<> veya /\sizin dilinizin PRNG'si ile oluşturulabileceğini kanıtlamanıza gerek yoktur .)

Çıktı isteğe bağlı olarak takip eden bir yeni satır içerebilir, ancak yorgan için gerekli olanın dışında takip eden boşluk veya başka karakterler yoktur.

CJam, 61 60 58 55 54 52 51 bayt

Sp3000 ve Optimizer’ın yardımıyla bir miktar kısaltıldı.

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

Burada test et.

açıklama

Bu simetrik ASCII sanat zorluklarında her zamanki gibi, bir kadran üretiyorum ve ardından iki uygun yansıtma işlemi ile onu tam şeye genişletiyorum.

Bu açıklama için F, yol boyunca bir yerde tanımladığım fonksiyonla başlamalıyım , çünkü üç yerde üç farklı şey için kullanılıyor:

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

Bu, yığının üstünde bir tamsayı ve bunun altında bir dize bekler. Amacı, dize ters çevirmek ve aynı zamanda yansıtma doğru elde etmek için bazı karakterleri takas etmektir. Tamsayı ya ya 1da ya da 3( 1) hem parantezlerin hem de eğik çizgilerin değiştirilip değiştirilmeyeceğini veya ( 3) yalnızca parantezlerin değiştirilip değiştirilmeyeceğini belirtir . İşte nasıl çalışıyor:

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

Şimdi kodun geri kalanı için:

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

İki yarım ve bu yeni satır sonunda program sonunda otomatik olarak yazdırılır.

Python 3, 257 229 192 185 176 149 143 bayt

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)

@Xnor'ın yardımıyla nihayet JS'yi yakaladık!

Örnek çıktı:

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

açıklama

(Biraz eski, daha sonra güncellenecek)

"444046402"Her bir rakamın ilgili 2-karakter alt dizisinin başlangıç ​​indeksine atıfta bulunarak satırları kodlar '--==\/<>'. İki karakterlerin karıştırma tekrarlanan içten dışa aracılığıyla Her birey satır (kullanılarak inşa edilmiştir sample(...,2)beri, random.shuffleve dize katılmadan maalesef yer-in).

Dördüncü satır için genişlemenin nasıl göründüğünün basitleştirilmiş bir örneği:

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

hangi verim ><>><><<><:

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

Genel yorgan aynı zamanda içten dışa inşa edilmiştir, çünkü inşaat 9. / 10. sıralarda başlar ve dışa doğru çalışır. Bunu yapmak Liçin, ilerledikçe önüne ve arkasına satır eklediğimiz boş bir liste ile başlıyoruz.

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

Buradaki n<"5"şart, aşağıdakilerden oluşan bir satır olup olmadığını kontrol etmektir ><, bu durumda arkaya özdeş bir satır ekleriz, aksi halde tersini.

Son olarak, baskının gerçekleşmesini *_,=değerlendirmek için zorlamaktır ve mapbunu yapmak için daha kısa bir yoldur print("\n".join(L)).

Uzun zamandır işleve sahibim

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

hangi bir dize ve dönüşürse alır /\><için \/<>sırasıyla ama sonunda bundan kurtulmak başardınız :)

Python 2,300 bayt

Bu program kullanır join, lambda, replace, sample, importve diğer ayrıntılı işlevler, bu nedenle herhangi bir golf ödülü kazanmayacaksınız.

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

Otomatik golfçünün önündeki kod onu ele geçirdi:

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

Bir örnek çıktı:

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

APL ( 53 58)

O değil oldukça ben ne yazık ki, düşünce gibi simetrik. Bana 5 karakter tamir edildi ve şimdi tükendi.

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

Açıklama:

• L←+,3-⌽: L argümanını döndüren ve ardından argümanını döndüren bir fonksiyondur - argümanının tersi
• L{L?12⍴2}¨⍳9: [1,2] 'den artı 9, 12 rasgele değer satırı üret
• 732451451260688⊤⍨18/8: listeyi hazırla 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(lanet olası asimetrikliğin olduğu yer)
• +: her satır için, her bir değere karşılık gelen sayıyı ekleyin
• ↑: matris biçiminde
• '==--/\<><'[... ]: matristeki sayıların her biri için, o konumdaki dizeden bir karakter seçin

Çıktı:

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

PHP, 408 , 407 , 402 , 387 , 379 bayt

Ben iyi bir golfçü değilim, ama bu sorun kulağa eğlenceli geliyordu, ben de denedim.

<?$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 kod

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

?>

Ungolded versiyonun küçük bir bonusu var: Onu bir tam sayıya ekebilir rand()ve bir tohum için her seferinde aynı yorganı alabilirsiniz:

php quilt.php 48937

Bu, örneğin, bu güzel, elle dokunmuş yorganda:

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

Düzenleme : İlk sürümümün doğru yorgan döndürmediği ortaya çıktı. Bu yüzden düzelttim. Yeterince komik, düzeltme daha da kısa.

JavaScript (ES6) 169 195 201

Düzenleme 6 bayt thx @nderscore kaydedildi. Dikkat edin, geri dönüşlerin içindeki yeni satır önemli ve sayılır.

Edit2 basitleştirilmiş sıra bina, gerek reverseveconcat

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

Test etmek için pasajı çalıştır (Firefox'ta)

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

Bunu sevdim, çünkü her iki string kelimesinde de ters eğik çizgileri suistimal etmeyi öğrenmemi sağladı String#tr. Kod aksi takdirde zekice değil, sadece küçük.

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

Bu 57 baytlık versiyonlarla geldiğiniz için @Jakube'e çok teşekkürler.

Algoritma, Martin'e çok benzer. (Revize) Gelecek açıklama.

Çevrimiçi deneyin

Açıklama:

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

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

Kullanımı:

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

@ FUZxxl 'a 1 bayt teşekkürler.

Açıklama çok yakında.

Burada çevrimiçi deneyin.

Python 295 287 227 bayt

Çok iyi değil ama yine de göndereceğim:

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

Bir açıklama istiyorsan, sadece bana sor.

Javascript ( ES7 Taslağı ) 174 168 146

@ Edc65 tarafından alınan bazı ilham kaynakları

Düzenleme: Satırların oluşturulmasını optimize etmek için bazı fikirler için edc65 sayesinde.

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

Gösteri: ( yalnızca 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>');

Yorumlananlar:

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

veya normal olarak biçimlendirilmiş:

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

Açıklama:

s:='====----/\/\/<><<>'Blok ile birlikte karakter dizisi f:=[:c|s at:(s indexOf:c)+i]hem karakterleri atmak hem de desenleri ters çevirmek için ...

• İ = 1 için yatay ters çevirme yapar ( /<-> \, <<-> >).

• İ = 3 için dikey ters çevirme yapar ( /<-> \)

• İ 1 ya da 2 atRandom = için, arasında atmak /veya \, <ya da>

'=-/</-///'9 ilk satır için cbloğu besleyecek karakter tipini kodlar f.

#() , '=-/</-///' String'i bir Diziye dönüştürmek ve böylece bir Diziyi toplamak için kullanılan bir birleştirme hilesidir.

Gerisi yatay / dikey simetriyi uyguladıktan sonra basit birleştirmedir.

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

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

Veya biçimlendirilmiş:

|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

açıklamalar:

s:='==--/\<>'. Açıkçası dört olası çiftleri kodlar.

r:=(1<<108)atRandom. 9 satır * 12 sütun için 108 bit (bir LargeInteger'da) atmak (== ve - gereksiz yere atıyoruz ancak performans bizim sorunumuz değil).

h:=''birleştireceğimiz dizedir (Schlemiel ressam, çünkü bir Aktar karakter olarak çok maliyetli olurdu).

(16to:0by:-2),(0to:16by:2)do:[:i| satırlarda yineleniyor (* 2)

(11to:0by:-1),(0to:11) do:[:j| sütunlarda yineleniyor

28266ilk 9 satırda kullanılacak çifti kodlayan sihirli bir sayıdır. 00 '' == ', 01' - ', 10' / \ 've 11' <> 'kodlayan
bit kalıptır 00 01 10 11 10 01 10 10 10.

101yatay ve dikey dönüşü kodlayan sihirli bir sayıdır. '==' '-' '/ \' ve '<>' çiftlerinin ilk (0) veya ikinci (1) karakterinin ne zaman ters çevrileceğini (1) kodlayan
bit modelidir 0000 0000 0110 1010, düşey ve yatay simetri için.

n:=3 bitAnd: 28266>>i i / 2 satırı için karakter çiftinin kodlamasını verir ('==' için 0, '-' için 1, '/ \' için 2 ve '<>' için 3).

(r-1 bitAt: 6*i+j+1) i / 2 sütunu j için rastgele biti seçin (1, en düşük biti rütbesidir, bu nedenle [1, k] aralığında bir +1, k atRandom atması vardır, bu nedenle bir -1 vardır).

(101 bitAt: 3-n*4+m+p) ters bitini seçin: (3-n) * 4 n çift koduna karşılık gelen 4 bitlik grup için ofsettir, m dikey ters çevrme ofsetidir (p, ilk 9 satır için 0, son 9 satır için) yatay ters çevirme kayması (ilk 12 için 0, son 12 sütun için 1) +1 çünkü düşük bit sırası 1'dir.

bitXor:tersine çevirme işlemini gerçekleştirir (0 veya 1 ötelemesine cevap verir) ve s at:2*n+1+bitXor_offsetdoğru karakteri s cinsinden seçer.

Ancak , bitXor'un yeniden yazılmasından (A>>a)+(B>>b) bitAnd: 1daha az bayt maliyeti (A bitAt:a+1)bitXor:(B bitAt:b+1)ve p = +1 dengelemesi gitti ...

h,#[13] çirkin bir gıcırtılığa sahipseniz, bir String'i ByteArray (satırbaşı dönüş kodu içeren) ile birleştirebiliriz.

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