Для цього завдання художня ковдра 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.

Завдяки безлічі твердо кодованих ліній та симетрії, єдина реальна випадковість виходить з перших 12 символів на рядках 3, 4, 5, 7, 8, 9:

• Перші 12 символів у рядку 4 повинні мати будь-яку довжину 12 рядків символів <і >.
• Перші 12 символів у рядках 3, 5, 7, 8, 9 повинні мати будь-яку довжину 12 рядків символів /і \(незалежно один від одного).
• Ці випадкові рядки потім відображаються відповідно дзеркально, щоб зробити всю ковдру.

Виграє найкоротша відповідь у байтах. Tiebreaker - це раніше повідомлення.

Ви можете використовувати генератори псевдовипадкових чисел. (Ні, вам не потрібно доводити, що всі 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"Умова , щоб перевірити , чи є у нас рядок , що складається з ><, і в цьому випадку ми додається ідентичну рядок в задню частини , в іншому випадку його зворотне.

Нарешті, *_,=змусити оцінити mapтак, що друк відбувається, і це лише коротший спосіб зробити print("\n".join(L)).

Тривалий час я мав функцію

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

яка приймає рядок і перетворює /\><в \/<>відповідно, але я нарешті -то вдалося позбутися від нього :)

Python 2, 300 байт

Ця програма використовує join, lambda, replace, sample, importта інші багатослівні функції, тому вона не виграє жодної нагороди за гольф.

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] плюс їх зворотній, потім зворотний з цих 9 рядків
• 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 байтів, збережених thx @nderscore. Будьте уважні, нова рядок всередині зворотних котирувань є вагомим і рахується.

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)

Піта, 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

Фаро 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 випадкових випадків, вона кидається серед /або \, <або>

'=-/</-///'кодує тип символу, cякий подаватиме блок fдля 9 перших рядків.

#() , '=-/</-///' є конкатенаційним трюком для перетворення String в масив і, таким чином, збирання в масив.

Решта - це проста конкатенація після застосування горизонтальної / вертикальної симетрії.

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

Склей 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:=''це рядок, де ми будемо об'єднуватися (художник Шлемієль, тому що Потік був би занадто дорогим персонажами).

(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 кодує '==', 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 був переписаний і зміщено +1 на p ...

h,#[13] це некрасивий пискiзм, ми можемо поєднати String з ByteArray (містить код для повернення каретки).

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