Для этой задачи художественное стеганое одеяло 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 Draft ) 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 первых строк.

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

Остальное - простая конкатенация после применения горизонтальной / вертикальной симметрии.

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

Скрип 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 случайных бросков в интервале [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] это уродливый скрип, мы можем объединить строку с помощью ByteArray (содержащий код возврата каретки).

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