สำหรับความท้าทายนี้ผ้าห่มศิลปะ ASCII จะเป็นบล็อกของข้อความกว้าง 24 ตัวอักษรและสูง 18 บรรทัดซึ่งประกอบด้วยอักขระ=-<>/\ในรูปแบบคล้ายผ้าห่มที่มีทั้งแนวนอนและแนวตั้งสมมาตร

ผ้าห่มตัวอย่าง:

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

ผ้าห่มทั้งหมดมีรูปแบบเดียวกัน:

• พวกเขามักจะ 24 ถึง 18
• บรรทัดบนสุด (บรรทัดที่ 1) และบรรทัดล่างสุด (บรรทัดที่ 18) อยู่=ตลอดทาง
• บรรทัดที่ 2, 6, 13 และ 17 -ล้วนผ่านมาแล้ว
• สาย 4 และ 15 จะเหมือนกันสุ่มสมมาตรแนวนอนรูปแบบของและ<>
• สายอื่น ๆ ทั้งหมด (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) ที่เต็มไปด้วย/และ\ในทางที่สุ่มสมบูรณ์ดังกล่าวว่าผ้าห่มทั้งหมดยังคงอยู่ในแนวนอนและแนวตั้งสมมาตร

โปรดสังเกตว่าเมื่อพับครึ่งผ้าห่มทั้งในแนวตั้งและแนวนอนรูปร่างของตัวละครจะเข้ากันทุกประการ อย่าสับสนกับตัวละครที่เข้าคู่กัน เช่นบรรทัดที่ 3 และบรรทัดที่ 16 ไม่เหมือนกันพวกเขาเป็นภาพสะท้อนแนวตั้ง

ท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่จะพิมพ์หรือส่งคืน ASCII art quilt แบบสุ่ม

เนื่องจากจำนวนบรรทัด hardcoded และสมมาตรการสุ่มที่แท้จริงเพียงอย่างเดียวมาจากอักขระ 12 ตัวแรกในบรรทัดที่ 3, 4, 5, 7, 8, 9:

• 12 ตัวอักษรครั้งแรกในบรรทัดที่ 4 ควรจะสามารถเป็นอะไรก็ได้ความยาว 12 สตริงของตัวละครและ<>
• อักขระ 12 ตัวแรกในบรรทัดที่ 3, 5, 7, 8, 9 ควรมีความยาว 12 สตริงของอักขระ/และ\(เป็นอิสระจากกัน)
• สตริงแบบสุ่มเหล่านี้จะถูกมิร์เรอร์ตามลำดับเพื่อสร้างทั้งผ้าห่ม

คำตอบที่สั้นที่สุดเป็นไบต์ชนะ Tiebreaker เป็นโพสต์ก่อนหน้า

คุณอาจใช้เครื่องกำเนิดตัวเลขเทียมหลอก (ไม่คุณไม่จำเป็นต้องพิสูจน์ว่าสตริง char ทั้ง 12 ตัว<>หรือ/\สามารถสร้างด้วย PRNG ของภาษาของคุณ)

เอาท์พุทอาจมีการขึ้นบรรทัดใหม่ต่อท้าย แต่ไม่มีช่องว่างต่อท้ายหรือตัวละครอื่น ๆ นอกเหนือจากสิ่งที่จำเป็นสำหรับผ้าห่ม

CJam, 61 60 58 55 54 52 51 ไบต์

ย่อเล็กน้อยด้วยความช่วยเหลือจาก Sp3000 และ Optimizer

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

ทดสอบที่นี่

คำอธิบาย

ตามปกติด้วยความท้าทายศิลปะ ASCII แบบสมมาตรเหล่านี้ฉันกำลังสร้างหนึ่งในสี่ด้านจากนั้นขยายให้เต็มโดยใช้การดำเนินการสะท้อนสองแบบที่เหมาะสม

สำหรับคำอธิบายนี้ฉันควรเริ่มต้นด้วยฟังก์ชั่นFซึ่งฉันกำหนดไว้ที่ไหนสักแห่งระหว่างทางเพราะมันถูกใช้ในสามแห่งสำหรับสามสิ่งที่แตกต่างกัน:

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

สิ่งนี้คาดว่าจะเป็นจำนวนเต็มที่ด้านบนของสแต็กและสตริงที่อยู่ด้านล่าง โดยมีวัตถุประสงค์คือเพื่อย้อนกลับสตริงและสลับตัวละครบางตัวเพื่อให้ได้มิเรอร์ที่ถูกต้อง จำนวนเต็มเป็นอย่างใดอย่างหนึ่ง1หรือ3และบ่งชี้ว่า ( 1) ทั้งวงเล็บและเครื่องหมายทับควรสลับหรือ ( 3) วงเล็บเท่านั้นควรสลับ นี่คือวิธีการทำงาน:

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

ตอนนี้สำหรับรหัสที่เหลือ:

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

สองครึ่งและบรรทัดใหม่นั้นจะถูกพิมพ์โดยอัตโนมัติเมื่อสิ้นสุดโปรแกรม

Python 3, 257 229 192 185 176 149 143 ไบต์

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 ในที่สุดเราก็ติดกับ JS!

ตัวอย่างผลลัพธ์:

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

คำอธิบาย

(ล้าสมัยเล็กน้อยจะอัปเดตในภายหลัง)

"444046402"ถอดรหัสแถวกับแต่ละหลักหมายถึงดัชนีเริ่มต้นของการย่อย 2 '--==\/<>'ถ่านที่เกี่ยวข้องของ แต่ละแถวของแต่ละบุคคลที่ถูกสร้างขึ้นภายในออกผ่านสับซ้ำของทั้งสองตัวอักษร (ใช้sample(...,2)ตั้งแต่random.shuffleเป็นที่น่าเสียดายในสถานที่) และสตริงเข้าร่วม

ตัวอย่างง่าย ๆ ของสิ่งที่การขยายอาจมีลักษณะสำหรับแถวที่สี่คือ:

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

ซึ่งจะให้ผล><>><><<><:

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

ผ้านวมโดยรวมยังถูกสร้างขึ้นภายใน - ออกเช่นกันเมื่อการก่อสร้างเริ่มต้นด้วยแถวที่ 9/10 ทำงานออกไปด้านนอก เมื่อต้องการทำสิ่งนี้เราจะเริ่มต้นด้วยรายการที่ว่างเปล่าLซึ่งเราเพิ่มแถวไว้ด้านหน้าและด้านหลังเมื่อเราผ่าน

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

n<"5"เงื่อนไขเพื่อตรวจสอบว่าเรามีแถวประกอบด้วย><ซึ่งในกรณีที่เราผนวกแถวเหมือนจะกลับมิฉะนั้นมันตรงกันข้าม

สุดท้าย*_,=คือการบังคับการประเมินผลเพื่อการพิมพ์ที่เกิดขึ้นและเป็นเพียงวิธีที่สั้นกว่าที่จะทำmapprint("\n".join(L))

เป็นเวลานานที่ฉันมีฟังก์ชั่น

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

ซึ่งใช้สตริงและแปลง/\><เป็น\/<>ลำดับ แต่ในที่สุดฉันก็สามารถกำจัดได้ :)

Python 2, 300 ไบต์

โปรแกรมนี้ใช้join, lambda, replace, sample, importและฟังก์ชั่น verbose อื่น ๆ ดังนั้นมันจะไม่ชนะรางวัลกอล์ฟใด ๆ

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

รหัสก่อนที่นักกอล์ฟจะได้รับ:

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

ตัวอย่างผลลัพธ์:

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

APL ( 53 58)

มันไม่ได้ค่อนข้างสมมาตรอย่างที่ฉันคิดว่ามันน่าเสียดาย แก้ไขค่าใช้จ่ายฉัน 5 ตัวอักษรและตอนนี้ฉันหมด

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

คำอธิบาย:

• L←+,3-⌽: L เป็นฟังก์ชันที่ส่งคืนอาร์กิวเมนต์ตามด้วย 3 - การย้อนกลับของอาร์กิวเมนต์
• L{L?12⍴2}¨⍳9: สร้าง 9 บรรทัดของค่าสุ่ม 12 ค่าจาก [1,2] บวกกับการย้อนกลับ
• 732451451260688⊤⍨18/8: สร้างรายการ0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(นั่นคือสิ่งที่เป็นอสมมาตรแช่ง)
• +: สำหรับแต่ละบรรทัดเพิ่มหมายเลขที่สอดคล้องกับแต่ละค่า
• ↑: จัดรูปแบบเป็นเมทริกซ์
• '==--/\<><'[... ]: สำหรับตัวเลขแต่ละตัวในเมทริกซ์ให้เลือกตัวละครจากสตริงที่ตำแหน่งนั้น

เอาท์พุท:

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

PHP, 408 , 407 , 402 , 387 , 379 ไบต์

ฉันไม่ใช่นักกอล์ฟที่ดี แต่ปัญหานี้ฟังดูสนุกฉันเลยลองดู

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

รหัสที่ไม่ได้รับการปรับปรุง

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

?>

เวอร์ชันที่ไม่ได้รับรางวัลมีโบนัสเล็กน้อย: คุณสามารถส่งจำนวนเต็มไปยังการเพาะrand()และได้ผ้าห่มที่เหมือนกันในแต่ละครั้งสำหรับเมล็ด

php quilt.php 48937

ยกตัวอย่างเช่นในผ้าห่มที่ทอด้วยมืออันสวยงามนี้

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

แก้ไข : เปิดใช้งานรุ่นแรกของฉันไม่ได้คืนผ้าห่มที่ถูกต้อง ดังนั้นฉันจึงแก้ไขมัน ตลกพอการแก้ไขสั้นลง

JavaScript (ES6) 169 195 201

แก้ไข 6 ไบต์ที่บันทึกไว้ขอบคุณ @nderscore ระวังบรรทัดใหม่ภายใน backquotes นั้นมีความสำคัญและถูกนับ

Edit2 การสร้างแถวให้ง่ายขึ้นไม่จำเป็นต้องใช้reverseและ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

เรียกใช้ตัวอย่างเพื่อทดสอบ (ใน 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'>

ทับทิม, 162 155

String#trฉันเช่นนี้เพราะมันทำให้ฉันเรียนรู้ที่จะละเมิดเครื่องหมายทั้งในและตัวอักษรของสตริง รหัสไม่ฉลาดอย่างยิ่งยวดเพียงแค่กะทัดรัด

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

ขอบคุณมากที่ @Jakube ที่มากับรุ่น 57 ไบต์เหล่านี้

อัลกอริทึมคล้ายกับของมาร์ติน (แก้ไข) คำอธิบายที่จะมา

ลองออนไลน์

คำอธิบาย:

=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 ไบต์

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

การใช้งาน:

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

1 ไบต์ต้องขอบคุณ @FUZxxl

คำอธิบายจะมาเร็ว ๆ นี้

ลองออนไลน์ได้ที่นี่

Python 295 287 227 ไบต์

ไม่มาก แต่ฉันจะโพสต์ไว้:

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

หากคุณต้องการคำอธิบายเพียงแค่ถามฉัน

Javascript ( ฉบับร่าง ES7 ) 174 168 146

แรงบันดาลใจบางส่วนมาจาก @ edc65

แก้ไข: ขอบคุณ edc65 สำหรับแนวคิดบางประการในการเพิ่มประสิทธิภาพการสร้างแถว

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

การสาธิต: ( 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>');

แสดงความคิดเห็น:

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

หรือจัดรูปแบบตามปกติ:

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

คำอธิบาย:

สตริงs:='====----/\/\/<><<>'พร้อมกับบล็อกf:=[:c|s at:(s indexOf:c)+i]อยู่ที่นี่เพื่อสลับอักขระและสลับรูปแบบ ...

• สำหรับ i = 1 จะทำการพลิกกลับในแนวนอน ( /<-> \, <<-> >)

• สำหรับ i = 3 จะทำการพลิกกลับในแนวตั้ง ( /<-> \)

• สำหรับ i = 1 หรือ 2 atRandom ก็โยนหมู่/หรือ\, <หรือ>

'=-/</-///'เข้ารหัสประเภทอักขระcที่จะป้อนบล็อกfสำหรับ 9 บรรทัดแรก

#() , '=-/</-///' เป็นวิธีการเรียงต่อกันสำหรับการเปลี่ยนสตริงให้เป็นอาเรย์และเก็บเป็นอาเรย์

ส่วนที่เหลือคือการต่อกันอย่างง่าย ๆ หลังจากใช้ symetry แนวนอน / แนวตั้ง

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

รับสารภาพ 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

หรือจัดรูปแบบ:

|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

คำอธิบาย:

s:='==--/\<>'. เห็นได้ชัดว่าเข้ารหัสสี่คู่ที่เป็นไปได้

r:=(1<<108)atRandom. โยน 108 บิต (ใน LargeInteger) สำหรับ 9 แถว * 12 คอลัมน์ (เราโยน == และ - โดยไม่จำเป็น แต่ประสิทธิภาพไม่ใช่ปัญหาของเรา)

h:=''เป็นสตริงที่เราจะต่อกัน (Schlemiel จิตรกรเพราะสตรีมจะมีราคาแพงเกินไปในตัวอักษร)

(16to:0by:-2),(0to:16by:2)do:[:i| วนซ้ำแถว (* 2)

(11to:0by:-1),(0to:11) do:[:j| กำลังวนซ้ำในคอลัมน์

28266เป็นหมายเลขเวทย์เข้ารหัสคู่ที่จะใช้ใน 9 บรรทัดแรก
มันเป็นรูปแบบบิต00 01 10 11 10 01 10 10 10โดยที่ 00 encodes '==', 01 '-', 10 '/ \' และ 11 '<>'

101เป็นหมายเลขมายากลที่เข้ารหัสการพลิกกลับในแนวนอนและแนวตั้ง
มันเป็นรูปแบบบิตการ0000 0000 0110 1010เข้ารหัสเมื่อต้องการย้อนกลับ (1) หรือไม่ (0) อักขระแรก (0) หรือวินาที (1) ของแต่ละคู่ '==' '-' '/' 'และ' <> ', สำหรับซิมโฟนีแนวตั้งและแนวนอน

n:=3 bitAnd: 28266>>i ให้การเข้ารหัสของคู่อักขระสำหรับแถว i / 2 (0 สำหรับ '==', 1 สำหรับ '-', 2 สำหรับ '/ \' และ 3 สำหรับ '<>')

(r-1 bitAt: 6*i+j+1) เลือกสุ่มบิตสำหรับแถว i / 2 คอลัมน์ j (1 คืออันดับของบิตต่ำสุดดังนั้นเราจึงมี +1, k atRandom การทอยในช่วงเวลา [1, k] ดังนั้นเราจึงมี -1)

(101 bitAt: 3-n*4+m+p) เลือกบิตการกลับรายการ: (3-n) * 4 เป็นออฟเซ็ตสำหรับกลุ่ม 4 บิตที่สอดคล้องกับรหัสคู่ n, m คือการพลิกกลับในแนวตั้งชดเชย (0 สำหรับ 9 แรก 2 สำหรับ 9 แถวสุดท้าย) p คือ ออฟเซตการพลิกกลับในแนวนอน (0 สำหรับ 12 แรกแรก 1 สำหรับ 12 คอลัมน์สุดท้าย) +1 เพราะอันดับบิตต่ำคือ 1

bitXor:ทำการพลิกกลับ (ตอบกลับออฟเซต 0 หรือ 1) และs at:2*n+1+bitXor_offsetเลือกอักขระที่ถูกต้องใน s

แต่(A>>a)+(B>>b) bitAnd: 1ค่าใช้จ่ายน้อยกว่าไบต์(A bitAt:a+1)bitXor:(B bitAt:b+1)ดังนั้น bitXor จึงถูกเขียนใหม่และ offset +1 บน p หายไป ...

h,#[13] เป็นสารภาพที่น่าเกลียดเราสามารถเชื่อมสตริงกับ ByteArray (มีรหัสสำหรับการคืนสินค้า)

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