이다 캘빈 . 이 사용자가 PPCG Minecraft Server 대화방 에서 대화 할 수 있도록 20 명의 담당자를 얻으려고합니다 .

양의 정수를받는 프로그램이나 함수를 작성하십시오.

정수가 짝수 (2, 4, 6, ...) 인 경우이 정확한 ASCII 아트 문자열을 인쇄하거나 반환하십시오.

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |

정수가 홀수 (1, 3, 5, ...) 인 경우이 정확한 ASCII 아트 문자열을 인쇄하거나 반환하십시오.

                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

입력이 항상 양의 정수라고 가정 할 수 있습니다.

두 출력 경우 모두, 선택적으로 각 라인에서 "T"의 오른쪽 가장자리까지 및 / 또는 단일 후행 줄 바꿈 수에 제한이 없습니다. 각 문자 사이에 두 개의 공백 열이 있는지 확인하십시오.

바이트 단위의 가장 짧은 코드가 이깁니다.

자바 스크립트 (ES6) 343 336 289 267 265 260 바이트

그냥 재미를 위해 ... :) (46 바이트를 잘라 내고 다른 37을 자르도록 격려하는 Xufox에 감사합니다.)

n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')

a(4)또는 이와 유사하게 부름 . 여기에서보십시오 :

a=n=>`887141${n%2?`
98/202/05/4|3/29 1 /2|5|
 92/92/30 / 0--2|5|--/492/3|--3|
29/29/40/2013912|1|59/4|12_|_`:`3185121_
2/92/9409205/405/94|5|
 /29/2930 9 0--2|5|--94/193|--3|
/892029013912|392/492|5|`}`.replace(/\d/g,x=>+x?x<2?'__':x<9?' '.repeat(x):'\\':'|  |')
document.getElementById("a").innerHTML = "<pre>"+a(2)+"</pre>";
document.getElementById("b").innerHTML = "<pre>"+a(3)+"</pre>";

<p id="a"></p>
<p id="b"></p>

공백을 2~ 자릿수의 문자열로 압축했습니다 8(예 887: 23 공백). 그런 다음 각 숫자는 해당하는 수의 공백으로 바뀝니다. 0대표 | |및 1대표 __. 대체로이 프로그램은 결합 된 두 문자열 (203 + 227 = 430)보다 170 바이트 짧아서 행복합니다. :)

편집 : 어떻게 든,이 시점에서 유일한 다른 항목과 정확히 같은 길이입니다 .... o_o

편집 2 : 변경하여 공간을 저장 n%2<1?에 n%2?와 문자열을 교환. 또한 두 문자열의 시작이 동일하여 또 다른 5 바이트를 줄인다는 사실을 이용했습니다.

편집 3 : |2| 끔찍한 것처럼 보였으므로 각 발생을 단순화 x하여 7 바이트를 절약했습니다. Xufox의 제안은 또 다른 40 바이트를 차단했습니다.

편집 4 :\n 실제 줄 바꿈 으로 대체 할 Xufox의 제안 은 총 6 바이트를 제거합니다. 변경 x에 0와 __에 1그는 자신의 항목에서와 마찬가지로, 다음 (여기 정규식의 삽입 복수)을 모두 결합 (여기 사악한 웃음을 삽입), 추가로 16 바이트를 저장.

편집 5 : ES6 표준을 사용하기로 선택했기 때문에 사용자 지정 템플릿 문자열 보간을 사용하여 2 개의 최종 바이트를 줄였습니다.

MATLAB, 343 341

a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))

입력 번호는 stdin에서 제공됩니다.

샘플 실행 :

>> a=' -/\_|';
if mod(input(''),2)
x='003C00E00E000L0005N5000I000005550I0000I0055N4UVYO26R4004400400U005300UUXO060O060003C00C30CO00IO00UUUS060S5B54000';else
x='0I2000L0000L000E05H50C0000000555000C00C00H554UVYO26R4004400400U000250WUU006O006O0I2002I00O0I0O0C0UUU006S05BT0004';end
disp(a(reshape(dec2base(base2dec(reshape(x,[],7),36),6),4,[])-47))
1
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 

CJam, 158 149 145 138 바이트

li2%"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"281b7b"/
 -_\|"f=N/S3**_"_ ":T/TW%*4/zW%1m>N*1>"\/"_W%er"^W^]5OU"{i_32>T=t}/\4/zN*?

코드에는 인쇄 할 수없는 문자가 포함되어 있으므로 위의 캐럿 표기법을 사용합니다.

CJam 통역사 에서 온라인으로 사용해보십시오 .

브라우저에서 영구 링크가 작동하지 않으면 이 붙여 넣기 에서 코드를 복사 할 수 있습니다 .

예제 실행

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 6c69322522412bd772b585c6ffbba3ba6f5523fc2054159d5a653cc4ca4bded2a39b5757f835daeda7b9549aea65721eb0837dc30130523222323831623762222f0a202d5f5c7c22663d4e2f53332a2a5f225f20223a542f5457252a342f7a5725316d3e4e2a313e225c2f225f5725657222171d354f55227b695f33323e543d747d2f5c342f7a4e2a3f
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

생각

MINECRAFT 문자열 (일정한 줄 길이를 얻기 위해 채워짐)을 직접 인코딩하는 대신, 행과 열이 바뀐 "압축 된"버전의 문자열을 인코딩합니다.

줄 바꿈을 압축하고 제거한 후에이 문자열 ( R이라고 함 )을 인코딩해야합니다.

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_   

공백이 많이 있으므로 각 삼중 변이 줄 바꿈으로 바뀝니다.

이렇게하면 7 개의 다른 문자 ( \n -/\_|)가 남게 되므로 각 문자에 0 에서 6 까지의 숫자를 할당 하고 기본 7 숫자의 결과 배열 숫자를 고려한 다음 바이트 문자열로 인코딩합니다.

디코딩은 위의 단계를 반대로하여 작동합니다.

미러링 된 문자열은 원래 문자열로 구성 될 수 있습니다.

4 개의 행 순서를 반대로 바꾸고 soliduse를 바꾸면 다음과 같은 결과가 나타납니다.

\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 
                       __    __   __             __  ___

어쨌든 비슷하지만 맨 아래 줄을 맨 위로 가져 오려면 행을 명확하게 회전시켜야합니다.

                       __    __   __             __  ___
\        /  |  |  /|  |__   /__  |   /  \    /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \__/   |--   | 
  \/  \/    |  |/  |  |     \    |  |     \/    |     | 

그 성가신 밑줄이 아니었다면 그렇게 될 것입니다.

원래 문자열을 위에서 아래로 읽고 줄 바꿈을 무시하고 (따라서 R 을 얻음 ) 행을 이동하기 전에 각 밑줄과 공백을 공백, 밑줄로 바꿉니다.

                         _     _                      _ 
\        /  |  |  /|  |_    /_   |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

훨씬 낫다! 남은 일은 첫 번째 행의 첫 번째 공백을 삭제하고 (첫 번째 행의 모든 ​​밑줄을 한 문자 왼쪽으로 이동) E 와 C 에서 잘못 배치 된 밑줄을 한 행 위로 이동하고 밑줄을 T 이상 버리는 것 입니다.

암호

li2%           e# Read an integer from STDIN and push its parity.

"A+×rµ^ÅÆÿ»£ºoU#ü T^U^ÝZe<ÄÊKÞÒ£^ÛWWø5Úí§¹T^Úêer^^°^Ã}Ã^A0R2"

281b7b         e# Convert the byte string from base 281 to base 7.
"/\n -_\\|"f=  e# Replace each digit by its corresponding character.
N/S3**         e# Turn linefeeds into three spaces.
_              e# Copy the resulting string.
"_ ":T         e# Define T.
/TW%*          e# Replace occurrences of T with T reversed.
4/z            e# Split into chunks of length 4 and zip.
W%1m>          e# Reverse and rotate the rows.
N*             e# Join the rows, separating by linefeeds.
1>             e# Discard the first character.
"\/"_W%er      e# Swap the soliduses.
"^W^]5OU"      e# Push the string that corresponds to [23 29 53 79 85].
{              e# For each character:
  i            e#   Push its code point.
   _32>        e#   Push 1 iff the code point is larger than 32.
       T=      e#   Select the element at that index from T = "_ ".
         t     e#   Replace the element at the code point's index with that char.
}/             e#
\              e# Swap the partially generated MINECARFT string on top.
4/z            e# Split into chunks of length 4 and zip.
N*             e# Join the rows, separating by linefeeds.
?              e# Select the first string iff the input was odd.

Pyth-182 바이트

기본 인코딩 방식을 사용합니다. 인덱싱은 Pyth에서 모듈 식이므로 짝수를 위해 아무 것도 할 필요가 없으며 올바른 순서로 넣고 사용하십시오 @Q. 보너스로 이것은 음수에도 적용됩니다.

@mjbcs@L"_| /\\-"jCd6 56,"EWbòH\x00B)þK٣ĭIOõìæ«FFãbÐÄBØ\«¼,vã<RN>­º:w÷ò¾<éifP9e|ÉWf!FÔèà""EWbòH\x00B)þOHÿ$@ËþçX'D[¾«Â?°´=&£üá ¹»ázH×Æz3äkÕg{`!|ðY!ðGV"Q

첫 번째 코드 만 인코딩 한 다음 슬래시를 뒤집고 전환하려고했지만 첫 번째와 마지막 줄이 너무 어려웠습니다.

코드에 실제 null 바이트를 넣어 6 바이트를 절약 할 수는 있지만 너무 많은 문제가 있습니다.

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

출력 상자가 너무 작아서 줄 바꿈되어 온라인에서 실제로 나쁜 것처럼 보입니다. 나는 DEV-콘솔을 조롱하고을 변경하는 것이 좋습니다 col-md-5A를 col-md-7.

자바 스크립트 (ES6), 312, 285, 281, 272, 270, 263, 262, 260

이전 편집 내용은 편집 내역을 참조하십시오 .

편집 5 : 변환에서 -(현재 0) 및 공백 (현재 1)과 관련된 숫자를 전환했습니다 . 결과 블록에서 숫자 1, 2 및 3은 더 이상 사용되지 않았습니다. 이것은 누락 된 숫자가있는 배열을 사용할 수있게했습니다.

편집 6 : 배열 리터럴을 개선했습니다. 나는 이것을 이전에 시도했지만 숫자 대신 문자열로 사용 777했으며 77지금은 이것을 놓쳤다는 것을 알았습니다.

편집 7 : "골프 코드"는 질문에 지정된 기능 이므로이 f=사양을 충족시킬 필요가 없습니다 . 따라서 제거하여 두 바이트를 절약하십시오.

Firefox 39에서 실행 가능 :

// Testing:

f=

// Golfed code:

n=>[...`11111113ss17ss1pp11117pp3ppp
97dj3dj7822j78z213e17z3v8397gm78212
7f3kf3k1z27k7z20021200k17fppk1z001z
d7983987j2287jz2ss1lss2aabj3d7987j2aa3aza`.replace(/[123]/g,x=>[,777,'77z',77][x])].map(a=>isNaN(i=parseInt(a,36))?a:'- /\\_|'[n%2?i%6:~~(i/6)]).join``

// Testing:

;document.body.appendChild(document.createElement('pre')).innerHTML=f(0);
document.body.appendChild(document.createElement('pre')).innerHTML=f(1);
document.body.appendChild(document.createElement('pre')).innerHTML=f(2);
document.body.appendChild(document.createElement('pre')).innerHTML=f(35);

기본 6 숫자 시스템을 기반으로하며 각 ASCII 문자는 숫자를 나타냅니다.

"-": 0
" ": 1
"/": 2
"\": 3
"_": 4
"|": 5

그런 다음 각 ASCII 문자열의 숫자 표현을 결합했습니다. 예를 들어 제 ASCII 문자열이 포함 된 경우에 /한 위치와 다른 하나 포함 \에서 동일 위치 , 그 위치가된다 32((6) 인 20진수). 이것을 기수 36으로 변환하면 ( 두 기수 -6 수 마다 하나의 기수 36 번호를 얻음)을 얻습니다 .k

이 모든 작업은 사전에 수행되었으며 기능은 기본적으로이 프로세스를 취소합니다.

이제 두 개의 JavaScript 응답은 각각 서로 다른 바이트 수를 가지며 다른 바이트 수를 갖습니다.

추신 : 나 자신에 대한 메모 및 다른 사람들에 대한 참조로, 이것은 내가 사용한 코드입니다.

// 1. ASCII here
a=`|\\-/ _`;

// 2. ASCII here
b=`/|\\_ -`;

// Note: the ASCII strings’ backslashes have to be escaped!

[...a]
  .map((c,i)=>parseInt((c+b[i])
    .replace(/-/g,'0')
    .replace(/ /g,'1')
    .replace(/\//g,'2')
    .replace(/\\/g,'3')
    .replace(/_/g,'4')
    .replace(/\|/g,'5'),6))
  .map(c=>isNaN(c)
    ?`
`
    :c.toString(36))
  .join``
// Returns "wn3g7o", which is then put into the function as the block at the top.

CJam, 136 바이트

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^à 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"
265b8b[S9*'|3*+S2*]"/-_\| "+f=s4/56/ri=zN*

코드에는 인쇄 할 수없는 문자가 포함되어 있으므로 위의 캐럿 표기법을 사용합니다.

줄 바꿈은 "가독성"만을위한 것입니다. CJam 통역사 에서 온라인으로 사용해보십시오 .

브라우저에서 영구 링크가 작동하지 않으면 이 붙여 넣기 에서 코드를 복사 할 수 있습니다 .

예제 실행

$ LANG=en_US
$ xxd -ps -r > minecraft.cjam <<< 220153d338a5c8f70bafbe2f08d53284cb316ad2dd048130ee6c3b294852a7fb7c8a9e87ddc59f4e6c7a1466d1986a3ec08320342362485cbf84eeb7edec05017e28bff8b328fab42c8828a16a3ee83f2327bb76e750ef6a75383729d7223236356238625b53392a277c332a2b53322a5d222f2d5f5c7c20222b663d73342f35362f72693d7a4e2a
$ cjam minecraft.cjam <<< 2; echo
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     | 
$ cjam minecraft.cjam <<< 1; echo
                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

생각

이 접근법은 내 다른 대답 과 비슷한 점이 있지만 훨씬 간단하고 실망 스럽습니다.

다음 문자열을 인코딩하는 방법을 검색합니다.

                       __    __   __             __  ___                       __    __                         
  /\  /\    |  |\  |  |     /    |  |     /\    |     | \        /  |  |  /|  |     /    |   /  \ __ /  |     | 
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |  \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | 
/        \  |  |  \|  |__   \__  |   \  /    \  |     |   \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

일정한 행 길이를 달성하기 위해 각 행을 채우고 압축하고 (행과 열 변환) 줄 바꿈을 제거한 후에이 문자열을 인코딩해야합니다.

   /  /  /   \    \   /  /   \    \    \         |||         ||| \    \    \ |||         |||_ -__ -_          |  / \_  __  _         |||_ - _ -  |\    \           /  /  /_  \_   \    \         |||_ - _ -         _   _|||_    \    \    \   /  /   \    \   /  /  /           |||         |||   /  /  /   |||         |||_ -__ -_          |  / \_  __  _         |||  -_  -_  /| /           \    \  _ \ _ /  /  /           |||  -_  -_           _ |||   _

우리는 각각 대체 문자열 것이다 " |||"A의 0 , 각각의 문자열 " "A의 1 과의 문자 "/-_\| "와 2 행 7 바이트의 문자열로 인코딩 될 수있는베이스 (8) 숫자의 배열을 형성한다.

디코딩은 위의 단계를 반대로하여 작동합니다.

암호

"^ASÓ8¥È÷^K¯¾/^HÕ2^ÄË1jÒÝ^D^Á0îl;)HR§û|^Ê^Þ^ÇÝÅ^ßNlz^TfÑ^Øj>À^à 4#bH\¿^Äî·íì^E^A~(¿ø³(ú´,^È(¡j>è?#'»vçPïju87)×"

265b8b        e# Convert from base 265 to base 8.
[S9*'|3*+S2*] e# Push ["         |||" "  "].
"/-_\| "+     e# Concatenate to push ["         |||" "  " '/' '-' '_' '\' '|' ' '].
f=            e# Select the elements that correspond to the base 8 digits.
s4/           e# Flatten and chop into chunks of length 4 (columns).
56/           e# Chop into two subarrays of 56 columns.
ri            e# Read an integer from STDIN.
=             e# Select the corresponding subarray.
              e# Arrays wrap around, so [A B]0= eq. [A B]2= and [A B]1= eq. [A B]3=.
zN*           e# Zip and join the rows, separating by linefeeds.

라켓, 443 434 386 바이트

(require file/gunzip net/base64)(define(f n)(define o(open-output-bytes))(gunzip-through-ports(open-input-bytes(base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))o)(list-ref(string-split(get-output-string o)"a")(modulo n 2)))

차기 위해.

(require file/gunzip net/base64)
(define (f n)
  (define o (open-output-bytes))
  (gunzip-through-ports
   (open-input-bytes
    (base64-decode #"H4sIAK8Lt1UAA22Q3Q3AIAiE352CBcwtRHLpHg7f8lubahRUDuVD5DjItrH9REgOEWgskfVMDeca1GWcSmN2WFBtlUTdzdmSOT0BpEpGnjxUAf2RmvPq1OyKGF6N5V1nvgYcWjeod/Hj8JotBRtH0qM48OeoWrBxJH23KL/dOMh4IDXe8MUbT1AqtKkBAAA="))
   o)
  (list-ref (string-split (get-output-string o) "a") (modulo n 2)))

NB #lang racketDrRacket에서 라인을 실행 해야 할 수도 있습니다 .

05AB1E , 179 (177) 176 바이트

"
 -/\_|"•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huѦ%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆ˲’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•7вèJ2äIè

온라인으로 사용해보십시오.

설명:

•ÿ%Ò´Åçδ’Üå·Äm…½µƵδø5)ǝ®∊∊Ý®þCĀ₆áÝoþ²ši¤Æ%ßû¤%¦Ï≠θĀ5¾₃ʒŸQ>Šn°η8±8d¸6':…é’b…÷‡ö©«&‡huѦ%λÁZÊJÌ₅ú∞°»ó₄ι«ÓW´×ƒ×ùqiò2D1āwθóÆ˲’
Tι#и∊²ý‚KʒFæΩZºÿÏ";ηiʒæøвøïž‚è°ć½∊•

는 IS 압축 번호 :

669530978249988431396781816197276307266403407188962925862194299697873953319419752813246251351417090709766331736351616127424760949905163941809417778114834562736028512279028673309866195447599979612590918985644583407413903825059942009898007791080822453262749380245316127735585410697701790387188175543639634091138422651942833048832372950797322005040161476426127678479662921265139425

온라인으로 사용해보십시오.

7в 이것을 목록으로 Base-7로 변환하므로 숫자 목록을 얻습니다.

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,5,5,5,0,1,1,3,4,1,1,3,4,1,1,1,1,6,1,1,6,4,1,1,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,6,1,1,1,1,1,3,4,1,1,1,1,6,1,1,1,1,1,6,0,1,3,1,1,4,3,1,1,4,1,1,1,6,1,1,6,1,4,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,4,1,1,1,1,3,5,5,4,1,1,1,6,2,2,1,1,1,6,0,3,1,1,1,1,1,1,1,1,4,1,1,6,1,1,6,1,1,4,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,1,1,1,4,1,1,3,1,1,1,1,4,1,1,6,1,1,1,1,1,6,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,5,5,1,1,1,1,5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,4,1,1,1,1,1,1,1,1,3,1,1,6,1,1,6,1,1,3,6,1,1,6,1,1,1,1,1,3,1,1,1,1,6,1,1,1,3,1,1,4,1,5,5,1,3,1,1,6,1,1,1,1,1,6,0,1,4,1,1,3,4,1,1,3,1,1,1,6,1,1,6,1,3,1,6,1,1,6,2,2,1,1,6,1,1,1,1,1,6,2,2,3,1,1,1,1,4,1,1,3,1,1,1,6,2,2,1,1,1,6,0,1,1,4,3,1,1,4,3,1,1,1,1,6,1,1,6,3,1,1,6,1,1,6,5,5,1,1,1,4,5,5,1,1,6,5,5,6,1,1,1,1,1,4,3,1,1,1,1,6,5,5,1,1,5,6,5]

온라인으로 사용해보십시오.

è인덱스 각각의 문자열에 자리 "\n-/\_|"하고, J그 다음 우리에게주는 다음되는, 함께 전체 목록을 조인

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |                       __    __                        
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

온라인으로 사용해보십시오.

2ä문자열을 두 부분으로 나눕니다.
Iè입력을 가져 와서 인덱싱 (자동 랩 어라운드)하여 두 부분 중 하나를 가져 와서 암시 적으로 출력합니다.

압축 번호와 Base-7 음역을 생성하는 데 사용 된 @MagicOctopusUrn 의 ASCII 압축기 덕분에 큰 도움 이되었습니다. 온라인으로 사용해보십시오. (그 후 음표 를 숫자 목록으로 만드는 в대신 에 문자열과 숫자를 반대로하여 음역을 골프화하여 B로 문자열을 색인화합니다 è.

C, 251 바이트

k(w){char*f="_-/\\|]^^^\0<&*&)&3&(&&WX&J&*&\0t_&/&3&\0`);35)I5M\0a).@7).8-;./.-\0j()(0(1+4()(*+4+4()(04+",*o=f+4,m[229]="",i=7,c=10,p;for(memset(m,32,228);i;c=*f++^(w%2&i--/2==2)*115)for(p=0;*++o;m[(w%2?4-i/6-p/57:p/57)*57+p%57]=c)p+=*o-37;printf(m);}

k매개 변수를 수신하고에 메시지를 인쇄 하는 기능 입니다 stdout.

더 읽기 쉬운 버전 :

k(w)
{
    char*f="\n_-/\\|", // characters to fill in
        *o= " "// for each character, the list of positions to put it in, difference-encoded
        "]%%^^^\0"                  // for '\n' (newline)
        "<&*&)&3&(&&WX&J&*&\0"      // for '_' (underscore)
        "t_&/&3&\0"                 // for '-' (minus)
        "`);35)I5M\0"               // for '/' or '\' (slashes)
        "a).@7).8-;./.-\0"          // for '\' or '/' (slashes)
        "j()(0(1+4()(*+4+4()(04+",  // for '|' (vertical bar)
        m[229]="",  // message to generate
        i, // index of character, running 7...1
        c, // current character to fill in
        p, // where to place the character
        y; // y-coordinate of the character

    memset(m,32,228); // fill the message with spaces
    for(i=7;--i;)
    {
        c=*f++;
        c^=~w%2|i/2^1?0:115; // flip the direction of slashes, if needed
        for(p=0;*++o;)
        {
            p+=*o-37; // jump to next position
            y=p/57; // extract the y-coordinate
            y=w%2?4-i/5-y:y; // flip the y-coordinate, if needed
            m[y*57+p%57]=c; // place the character
        }
    }
    printf(m); // print the message
}

먼저 빈 메시지 (공백으로 채워짐)를 준비합니다. 각 캐릭터 (예 : |또는 -) 마다 해당 캐릭터를 배치 할 위치 목록이 있습니다.

각 위치마다 거꾸로 된 버전을 인쇄해야 할 경우 위치가 뒤집 힙니다. 즉, 수직 좌표 y는 4-y또는 3-y문자로 밑줄인지에 따라 또는 로 바뀝니다 . 또한 슬래시의 방향이 반전 XOR됩니다 115. 이는 with 로 수행됩니다 .

이 제어 구조는 개행 문자를 배치하는 데에도 사용됩니다. 명시 적 루프를 작성하는 것보다 목록에 4 개의 좌표를 추가하는 것이 더 효율적입니다.

이 시스템에는 몇 가지 사소한 결함이 있습니다. 우선, 최종 문자 T는 뒤집힌 버전에서 약간 다르게 보입니다.

___ 
 |    |
 |    |
 |   _|_

올바르게 출력하려면 코드는 |문자 뒤에 문자 를 배치 해야 _합니다.

또한 제어 문자열에 ASCII 문자 만 포함되도록하기 위해 인코딩했습니다.

• 위치 자체 대신 위치 간의 차이를 기록합니다.
• 문자열의 숫자가 37추가되어 ASCII 범위 32 ... 127로 이동합니다. 더 작은 숫자를 추가 할 수 있지만 문자열 리터럴 내에서 이스케이프되어야하는 and와 37같은 문자는 피하십시오 ."\
• 숫자 중 두 개가 127보다 컸습니다. 예를 들어 첫 번째 -문자는 위치 137에 나타납니다.이를 설명하기 위해 -나중에 다른 위치 (79)에 인공 문자를 추가했습니다.이 문자는 나중에 덮어 씁니다.이 문자 |는 위치 79에도 나타납니다.

또 다른 재미있는 점은 puts문자열을 출력하는 데 사용할 수 없다는 것입니다. 이로 인해 추가 줄 바꿈이 생성됩니다. 그래서 printf대신 사용 했습니다.

또한 57골프 코드에서 숫자 가 4 번 나타납니다. 긴 감기 표현 (w%2?4-i/6-p/57:p/57)*57+p%57은 변수를 제거 y하여 코드를 더 짧게 만듭니다.

펄, 292 259 246 바이트

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hw|j h|wS /SwrhSi pq hwS |
 mSlmSlS |S| l |S|--wS |--lSSmnnlS |--S |
k ihSih jw|h j|S|__S g__S|oosjSk ih jS|ooSo|o";s/v/SSSSS/g;s/w/S|S/g;s/S/  /g;<>&1?y"g-s"\\/\\  /\\ ___ |":y"g-s"\\  \\/\\/_ /\\| ";print $_

두 문자열이 대부분 비슷하므로 (예 : 전체 IE 및 C), 표시되는 버전에 따라 다르게 표시되는 문자로 문자열을 만듭니다. 예를 들어, m은 "오른쪽 문자열의 경우 슬래시, 거꾸로 된 문자열의 경우 슬래시"를 의미합니다. 음역 대체를 수행하여 올바른 문자를 표시합니다. 공백은 문자열 대체를 사용하여 실행 길이로 인코딩됩니다.

여러 줄 :

$_="Svv __SS__S nnSv nnSnnn
i kjSkj hS|S|j h|S|SS /SS|SrhSi pq hS|SS |
 mSlmSlS |S| l |S|--S|SS |--lSSmnnlS |--S |
k ihSih jS|S|h j|S|__S g__S|oosjSk ih jS|ooSo|o";
s/v/SSSSS/g;
s/w/S|S/g;
s/S/  /g;
<>&1?
    y"g-s"\\/\\  /\\ ___ |"
:
    y"g-s"\\  \\/\\/_ /\\| ";
print $_

생각:

출력에는 22 개의 고유 한 열만 있기 때문에 56- 문자 조회와 함께 0-17 범위 (가능한 모든 "이중 의미"문자)의 22 * ​​4 = 88 자로 저장할 수 있어야합니다. 열당 0-21 범위의 항목이 하나있는 테이블. 이론적으로 이것은 100 바이트 미만으로 인코딩 될 수 있지만 디코딩하기가 더 복잡한 코드로 인해 순 승리로 만들기는 어렵습니다.

CJAM, 206

두 개의 ASCII 그림은 base-216로 인코딩되며 1 바이트 = 3 자입니다.

" _\/|-":A;S7*"!D!D"+:B;qi2%{B"h  °°¤8 2 °2,J° °"",4# °³8=Ô° Ó\"# Ó °""\"z °Â89D-D·° z ·!¶"}{B"'    '!J"+"#h °¼88 2 °°  ° °""2/\" °²8=Ô° Óh#L Ó °""  h°°9D-D°,2 h° °"}?]{{i32-__36/A=@6/6%A=@6%A=}/N}/

여기에서 테스트

파워 쉘, 275 253 248 바이트

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

테스트 스크립트 :

$f = {

param($n)$d='8 \83484/7/484302 92984308 92918--118--128||6//0\16116129558| \/ |8 /02083\6/10018/6\302 955776_71 9_7_'
'8\,__,777,/6 /,\6/6\,_8 -- _,88,888,  ,||||||'-split','|%{$d=$d-replace+$i++,$_}
0..3|%{$l=$_;-join$d[(0..55|%{$_*8+$l*2+$n%2})]}

}

&$f 2
&$f 1

산출:

                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

주요 내용

압축 방법은 Dennis ♦ 의 CJam 확장 방법입니다 .

1. 압축하기 전에 문자열을 작성하십시오.
   • 두 ASCII 아트의 첫 번째 열의 문자
   • 두 번째 열의 문자
   • 세 번째 열의 문자 등 ...
2. 10 개의 연속 교체를 사용하여 압축합니다 (Powershell은 숫자 0..9를 문자열로 사용할 수 있기 때문에 압축 해제 알고리즘이 더 짧아집니다.

압축 스크립트 :

$src =
"                       __    __   __             __  ___", # line1, art1
"                       __    __                         ", # line1, art2
"  /\  /\    |  |\  |  |     /    |  |     /\    |     | ", # line2, art1
"\        /  |  |  /|  |     /    |   /  \ __ /  |     | ", # line2, art2
" /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   | ", # line3, art1
" \  /\  /   |  | / |  |--  |     |--/    \  /   |--   | ", # line3, art2
"/        \  |  |  \|  |__   \__  |   \  /    \  |     | ", # line4, art1
"  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_"  # line4, art2

$z=-join(0..$src[0].Length|%{
    $p=$_
    $src|%{$_[$p]}
})
$z

압축 전 문자열은 다음과 같습니다.

   \  /     /\    /    \  \    /    \/      /\    /    \  \    /    \/     /  \                   ||||||                  ||||||  \    /    \/     /  \   ||||||          ||||||__  --____  --__                    ||    //  \\__    ____    __                  ||||||_   -- __   -- _  | \/ |   /  \                    \  /     /\  /__  \  \__  /    \/     /  \                   ||||||_   -- __   -- _                _      __ ||||||_      _

SAS, 442 바이트

%macro a(b);&b=tranwrd(&b,put(i,1.),repeat('A0'x,i));%mend;%macro b(z);length a b c d$99;if mod(&z,2)then do;a='992__3__';b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';end;else do;a='992__3__2__65__1___';b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';end;do i=0to 9;%a(a)%a(b)%a(c)%a(d)end;put a/b/c/d;%mend;`

골퍼가 아닌 :

%macro a(b);
  &b=tranwrd(&b,put(i,1.),repeat('A0'x,i));
%mend;

%macro b(z);
length a b c d$99;
if mod(&z,2)then do;
  a='992__3__';
  b='\7/1|1|1/|1|4/3|2/1\0__0/1|4|';
  c='0\1/\1/2|1|0/0|1|--1|4|--/3\1/2|--2|';
  d='1\/1\/3|1|/1|1|__2\__1|__|4\/3|__1_|_';
end;
else do;
  a='992__3__2__65__1___';
  b='1/\1/\3|1|\1|1|4/3|1|4/\3|4|';
  c='0/1\/1\2|1|0\0|1|--1|4|--\3/__\2|--2|';
  d='/7\1|1|1\|1|__2\__1|2\1/3\1|4|';
end;
do i=0to 9;
  %a(a)
  %a(b)
  %a(c)
  %a(d)
end;
put a/b/c/d;
%mend;

테스트 :

data a;
  %b(1)
  %b(2)
  %b(0)
  %b(35)
run;
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __   __             __  ___
  /\  /\    |  |\  |  |     /    |  |     /\    |     |
 /  \/  \   |  | \ |  |--  |     |--\    /__\   |--   |
/        \  |  |  \|  |__   \__  |   \  /    \  |     |
                       __    __
\        /  |  |  /|  |     /    |   /  \ __ /  |     |
 \  /\  /   |  | / |  |--  |     |--/    \  /   |--   |
  \/  \/    |  |/  |  |__   \__  |__|     \/    |__  _|_

입력 블록에 코드를 넣음으로써 약간의 코드를 저장할 수는 있지만 매크로가 매크로로 작성하는 정신을 위반한다고 느끼는 데이터 단계 당 한 번만 매크로가 될 수 있다는 제한을 추가합니다. (그리고 데이터 단계에 입력하라는 메시지를 추가하면 더 많은 문자가 추가됩니다)

bash, 247 바이트

(($1%2)) && c=tail || c=head
base64 -d <<<H4sIAF/3uFUCA31Q2w3AIAj8ZwoWMLcQyS3i8JWXtWlTI6BwPA7Vz0Nunc9HhKSowlJU57qWJjBoZ/4a41o8aC4NsTBjbMgYkQDStCIrDz3AbmRuYjpzPTOGG5P9/gmKtQddFy8eMbOn4Khb7NE88ObRs+DgUez3iqrtwYPMAoWJhU/KBeJFPOCqAQAA | zcat | $c -n4

문자열이 연결되고 압축됩니다.

PHP, 225 바이트

미운, 무차별 대입 솔루션.

echo str_split(gzinflate(base64_decode('dZDdDcAgCITfnYIFzC1Ecos4fOW3Nm2NgsohfIp8DrJtbB8RkkMEGktk7anhXIO6jFNpzA4Lqq2SqLs5WzKnJ4BUycjOQzXQhdScd6dmV8Rwa7rqP9/QukE9ixeGt2wpODASHoWBN0a1ggMj4fuHsuyBQcYDqfH/XrwA')),224)[$argv[1]%2];

압축 한 다음 표시 할 연결된 문자열을 base64로 인코딩했습니다. 이 코드는 코드를 해독하고 압축을 풀고 224 자로 분할합니다. 첫 번째 문자열은 후행 줄 바꿈이없는 224 자이고 두 번째 문자열은 201 자입니다 (또한 줄 바꿈 없음). 명령 행 인수 ( $argv[1]%2) 의 패리티는에 의해 생성 된 배열에서 색인으로 사용됩니다 str_split().

하스켈, 138 바이트

m x=do
 h<-readFile"a"
 return$take 225.drop(225*mod x 2)<$>find((==h).hash.pack)(replicateM 425"/\\|_- ")

이것은 약간의 해킹입니다. 두 개의 마인 크래프트 텍스트의 연결에 대한 SHA256 해시를 무차별 처리 한 다음 분리하여 매개 변수 x를 기반으로 적절한 텍스트를 선택합니다. 이것은 매우 비현실적이며 실시간으로 계산할 수 없으며 내가 아는 모든 과정에서 충돌이 발생할 수도 있습니다.

Haskell은 문자열에서 해당 해시의 ASCII 표현을 가질 수 없으므로 "a"라는 파일에서 읽었으며 32 바이트를 내 점수에 추가했습니다.

• readFile 및 팩은 Data.ByteString.Char8에서 가져옵니다.
• 해시는 Crypto.Hash.SHA256에서 가져온 것입니다.

설명 :

replicateM 425"/\\|_- "

425 자의 글자 "/ \ | _-"의 모든 조합 목록을 만듭니다 (두 마인 크래프트 텍스트의 길이가 합쳐 짐)

find((==h).hash.pack)

해시와 일치하는 첫 번째 것을 선택하십시오.

take 225.drop(225*mod x 2)

첫 번째 텍스트는 225 자이며 다른 텍스트는 정확히 200 자입니다.

자바 스크립트 (ES6), 403 296 바이트

( 이전 답변 에서 이동 ) 새로운 방법을 시도해보십시오.

n=>`55555559Å9Å${n%2?`55555558556776}}5Y75Y¥Æ75786¡YAA[7ćA5Fï5¡YFéA8Y§5}\x83AEÅKÅ\x99}5§5\x999\x95`:`Q5555Q9Ý>6¡77¡}}5Y7756¡75768Y¡AA£7ćA5Fû5u¡FéAY55¡}}­EÅKÅ}G;5¡}5}`}`.replace(r=/./g,x=>(163+x.charCodeAt()).toString(6).slice(1)).replace(r,x=>' /|\\_-'[x]).match(/.{56}/g).join`
`

인쇄 할 수없는 문자가 몇 가지 있습니다. 이들은 예를 들어로 대체되었습니다 \x83.

인코딩 자체는 다른 것보다 약 40 바이트 짧지 만 디코딩 프로세스는 더 정교합니다. 다른 사람들이 텍스트를 인코딩하는 데 사용한 base-216 시스템을 사용했습니다. 참고로 내가 사용한 코드는 다음과 같습니다.

// normal MINECRAFT
a='00000000000000000000000440000440004400000000000004400444'+
  '00130013000020023002002000001000020020000013000020000020'+
  '01003100300020020302002550020000025530000144300025500020'+
  '100000000300200200320024400034400200030010000300200000200';

// upside-down MINECRAFT
// un-comment this one to run it
/*
a='00000000000000000000000440000440000000000000000000000000'+
  '30000000010020020012002000001000020001003044010020000020'+
  '03001300100020020102002550020000025510000300100025500020'+
  '003100310000200210020024400034400244200000310000244004240';
*/

console.log(a.replace(/.../g,x=>String.fromCharCode(parseInt(b[i],6)+53)));

기본적으로 ASCII 텍스트 (기본 6으로 사전 변환 됨)를 가져 와서 세 배로 늘려서 기본 216으로 변경합니다. 그런 다음 인쇄 할 수없는 대부분의 문자를 제거하기 위해 53이 추가됩니다.

제안을 환영합니다!

원래 403 바이트 코드는 다음과 같습니다.

a=n=>{y=[' ','/','|','\\','_','-'],x=`55555559Å9Å${n%2?`55555555¡55Y}}eA5;5};GÝY}5}¡k;77;} 757Ĉ5G;7ć75§H5AB77Ý8ÝEÑ5H5EÅÕ`:`Q5555Q9Ý6¡k5}\u008FAA5;5}}5k5}5}Y§G77G} 757Ċ5?×7ć7;55GAAI7Ý8ÝA865GA5A`}`;b=x.split('').map(x=>x.charCodeAt(0)-53);for(c=[],i=b.length;i--;){c[i]=b[i].toString(6);while(c[i].length<3)c[i]='0'+c[i]}d=c.join('').replace(/\d/g,x=>y[x]).split('');d[56]=d[112]=d[168]=`
`;return d.join('')};

사용하여 for반복하는 while루프, 한 번만 사용 된 네 개의 변수, 간단한 것들에 대한 긴 알고리즘의 톤. 소년, 나는 개선했다 ...

파이썬, 312 바이트

def y(b):
 x=int(['4vwhclv10tuk4z18gf73aimn6zvwkrhxekphfn1lxocj9ezchd1cd1cv97p3f6k12s8hcjznnm5iq3om4vgxvugp3makgu4n3f6qxvdrtl4c0lva12hwt','8uzwdylhtrf6oqnwnck8pfxu25m5844tuo2700v3zoeuvossx1b47rnwyrmqodau3feu3spi9jydhyxvntv48vojx9iq9af78wufzn1'][b%2],36);x<<=69;s="";t=" /\\-|_\n"
 while x:s+=t[x&7];x>>=3
 print s

함수는 int 주어진 출력을 인쇄합니다

C, 321 바이트

반복과 문자 색인을 문자열로 인코딩했습니다.

main(n,v,p,c)char**v,*p,*c;{c=" _/\\|-\n";for(p=atoi(v[1])%2?"8@8iXivs8rhththrthtPrXt`rhspiprhtPtvpshrshr`thtprpthtmhtPtmrXshr`tm`tvhsrhsrXthtrhthti`sihtitPsrXtihqtq":"8@8iXi`i8PihavhrshrsXthtshthtPrXthtPrsXtPtvprhsrhs`thtpspthtmhtPtmsXris`tm`tvr8shththsthti`siht`shrXshtPtw";*p;p++)for(n=*p/8^15;n--;)putchar(c[*p&7]);}

파이썬 3, 486 (533) (612)

r=str.replace;m,p=r(r(r('''YYYYY   __YA AYY   A___
  /\  /\YX\  X Y/YX Y/\Y| Y|
 /  \/  \   X \ X--  | Y|--\Y/__\   |--   |
/YY\  X  \XA \A|   \  /Y\  | Y| ''','X','|  |'),'Y','    '),'A','__  '),print;
if int(input())%2==0:p(m)
else:
 q,i,u=m.split('\n')[::-1],0,[[23,24,29,30],[42,43],[],[23,24,29,30,34,35,53,49,50,55]];q.insert(0,q.pop())
 while i<len(q):
  x=list(r(q[i],'_',' '))+[' ']
  for a in u[i]:x[a]='_'
  p(r(r(r(r(''.join(x),'___',''),"\\",'t'),'/',"\\"),'t','/'))
  i+=1

PHP , 263 바이트

<?=strtr('3333 20220'.['2 0332 020_
2/\2/\211\113/2113/\212 1
 /2\/2\ 11 \ |1412 14\22/0\ 14 1
/32 \112\|102 \012 \2/22\12 1',
'
\32 /112/|13/212 /2\ 0 /12 1
 \2/\2/ 11 / |1412 14/22\2/ 14 1
2\/2\/211/1102 \010|3\/2102_|_'][$argn&1],[__,"  |","  ","     ","--"]);

온라인으로 사용해보십시오!

루비, 290 바이트

$><<(gets.to_i%2<1?"xCeCdCnCcC_
c/Bc/Be|ABAAf/e|Af/Be|f|
b/cB/cBd|AbBb|A--Af|--Be/CBd|--d|
/iBAAcB|ACdBCAdBc/eBAf|":"xCeC
Bi/AAc/|Af/e|d/cBbCb/Af|
bBc/Bc/d|Ab/b|A--Af|--/eBc/d|--d|
cB/cB/e|A/AACdBCAC|fB/e|Cc_|_").gsub(?C,'__').tr(?B,?\\).gsub(?A,'c|').gsub(/[a-z]/){|e|' '*(e.ord-97)}

아마도 약하고 즉흥적으로 진입했을 것입니다. 기본적으로 소문자가 많은 공백 (실제로 ord (ch)- 'A'공백)과 대문자가 몇 바이트를 절약 한 일반적인 용어임을 의미하는 매우 간단한 (수제) 압축입니다.

SOGL V0.12 , 72 71 바이트

═j;ΗD^⌡⁾yō⁶⅜┐≡¼τ~≡š┘,┼◄‚4øDqψ∫‛²′Ζdκ↓±ģ░○∙ΘΝ◄ōΞ06║⁶╗i-η}┌^JY³‘''n.2%?№↕

여기 사용해보십시오!

SOGL의 수직 미러링은이를 위해 완벽하게 작동했습니다.

캔버스 , 70 바이트

Ｃ＜aT［≤＾５ｔ‽◂6Ｚｒ!ｖ↓［ｕ0F∙ＯＦ－╫＃ｔ┬ａ*７ＺfK1!&)y＠½（＋M⇵ＰV-¼G:Ｕju╋╷(╫:N‟‾)ｎ⁸２％？↕

여기 사용해보십시오!