Para esse desafio, uma colcha de arte ASCII terá um bloco de texto com 24 caracteres de largura e 18 linhas de altura, contendo os caracteres =-<>/\em um padrão semelhante a uma colcha simétrica horizontal e verticalmente.

Colcha de exemplo:

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

Todas as colchas têm a mesma forma:

• Eles são sempre 24 por 18.
• A linha superior (linha 1) e a linha inferior (linha 18) estão =do outro lado.
• As linhas 2, 6, 13 e 17 estão -do outro lado.
• As linhas 4 e 15 são o mesmo padrão aleatório horizontalmente simétrico de <e >.
• Todas as outras linhas (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) são preenchidas /e de \maneira completamente aleatória, de modo que toda a colcha permaneça simétrica horizontal e verticalmente .

Observe que, ao dobrar a colcha exatamente ao meio, vertical ou horizontalmente, as formas dos caracteres são exatamente iguais. Não confunda isso com os próprios personagens. por exemplo, as linhas 3 e 16 não são idênticas, são imagens espelhadas verticais.

Desafio

Escreva um programa ou função que imprima ou retorne uma manta de arte ASCII aleatória.

Devido às muitas linhas codificadas e à simetria, a única aleatoriedade real vem dos 12 primeiros caracteres nas linhas 3, 4, 5, 7, 8, 9:

• Os 12 primeiros caracteres da linha 4 devem ter 12 caracteres de comprimento <e >.
• Os primeiros 12 caracteres nas linhas 3, 5, 7, 8, 9 devem poder ter qualquer comprimento de 12 caracteres /e \(independentes um do outro).
• Essas seqüências aleatórias são espelhadas de acordo para formar a colcha inteira.

A resposta mais curta em bytes vence. O desempatador é uma publicação anterior.

Você pode usar geradores de números pseudo-aleatórios. (Não, você não precisa provar que todas as 12 caracteres <>ou /\podem ser geradas com o PRNG do seu idioma.)

Opcionalmente, a saída pode conter uma nova linha à direita, mas não há espaços à direita ou outros caracteres além do necessário para a colcha.

CJam, 61 60 58 55 54 52 51 bytes

Encurtou um pouco com a ajuda do Sp3000 e do Optimizer.

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

Teste aqui.

Explicação

Como sempre, com esses desafios simétricos da arte ASCII, estou gerando um quadrante e depois expandindo-o ao máximo por duas operações de espelhamento apropriadas.

Para esta explicação, devo começar com a função F, que estou definindo em algum lugar ao longo do caminho, porque é usada em três lugares para três coisas diferentes:

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

Isso espera um número inteiro no topo da pilha e uma string abaixo disso. Seu objetivo é inverter a string e também trocar alguns caracteres, para obter o espelhamento correto. O número inteiro é 1ou 3e indica se ( 1) os colchetes e as barras devem ser trocados ou ( 3) apenas os colchetes devem ser trocados. Aqui está como funciona:

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

Agora, para o resto do código:

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

As duas metades e a nova linha única são impressas automaticamente no final do programa.

Python 3, 257 229 192 185 176 149 143 bytes

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)

Com a ajuda do @xnor, finalmente alcançamos o JS!

Saída de amostra:

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

Explicação

(Um pouco desatualizado, será atualizado mais tarde)

"444046402"codifica as linhas, com cada dígito se referindo ao índice inicial da substring de 2 caracteres relevante de '--==\/<>'. Cada linha individual é construída de dentro para fora através da repetição aleatória dos dois caracteres (usando sample(...,2), pois random.shuffleinfelizmente está no local) e da união de cadeias.

Um exemplo simplificado de como a expansão pode parecer para a quarta linha é:

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

o que produziria ><>><><<><:

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

A colcha geral também é construída de dentro para fora, pois a construção começa com a 9ª / 10ª linhas, trabalhando para fora. Para fazer isso, começamos com uma lista vazia L, na qual adicionamos linhas na frente e no verso à medida que avançamos

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

A n<"5"condição é verificar se temos uma linha que consiste em ><, nesse caso, anexamos uma linha idêntica à parte traseira, caso contrário, seu inverso.

Finalmente, *_,=é forçar a avaliação mappara que a impressão ocorra e é apenas uma maneira mais curta de fazer print("\n".join(L)).

Durante muito tempo tive a função

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

que pega uma string e converte /\><em \/<>respectivamente, mas finalmente consegui me livrar dela :)

Python 2, 300 bytes

Este programa usa join, lambda, replace, sample, importe outras funções detalhadas, por isso não ganhará nenhum prêmio de golfe.

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

O código antes do jogador de golfe se apossar dele:

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

Uma saída de amostra:

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

APL ( 53 58)

Infelizmente, não é tão simétrico quanto eu pensava. Correção me custou 5 caracteres e agora estou fora de funcionamento.

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

Explicação:

• L←+,3-⌽: L é uma função que retorna seu argumento seguido por 3 - o inverso de seu argumento
• L{L?12⍴2}¨⍳9: gere 9 linhas de 12 valores aleatórios a partir de [1,2] mais seu reverso, depois o inverso dessas 9 linhas
• 732451451260688⊤⍨18/8: gerar a lista 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(é aí que está a maldita assimetria)
• +: para cada linha, adicione o número correspondente a cada valor
• ↑: formato como matriz
• '==--/\<><'[... ]: para cada um dos números na matriz, selecione o caractere da sequência nessa posição

Saída:

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

PHP, 408 , 407 , 402 , 387 , 379 bytes

Eu não sou um bom jogador de golfe, mas esse problema parecia divertido, então tentei.

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

Código ungolfed

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

?>

A versão não gasta tem um pequeno bônus: você pode passar um número inteiro para a semente rand()e obter a mesma colcha de cada vez para uma semente:

php quilt.php 48937

Isso resulta, por exemplo, nesta linda colcha tecida à mão:

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

Editar : Acontece que minha primeira versão não retornou uma colcha correta. Então eu consertei. Engraçado o bastante, a correção é ainda mais curta.

JavaScript (ES6) 169 195 201

Edite 6 bytes salvos thx @nderscore. Cuidado, a nova linha dentro de aspas é significativa e contada.

Edit2 construção de linhas simplificada, sem necessidade de reverseeconcat

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

Execute o snippet para testar (no 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'>

Ruby, 162 155

Eu gosto deste porque me fez aprender a abusar barras invertidas nos literais de string e String#tr. Caso contrário, o código não é muito inteligente, apenas compacto.

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

Muito obrigado a @Jakube por apresentar essas versões de 57 bytes.

Algoritmo muito semelhante ao de Martin. (Revisto) Explicação por vir.

Experimente online

Explicação:

=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 bytes

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

Uso:

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

1 byte graças a @FUZxxl.

Explicação em breve.

Experimente online aqui.

Pitão 295 287 227 bytes

Não é tão bom, mas eu vou postá-lo de qualquer maneira:

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

Se você quiser uma explicação, pergunte-me.

Javascript ( ES7 Draft ) 174 168 146

Alguma inspiração tirada de @ edc65

Edit: Obrigado ao edc65 por algumas idéias para otimizar a construção de linhas.

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

Demonstração: ( somente 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>');

Comentado:

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

ou formatado normalmente:

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

Explicação:

A corda s:='====----/\/\/<><<>'junto com o bloco f:=[:c|s at:(s indexOf:c)+i]está aqui tanto para jogar os personagens quanto para reverter os padrões ...

• Para i = 1, ele realiza a reversão horizontal ( /<-> \, <<-> >).

• Para i = 3, ele realiza a reversão vertical ( /<-> \)

• Para i = 1 ou 2 no Random, ele joga entre /ou \, <ou>

'=-/</-///'codifica o tipo de caractere cque alimentará o bloco fpelas 9 primeiras linhas.

#() , '=-/</-///' é um truque de concatenação para transformar a String em uma matriz e, assim, coletar em uma matriz.

O restante é uma concatenação simples após a aplicação da simetria horizontal / vertical.

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

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

Ou formatado:

|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

Explicações:

s:='==--/\<>'. obviamente codifica os quatro pares possíveis.

r:=(1<<108)atRandom. atire 108 bits (em um LargeInteger) por 9 linhas * 12 colunas (lançamos o == e - desnecessariamente, mas o desempenho não é nosso problema).

h:=''é a string na qual concatenaremos (pintor de Schlemiel porque um fluxo seria muito caro em caracteres).

(16to:0by:-2),(0to:16by:2)do:[:i| está iterando nas linhas (* 2)

(11to:0by:-1),(0to:11) do:[:j| está iterando nas colunas

28266é um número mágico que codifica o par a ser usado nas primeiras 9 linhas.
É o padrão de bits 00 01 10 11 10 01 10 10 10, em que 00 codifica '==', 01 '-', 10 '/ \' e 11 '<>'.

101é um número mágico que codifica a reversão horizontal e vertical.
É o padrão de bits 0000 0000 0110 1010, codificando quando inverter (1) ou não (0) o primeiro (0) ou o segundo (1) caractere de cada par '==' '-' '/ \' e '<>', para a simetria vertical e simetria horizontal.

n:=3 bitAnd: 28266>>i fornece a codificação do par de caracteres para a linha i / 2 (0 para '==', 1 para '-', 2 para '/ \' e 3 para '<>').

(r-1 bitAt: 6*i+j+1) escolha o bit aleatório para a linha i / 2 da coluna j (1 é a classificação do bit mais baixo, portanto, temos +1, k no lançamento aleatório no intervalo [1, k], portanto, temos -1).

(101 bitAt: 3-n*4+m+p) escolha o bit de reversão: (3-n) * 4 é o deslocamento para o grupo de 4 bits correspondente ao código de par n, m é o deslocamento de reversão vertical (0 para os primeiros 9, 2 para as últimas 9 linhas), p é o deslocamento de reversão horizontal (0 para as primeiras 12, 1 para as últimas 12 colunas) +1 porque a classificação de bits baixa é 1.

bitXor:executa a reversão (responde um deslocamento 0 ou 1) e s at:2*n+1+bitXor_offsetescolhe o caractere correto em s.

Mas (A>>a)+(B>>b) bitAnd: 1custa menos bytes do (A bitAt:a+1)bitXor:(B bitAt:b+1)que o bitXor foi reescrito e o deslocamento +1 em p desapareceu ...

h,#[13] é um squeakism feio, podemos concatenar uma String com um ByteArray (contendo código para retorno de carro).

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