Đối với thử thách này, một chiếc mền nghệ thuật ASCII sẽ là một khối văn bản rộng 24 ký tự và cao 18 dòng, chứa các ký tự =-<>/\theo mô hình giống như chăn đối xứng theo chiều ngang và chiều dọc.

Ví dụ chăn:

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

Tất cả các mền có cùng một hình thức:

• Họ luôn luôn 24 trong 18.
• Dòng trên cùng (dòng 1) và dòng dưới cùng (dòng 18) là =tất cả các cách.
• Các dòng 2, 6, 13 và 17 đều -đi qua.
• Các dòng 4 và 15 là cùng một mẫu đối xứng theo chiều ngang ngẫu nhiên <và >.
• Tất cả các dòng khác (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) được lấp đầy /và \theo cách hoàn toàn ngẫu nhiên sao cho toàn bộ chăn vẫn đối xứng theo chiều ngang và chiều dọc .

Lưu ý rằng khi gấp chăn chính xác một nửa, theo chiều dọc hoặc chiều ngang, hình dạng của các ký tự khớp chính xác với nhau. Đừng nhầm lẫn điều này với các nhân vật tự kết hợp. ví dụ dòng 3 và dòng 16 không giống nhau, chúng là hình ảnh phản chiếu dọc.

Thử thách

Viết chương trình hoặc chức năng sẽ in hoặc trả lại chăn nghệ thuật ASCII ngẫu nhiên.

Do có nhiều dòng mã hóa cứng và tính đối xứng, sự ngẫu nhiên thực sự duy nhất đến từ 12 ký tự đầu tiên trên các dòng 3, 4, 5, 7, 8, 9:

• 12 ký tự đầu tiên trên dòng 4 sẽ có thể có độ dài 12 chuỗi ký tự <và >.
• 12 ký tự đầu tiên trên các dòng 3, 5, 7, 8, 9 phải có thể là bất kỳ chuỗi dài 12 ký tự nào /và \(độc lập với nhau).
• Các chuỗi ngẫu nhiên này sau đó được nhân đôi để tạo ra toàn bộ chăn.

Câu trả lời ngắn nhất trong byte thắng. Tiebreaker là bài trước.

Bạn có thể sử dụng trình tạo số giả ngẫu nhiên. (Không, bạn không cần phải chứng minh rằng tất cả 12 chuỗi char <>hoặc /\có thể được tạo bằng PRNG ngôn ngữ của bạn.)

Đầu ra có thể tùy ý chứa một dòng mới, nhưng không có dấu cách hoặc các ký tự khác ngoài những gì cần thiết cho chăn.

CJam, 61 60 58 55 54 52 51 byte

Rút ngắn một chút với một số trợ giúp từ Sp3000 và Trình tối ưu hóa.

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

Kiểm tra nó ở đây.

Giải trình

Như thường lệ với những thách thức nghệ thuật ASCII đối xứng này, tôi tạo ra một góc phần tư và sau đó mở rộng nó thành toàn bộ bằng hai thao tác phản chiếu thích hợp.

Đối với lời giải thích này, tôi nên bắt đầu với chức năng Fmà tôi đang xác định ở đâu đó trên đường đi, bởi vì nó được sử dụng ở ba nơi cho ba điều khác nhau:

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

Điều này mong đợi một số nguyên trên đỉnh của ngăn xếp và một chuỗi bên dưới đó. Mục đích của nó là đảo ngược chuỗi và cũng trao đổi một số ký tự, để có được sự phản chiếu đúng. Các số nguyên là một trong hai 1hoặc 3và cho biết ( 1) cả hai dấu ngoặc và dấu gạch chéo nên được trao đổi hoặc ( 3) chỉ dấu ngoặc nên được hoán đổi. Đây là cách nó làm việc:

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

Bây giờ cho phần còn lại của mã:

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

Hai nửa và dòng mới đó sẽ được in tự động vào cuối chương trình.

Python 3, 257 229 192 185 176 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)

Với sự giúp đỡ từ @xnor, cuối cùng chúng tôi cũng đã bắt kịp với JS!

Đầu ra mẫu:

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

Giải trình

(Hơi lỗi thời, sẽ cập nhật sau)

"444046402"mã hóa các hàng, với mỗi chữ số đề cập đến chỉ mục bắt đầu của chuỗi con 2 char có liên quan của '--==\/<>'. Mỗi hàng riêng lẻ được xây dựng từ trong ra ngoài thông qua việc xáo trộn lặp lại hai ký tự (sử dụng sample(...,2), vì random.shufflekhông may tại chỗ) và nối chuỗi.

Một ví dụ đơn giản về việc mở rộng có thể trông như thế nào đối với hàng thứ tư là:

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

sẽ mang lại ><>><><<><:

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

Chăn tổng thể cũng được xây dựng từ trong ra ngoài, khi việc xây dựng bắt đầu với các hàng thứ 9/10, hoạt động ra bên ngoài. Để làm điều này, chúng tôi bắt đầu với một danh sách trống L, chúng tôi thêm các hàng vào phía trước và phía sau khi chúng tôi đi qua

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

Điều n<"5"kiện là để kiểm tra xem chúng ta có một hàng bao gồm hay không ><, trong trường hợp đó chúng ta nối một hàng giống hệt vào phía sau, nếu không thì ngược lại.

Cuối cùng, *_,=là để đánh giá việc mapin ấn xảy ra, và chỉ là một cách ngắn hơn để làm print("\n".join(L)).

Trong một thời gian dài tôi đã có chức năng

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

mà phải mất một chuỗi và cải /\><để \/<>tương ứng, nhưng cuối cùng tôi đã quản lý để thoát khỏi nó :)

Python 2, 300 byte

Chương trình này sử dụng join, lambda, replace, sample, importvà các chức năng dài dòng khác, vì vậy nó sẽ không giành được bất kỳ giải thưởng golf nào.

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

Mã trước khi golfer tự động nắm giữ nó:

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

Một đầu ra mẫu:

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

APL ( 53 58)

Thật không may, nó không hoàn toàn đối xứng như tôi nghĩ, thật không may. Sửa chữa tốn 5 ký tự và bây giờ tôi không còn hoạt động.

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

Giải trình:

• L←+,3-⌽: L là một hàm trả về đối số của nó theo sau là 3 - mặt trái của đối số của nó
• L{L?12⍴2}¨⍳9: tạo 9 dòng gồm 12 giá trị ngẫu nhiên từ [1,2] cộng với đảo ngược của chúng, sau đó đảo ngược của 9 dòng đó
• 732451451260688⊤⍨18/8: tạo danh sách 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(đó là nơi không đối xứng chết tiệt)
• +: cho mỗi dòng, thêm số tương ứng vào mỗi giá trị
• ↑: định dạng dưới dạng ma trận
• '==--/\<><'[... ]: cho mỗi số trong ma trận, chọn ký tự từ chuỗi ở vị trí đó

Đầu ra:

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

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

Tôi không phải là một tay golf giỏi, nhưng vấn đề này nghe có vẻ vui nên tôi đã thử.

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

Mã mã

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

?>

Phiên bản chưa được chỉnh sửa có một phần thưởng nhỏ: Bạn có thể chuyển cho nó một số nguyên cho hạt giống rand()và nhận được cùng một chăn mỗi lần cho một hạt giống:

php quilt.php 48937

Kết quả này, ví dụ, trong chiếc chăn dệt bằng tay tuyệt đẹp này:

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

Chỉnh sửa : Hóa ra phiên bản đầu tiên của tôi không trả lại đúng chăn. Vì vậy, tôi đã sửa nó. Hài hước lắm, bản sửa lỗi thậm chí còn ngắn hơn.

JavaScript (ES6) 169 195 201

Chỉnh sửa 6 byte lưu thx @nderscore. Hãy coi chừng, dòng mới bên trong backquotes là đáng kể và được tính.

Edit2 xây dựng hàng đơn giản hóa, không cần reversevàconcat

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

Chạy đoạn mã để kiểm tra (trong 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'>

Hồng ngọc, 162 155

Tôi thích cái này vì nó khiến tôi học cách lạm dụng dấu gạch chéo ngược trong cả hai chuỗi ký tự và String#tr. Mã không thông minh khủng khiếp nếu không, chỉ nhỏ gọn.

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)

Bình thường, 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

Cảm ơn rất nhiều đến @Jakube vì đã đưa ra các phiên bản 57 byte này.

Thuật toán rất giống với Martin. (Sửa đổi) Giải thích sắp tới.

Dùng thử trực tuyến

Giải trình:

=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

Sử dụng:

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

1 byte nhờ @FUZxxl.

Giải thích đến sớm.

Hãy thử trực tuyến tại đây.

Python 295 287 227 byte

Không phải là tuyệt vời nhưng dù sao tôi cũng sẽ đăng nó:

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

Nếu bạn muốn một lời giải thích chỉ cần hỏi tôi.

Javascript ( Dự thảo ES7 ) 174 168 146

Một số cảm hứng lấy từ @ edc65

Chỉnh sửa: Nhờ edc65 cho một số ý tưởng để tối ưu hóa việc xây dựng các hàng.

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

Trình diễn: ( chỉ dành cho 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>');

Đã bình luận:

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

hoặc được định dạng bình thường:

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

Giải trình:

Chuỗi s:='====----/\/\/<><<>'cùng với khối f:=[:c|s at:(s indexOf:c)+i]ở đây cả để ném các ký tự và đảo ngược các mẫu ...

• Với i = 1, nó thực hiện đảo chiều ngang ( /<-> \, <<-> >).

• Với i = 3, nó thực hiện đảo chiều dọc ( /<-> \)

• Đối với i = 1 hoặc 2 atRandom, nó sẽ nằm trong số /hoặc\ , <hoặc>

'=-/</-///' mã hóa kiểu ký tự c sẽ cung cấp khối fcho 9 dòng đầu tiên.

#() , '=-/</-///' là một mẹo ghép để chuyển đổi Chuỗi thành Mảng và do đó thu thập thành Mảng.

Phần còn lại là cách ghép đơn giản sau khi áp dụng phép đo ngang / dọc.

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

Tiếng kêu 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

Hoặc được định dạng:

|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

Giải thích:

s:='==--/\<>'. rõ ràng mã hóa bốn cặp hữu hình.

r:=(1<<108)atRandom. ném 108 bit (trong LargeInteger) cho 9 hàng * 12 cột (chúng tôi ném == và - không cần thiết nhưng hiệu suất không phải là vấn đề của chúng tôi).

h:=''là chuỗi nơi chúng ta sẽ ghép nối (họa sĩ Schlemiel vì một luồng sẽ quá tốn kém trong các ký tự).

(16to:0by:-2),(0to:16by:2)do:[:i| đang lặp trên các hàng (* 2)

(11to:0by:-1),(0to:11) do:[:j| đang lặp lại trên các cột

28266là một số ma thuật mã hóa cặp được sử dụng trên 9 dòng đầu tiên.
Đây là mô hình bit00 01 10 11 10 01 10 10 10 , trong đó 00 mã hóa '==', 01 '-', 10 '/ \' và 11 '<>'.

101là một số ma thuật mã hóa sự đảo ngược ngang và dọc.
Đây là mô hình bit0000 0000 0110 1010 , mã hóa khi đảo ngược (1) hay không (0) ký tự đầu tiên (0) hoặc thứ hai (1) của mỗi cặp '==' '-' '/ \' và '<>', cho các ký hiệu dọc và ký hiệu ngang.

n:=3 bitAnd: 28266>>i đưa ra mã hóa cặp ký tự cho hàng i / 2 (0 cho '==', 1 cho '-', 2 cho '/ \' và 3 cho '<>').

(r-1 bitAt: 6*i+j+1) chọn bit ngẫu nhiên cho hàng i / 2 cột j (1 là thứ hạng của bit thấp nhất do đó chúng ta có +1, k atRandom tung trong khoảng [1, k] do đó chúng ta có -1).

(101 bitAt: 3-n*4+m+p) chọn bit đảo chiều: (3-n) * 4 là phần bù cho nhóm 4 bit tương ứng với mã cặp n, m là phần bù đảo chiều dọc (0 cho 9 hàng đầu tiên, 2 cho 9 hàng cuối cùng), p là bù đảo chiều ngang (0 cho 12 cột đầu tiên, 1 cho 12 cột cuối cùng) +1 vì thứ hạng bit thấp là 1.

bitXor: thực hiện đảo ngược (nó trả lời bù 0 hoặc 1) và s at:2*n+1+bitXor_offset chọn đúng ký tự trong s.

Nhưng (A>>a)+(B>>b) bitAnd: 1chi phí ít byte hơn (A bitAt:a+1)bitXor:(B bitAt:b+1)do đó bitXor đã được viết lại và bù +1 trên p đã biến mất ...

h,#[13] là một chủ nghĩa khó chịu xấu xí, chúng ta có thể nối một Chuỗi bằng ByteArray (chứa mã để trả lại vận chuyển).

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