이 문제를 해결하기 위해 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, 8의 제 12 개 문자 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.";

그런 다음 두 개의 절반과 단일 줄 바꿈이 프로그램 끝에서 자동으로 인쇄됩니다.

파이썬 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})

이는 문자열과 변환 소요 /\><로를 \/<>각각 그러나 나는 마침내 없애 관리했습니다 :)

파이썬 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);

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

?>

ungolfed 버전에는 약간의 보너스가 있습니다. 씨앗에 정수를 전달하고 씨앗에 rand()대해 매번 같은 퀼트를 얻을 수 있습니다 .

php quilt.php 48937

예를 들어,이 아름다운 손으로 짠 이불에서 결과는 다음과 같습니다.

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

편집 : 첫 번째 버전이 올바른 이불을 반환하지 않는 것으로 나타났습니다. 그래서 나는 고쳤다. 재밌지 만, 수정은 더 짧습니다.

자바 스크립트 (ES6) 169195 201

thx @nderscore에 저장된 6 바이트를 편집하십시오 . 백 따옴표 안의 줄 바꿈이 중요하고 계산됩니다.

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 바이트.

곧 설명하겠습니다.

여기에서 온라인으로 사용해보십시오.

파이썬 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])

설명이 필요하면 그냥 물어보세요.

자바 ( 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 atRandom의 경우 /또는 사이 \에< 또는>

'=-/</-///' 문자 유형을 인코딩 cf9 개의 첫 줄에 블록 을 공급할 을 .

#() , '=-/</-///' 는 문자열을 배열로 변환하여 배열로 수집하는 연결 트릭입니다.

나머지는 수평 / 수직 시메트리를 적용한 후 간단한 연결입니다.

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

que 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. 9 행 * 12 열에 대해 108 비트 (LargeInteger에서)를 던지십시오 (우리는 == 및-를 불필요하게 던지지 만 성능은 우리의 문제가 아닙니다).

h:=''우리가 연결할 문자열입니다 (스트림이 너무 비싸서 문자가 너무 많아서 Schlemiel 화가).

(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) 또는 두 번째 문자 (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] 못생긴 삐걱 거리는 소리입니다. 문자열을 ByteArray (캐리지 리턴 코드 포함)와 연결할 수 있습니다.

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