Para este desafío, una colcha de arte ASCII será un bloque de texto de 24 caracteres de ancho y 18 líneas de alto, que contiene los caracteres =-<>/\en un patrón similar a una colcha que es simétrica horizontal y verticalmente.

Edredón de ejemplo:

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

Todos los edredones tienen la misma forma:

• Siempre son 24 por 18.
• La línea superior (línea 1) y la línea inferior (línea 18) están =completamente cruzadas.
• Las líneas 2, 6, 13 y 17 están -al otro lado.
• Las líneas 4 y 15 son el mismo patrón aleatorio simétrico horizontalmente de <y >.
• Todas las demás líneas (3, 5, 7, 8, 9, 10, 11, 12, 14, 16) se rellenan /y \de forma completamente aleatoria, de modo que toda la colcha permanece horizontal y verticalmente simétrica .

Tenga en cuenta que al plegar la colcha exactamente por la mitad, ya sea vertical u horizontalmente, las formas de los caracteres coinciden exactamente. No confundas esto con los personajes que coinciden. por ejemplo, la línea 3 y la línea 16 no son idénticas, son imágenes especulares verticales.

Reto

Escriba un programa o función que imprima o devuelva una colcha de arte ASCII aleatoria.

Debido a las muchas líneas codificadas y la simetría, la única aleatoriedad real proviene de los primeros 12 caracteres en las líneas 3, 4, 5, 7, 8, 9:

• Los primeros 12 caracteres de la línea 4 deben poder tener una longitud de 12 cadenas de caracteres <y >.
• Los primeros 12 caracteres en las líneas 3, 5, 7, 8, 9 deben poder tener una longitud de 12 cadenas de los caracteres /y \(independientes entre sí).
• Estas cadenas aleatorias se reflejan en consecuencia para hacer toda la colcha.

La respuesta más corta en bytes gana. Tiebreaker es una publicación anterior.

Puede usar generadores de números pseudoaleatorios. (No, no es necesario demostrar que todas cadena de carbón de 12 <>o /\se puede generar con PRNG de que el lenguaje.)

La salida puede contener opcionalmente una nueva línea final, pero no espacios finales u otros caracteres además de lo que es necesario para la colcha.

CJam, 61 60 58 55 54 52 51 bytes

Se acortó un poco con la ayuda de Sp3000 y Optimizer.

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

Pruébalo aquí.

Explicación

Como es habitual con estos desafíos de arte ASCII simétricos, estoy generando un cuadrante y luego lo amplío al máximo mediante dos operaciones de duplicación apropiadas.

Para esta explicación, debería comenzar con la función F, que estoy definiendo en algún lugar del camino, porque se usa en tres lugares para tres cosas diferentes:

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

Esto espera un número entero en la parte superior de la pila y una cadena debajo de eso. Su propósito es invertir la cadena y también intercambiar algunos caracteres, para obtener el reflejo correcto. El entero es 1o 3e indica si ( 1) se deben intercambiar los corchetes y las barras inclinadas o ( 3) solo se deben intercambiar los corchetes. Así es 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.";

Ahora para el resto del 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.";

Las dos mitades y esa nueva línea se imprimen automáticamente al final del 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)

Con la ayuda de @xnor, ¡finalmente hemos alcanzado a JS!

Salida de muestra:

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

Explicación

(Ligeramente desactualizado, se actualizará más tarde)

"444046402"codifica las filas, y cada dígito se refiere al índice inicial de la subcadena de 2 caracteres correspondiente de '--==\/<>'. Cada fila individual se construye de adentro hacia afuera a través de la combinación repetida de los dos caracteres (usando sample(...,2), random.shuffledesafortunadamente , está en su lugar) y la unión de cadenas.

Un ejemplo simplificado de cómo se vería la expansión para la cuarta fila es:

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

que produciría ><>><><<><:

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

El edredón general también se construye de adentro hacia afuera, ya que la construcción comienza con las filas 9 y 10, trabajando hacia afuera. Para hacer esto, comenzamos con una lista vacía L, a la que agregamos filas al frente y atrás a medida que avanzamos

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

La n<"5"condición es verificar si tenemos una fila que consiste en ><, en cuyo caso agregamos una fila idéntica a la parte posterior, de lo contrario su reverso.

Finalmente, *_,=es forzar la evaluación mappara que se produzca la impresión, y es solo una forma más corta de hacerlo print("\n".join(L)).

Durante mucho tiempo tuve la función

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

que toma una cadena y la convierte /\><en \/<>respectivamente, pero finalmente logré deshacerme de ella :)

Python 2, 300 bytes

Este programa utiliza join, lambda, replace, sample, importy otras funciones detalladas, por lo que no ganará ningún premio de golf.

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

El código antes de que el auto-golfista lo obtuviera:

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

Una salida de muestra:

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

APL ( 53 58)

Desafortunadamente, no es tan simétrico como pensé que era. La solución me costó 5 caracteres y ahora estoy fuera de la carrera.

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

Explicación:

• L←+,3-⌽: L es una función que devuelve su argumento seguido de 3, el reverso de su argumento
• L{L?12⍴2}¨⍳9: genera 9 líneas de 12 valores aleatorios a partir de [1,2] más su reverso, luego el reverso de esas 9 líneas
• 732451451260688⊤⍨18/8: genera la lista 0 2 4 6 4 2 4 4 4 4 4 4 2 4 _7_ 4 2 0(ahí es donde está la maldita asimetría)
• +: para cada línea, agregue el número correspondiente a cada valor
• ↑: formato como matriz
• '==--/\<><'[... ]: para cada uno de los números en la matriz, seleccione el carácter de la cadena en esa posición

Salida:

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

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

No soy un buen golfista, pero este problema sonaba divertido, así que lo probé.

<?$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 sin golf

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

?>

La versión sin golf tiene una pequeña bonificación: puede pasarle un número entero para sembrar rand()y obtener la misma colcha cada vez que se obtiene una semilla:

php quilt.php 48937

Esto resulta, por ejemplo, en esta hermosa colcha tejida a mano:

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

Editar : Resulta que mi primera versión no devolvió una colcha correcta. Entonces lo arreglé. Curiosamente, la solución es aún más corta.

JavaScript (ES6) 169 195 201

Editar 6 bytes guardados thx @nderscore. Cuidado, la nueva línea dentro de las comillas inversas es significativa y contada.

Edite2 construcción de filas simplificada, sin necesidad de reverseyconcat

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

Ejecute el fragmento para probar (en 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'>

Rubí, 162 155

Me gusta este porque me hizo aprender a abusar de las barras invertidas en los literales de cadena y String#tr. De lo contrario, el código no es terriblemente inteligente, solo 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

Muchas gracias a @Jakube por presentar estas versiones de 57 bytes.

Algoritmo muy similar al de Martin. (Revisado) Explicación por venir.

Pruébalo en línea

Explicación:

=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 gracias a @FUZxxl.

Explicación próximamente.

Pruébelo en línea aquí.

Python 295 287 227 bytes

No es tan bueno, pero lo publicaré de todos modos:

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

Si quieres una explicación solo pregúntame.

Javascript ( Proyecto de ES7 ) 174 168 146

Alguna inspiración tomada de @ edc65

Editar: Gracias a edc65 por algunas ideas para optimizar la construcción de filas.

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

Demostración: ( solo 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])

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

Explicación:

La cadena s:='====----/\/\/<><<>'junto con el bloque f:=[:c|s at:(s indexOf:c)+i]están aquí tanto para lanzar los caracteres como para invertir los patrones ...

• Para i = 1, realiza la reversión horizontal ( /<-> \, <<-> >).

• Para i = 3, realiza la reversión vertical ( /<-> \)

• Para i = 1 o 2 en Random, se lanza entre /o \, <o>

'=-/</-///'codifica el tipo de caracteres cque alimentará el bloque fpara las 9 primeras líneas.

#() , '=-/</-///' es un truco de concatenación para transformar la cadena en una matriz y, por lo tanto, recolectarla en una matriz.

El resto es simple concatenación después de aplicar la simetría horizontal / vertical.

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

Chirrido 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

O formateado:

|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

Explicaciones:

s:='==--/\<>'. obviamente codifica los cuatro pares posibles.

r:=(1<<108)atRandom. arroje 108 bits (en un LargeInteger) para 9 filas * 12 columnas (arrojamos el == y - sin necesidad, pero el rendimiento no es nuestro problema).

h:=''es la cadena donde concatenaremos (pintor Schlemiel porque una secuencia sería demasiado costosa en caracteres).

(16to:0by:-2),(0to:16by:2)do:[:i| está iterando en las filas (* 2)

(11to:0by:-1),(0to:11) do:[:j| está iterando en las columnas

28266es un número mágico que codifica el par que se utilizará en las primeras 9 líneas.
Es el patrón de bits 00 01 10 11 10 01 10 10 10, donde 00 codifica '==', 01 '-', 10 '/ \' y 11 '<>'.

101es un número mágico que codifica la reversión horizontal y vertical.
Es el patrón de bits 0000 0000 0110 1010, que codifica cuándo invertir (1) o no (0) el primer (0) o segundo (1) carácter de cada par '==' '-' '/ \' y '<>', para la simetría vertical y la simetría horizontal.

n:=3 bitAnd: 28266>>i proporciona la codificación del par de caracteres para la fila i / 2 (0 para '==', 1 para '-', 2 para '/ \' y 3 para '<>').

(r-1 bitAt: 6*i+j+1) seleccione el bit aleatorio para la fila i / 2 columna j (1 es el rango del bit más bajo, por lo tanto, tenemos un +1, k en el lanzamiento aleatorio en el intervalo [1, k], por lo tanto tenemos un -1).

(101 bitAt: 3-n*4+m+p) elija el bit de inversión: (3-n) * 4 es el desplazamiento para el grupo de 4 bits correspondiente al código de par n, m es el desplazamiento de reversión vertical (0 para los primeros 9, 2 para las últimas 9 filas), p es el desplazamiento de reversión horizontal (0 para los primeros 12, 1 para las últimas 12 columnas) +1 porque el rango de bits bajo es 1.

bitXor:realiza la reversión (responde un desplazamiento 0 o 1) y s at:2*n+1+bitXor_offsetselecciona el carácter correcto en s.

Pero (A>>a)+(B>>b) bitAnd: 1cuesta menos bytes que, (A bitAt:a+1)bitXor:(B bitAt:b+1)por lo tanto, el bitXor se reescribió y el desplazamiento +1 en p desapareció ...

h,#[13] es un chirrido feo, podemos concatenar una cadena con un ByteArray (que contiene el código para el retorno de carro).

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