この課題では、ASCIIアートキルトは、幅24文字、高さ18行のテキストブロックであり、=-<>/\水平方向と垂直方向に対称なキルトのようなパターンの文字が含まれます。

キルトの例：

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

すべてのキルトの形式は同じです：

• それらは常に24 x 18です。
• 一番上の行（1行目）と一番下の行（18行目）が最後=です。
• 2行目、6行目、13行目、および17行目が-すべて横切っています。
• ライン4と15が同じランダムで左右対称のパターン<と>。
• 他のすべての行（3、5、7、8、9、10、11、12、14、16）で満たされている/と\全体のキルトが残るように、完全にランダムな方法で、水平および垂直対称。

キルトを縦または横に正確に半分に折り畳むと、キャラクターの形が正確に一致することに注意してください。キャラクター自体が一致することと混同しないでください。たとえば、ライン3とライン16は同一ではなく、垂直鏡像です。

チャレンジ

ランダムなASCIIアートキルトを印刷または返すプログラムまたは関数を作成します。

多くのハードコードされた行と対称性により、実際のランダム性は、行3、4、5、7、8、9の最初の12文字から得られます。

• 4行目の最初の12文字は、任意の長さの12文字の文字列である必要が<あり>ます。
• 3行目、5行目、7行目、7行目、8行目、9行目の最初の12文字は、任意の長さの12文字の文字列である必要が/あります\（互いに独立）。
• これらのランダムな文字列は、それに応じてミラーリングされ、キルト全体が作成されます。

バイト単位の最短回答が優先されます。Tiebreakerは以前の投稿です。

擬似乱数ジェネレーターを使用できます。（いいえ、あなたがいることを証明する必要はありません、すべての 12のcharの文字列<>や/\、あなたの言語のPRNGで生成することができます。）

出力には、オプションで末尾の改行を含めることができますが、キルトに必要なもの以外に末尾のスペースやその他の文字は含まれません。

CJam、61 60 58 55 54 52 51バイト

Sp3000とOptimizerの助けを借りて少し短くしました。

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

ここでテストしてください。

説明

これらの対称ASCIIアートの課題では通常どおり、1つの象限を生成し、2つの適切なミラーリング操作によってそれを完全なものに拡張しています。

この説明Fのために、3つの異なることのために3つの場所で使用されているため、途中でどこかで定義している関数から始めます。

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

2つの半分とその単一の改行は、プログラムの最後に自動的に印刷されます。

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文字の部分文字列の開始インデックスを参照して、行をエンコードします'--==\/<>'。個々の行は、2つの文字のシャッフルの繰り返し（残念ながらインプレースsample(...,2)であるため、を使用random.shuffle）と文字列の結合を介してインサイドアウトで構築されます。

4行目の展開がどのように表示されるかを示す簡単な例は次のとおりです。

''.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：[1,2]とその逆から12個のランダムな値の9行を生成し、次にこれらの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

これらの57バイトバージョンを作成してくれた@Jakubeに感謝します。

Martinのアルゴリズムに非常によく似たアルゴリズム。（改訂）今後の説明。

オンラインで試す

説明：

=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
========================
------------------------
///\\\\/\///\\\/\////\\\
><<><><>><>><<><<><><>><
\\/\//\\/\//\\/\//\\/\//
------------------------
\/\/\//////\/\\\\\\/\/\/
/\/\\//\//\\//\\/\\//\/\
//\\\\/////\/\\\\\////\\
\\////\\\\\/\/////\\\\//
\/\//\\/\\//\\//\//\\/\/
/\/\/\\\\\\/\//////\/\/\
------------------------
//\/\\//\/\\//\/\\//\/\\
><<><><>><>><<><<><><>><
\\\////\/\\\///\/\\\\///
------------------------
========================

@FUZxxlのおかげで1バイト。

説明はすぐに来ます。

こちらからオンラインでお試しください。

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の/場合\、<またはの間でトスします。または>

'=-/</-///'最初の9行のcブロックfにフィードする文字タイプをエンコードします。

#() , '=-/</-///' は、文字列を配列に変換し、配列に収集するための連結トリックです。

残りは、水平/垂直対称を適用した後の単純な連結です。

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

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

またはフォーマット：

|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:='==--/\<>'. 明らかに4つの可能なペアをエンコードします。

r:=(1<<108)atRandom. 9行* 12列で108ビット（LargeInteger）をトスします（==および-を不必要にトスしますが、パフォーマンスは問題ではありません）。

h:=''連結する文字列です（ストリームの文字のコストが高すぎるため、シュレミエルペインター）。

(16to:0by:-2),(0to:16by:2)do:[:i| 行を繰り返しています（* 2）

(11to:0by:-1),(0to:11) do:[:j| 列を繰り返しています

28266は、最初の9行で使用されるペアをエンコードするマジックナンバーです。00は '=='、01 '-'、10 '/ \'および11 '<>'をエンコードする
ビットパターン00 01 10 11 10 01 10 10 10です。

101は、水平および垂直の反転をエンコードするマジックナンバーです。
各パターン0000 0000 0110 1010の最初の（0）または2番目の（1）文字を逆にする（1）かしない（0）かをエンコードするビットパターンであり、「/ =」および「<>」垂直対称および水平対称用。

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はペアコードnに対応する4ビットのグループのオフセット、mは垂直反転オフセット（最初の9は0、最後の9行は2）、pは低ビットランクが1であるため、水平反転オフセット（最初の12は0、最後の12列は1）+1

bitXor:復帰を実行し（オフセット0または1に応答します）、s at:2*n+1+bitXor_offsetsの正しい文字を選択します。

しかし、bitXorが書き直され、pのオフセット+1がなくなる(A>>a)+(B>>b) bitAnd: 1よりもバイト数が少なくなります(A bitAt:a+1)bitXor:(B bitAt:b+1)...

h,#[13] いキーキーです。StringとByteArray（キャリッジリターンのコードを含む）を連結できます。

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