Funciton , 비경쟁, 29199 바이트
나는 매우 유용한 라이브러리 함수의 아픈 부족을 강조했기 때문에이 도전을 즐겼다. 이 챌린지가 게시 된 후에 함수를 작성 했으므로 모든 함수를 여기 (및 바이트 수)에 포함시킬 것입니다.
단일 파일의 전체 소스
설명
항상 그렇듯이 javascript:(function(){$('pre,code').css({lineHeight:5/4});})()브라우저 콘솔에서 실행하여 더 나은 렌더링을 얻으 십시오.
① ɹ ⇄역전
알다시피 또는 모르는 것처럼 Funciton에는 list 에 대한 함수로 가득 찬 라이브러리가 있습니다.이 함수 는 단일 humongous 정수로 인코딩 된 값이며 지연 평가 시퀀스에 대한 별도의 라이브러리이며 람다 식 (익명 함수)을 사용합니다. 게으르다. 물론 문자열 처리 기능을위한 라이브러리도 있습니다.
이 문제를 해결하기 위해 문자열을 반전시키는 함수와 지연 평가 시퀀스를 반전시키는 함수가 필요했습니다. 놀랍게도, 나는 목록에 대해 하나만 가지고있었습니다 – 정확히 내가 필요하지 않은 것입니다. 지연 시퀀스 ( ɹ)와 문자열 ( ⇄)의 역함수는 다음 과 같습니다.
╓───╖ ╔════╗ ┌────╖ ╓───╖
║ ɹ ║ ║ 21 ╟─┤ >> ╟──┐ ║ ⇄ ║
╙─┬─╜ ╚════╝ ╘═╤══╝ │ ╙─┬─╜ ┌──┐
┌─────┴─────┐ ┌─┴─╖ ├───────┴────────┤ │
┌─┴─╖ ┌───╖ │ │ ⇄ ║ │ ╔════╗ ┌───╖ │ │
┌─┤ ╟─┤ ɹ ╟─┐ │ ╘═╤═╝ │ ║ −1 ╟─┤ ≠ ╟─┴┐ │
│ └─┬─╜ ╘═══╝ │ │ ┌─┴─╖ ┌─┴─╖ ╚════╝ ╘═╤═╝ │ │
│ │ ┌───╖ │ │ │ ‼ ╟─┤ ? ╟──────────┤ │ │
│ └───┤ ʬ ╟─┘ │ ╘═╤═╝ ╘═╤═╝ ╔═══╗ ┌─┴─╖ │ │
│ ╘═╤═╝ │ ┌─┴─╖ ╔═══╗ ║ 0 ╟─┤ ≠ ╟──┘ │
│ ╔═══╗ ┌─┴─╖ │ ┌─┤ ʃ ╟─╢ 1 ║ ╚═╤═╝ ╘═══╝ │
└─╢ 0 ╟─┤ ? ╟───┘ │ ╘═╤═╝ ╚═══╝ │ │
╚═══╝ ╘═╤═╝ │ └────────────┘ │
│ └─────────────────────────────┘
"게으른 시퀀스 ʬ의 끝에 요소를 추가하는"을 사용 하는 지연 시퀀스. 하나는 ʃ(하위 문자열)과 ‼(문자열 연결)을 사용합니다.
② Ṗ프라임
n 을 모든 요인으로 순서대로 나눠서 소인수 분해를 수행 할 수 있었지만 소수 를 생성하는 라이브러리 함수를 원했습니다. 다음 함수는 정수 n을 취하고 에라토스테네스 의 체를 구현하여 n 까지의 모든 소수를 생성합니다 . 이 작업은 지연 시퀀스로 수행되므로 실제로 평가할 수있는 소수만 생성됩니다.
╓───╖
║ Ṗ ║
╔═══╗ ╙─┬─╜
║ 0 ║ ┌─┴─╖
╚═╤═╝ │ ♭ ║
╔═══╗ ┌──┴─╖ ╘═╤═╝
║ 2 ╟─┤ Ṗp ╟───┘
╚═══╝ ╘══╤═╝
┌──────────────┐ │
│ ├─────────────────────────────────────────┐
│ ┌─┴─╖ │
│ ┌─┤ · ╟────────────────────────────┐ ╓┬───╖ │
│ │ ╘═╤═╝ ├───╫┘Ṗp ╟─┤
│ │ │ ╔═══╗ ┌────╖ ┌─┴─╖ ╙─┬──╜ │
│ │ │ ║ 1 ╟─┤ >> ╟─────┤ · ╟───┴─┐ │
│ │ │ ┌───╖ ╚═══╝ ╘══╤═╝ ╘═╤═╝ │ │
│ │ ┌─┴──┤ ♯ ╟─────┐ ┌──┴─╖ ┌───╖ │ │ │
│ │ │ ╘═══╝ ┌─┐ │ ┌──┤ Ṗp ╟─┤ ♭ ╟─┴─┐ │ │
│ │ │ ├─┘ └─┤ ╘══╤═╝ ╘═══╝ ┌─┘ │ │
│ │ │ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │ │
│ │ └────────╢ ├─┤ · ╟─┤ ? ╟─────┤ · ╟─┐ │ │
│ │ ┌───╖ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │ │
│ ┌─┴─┤ ♭ ╟─┐ ┌──┴─╖ │ ┌─┴─╖ │ │ │ │
│ │ ╘═══╝ └─┤ Ṗp ╟───┘ ┌─┤ ? ╟───────┘ │ │ │
│ ┌───╖ │ ╔════╗ ╘══╤═╝ │ ╘═╤═╝ │ │ │
┌─┴─┤ ÷ ╟──┘ ║ −1 ║ ┌──┴─╖ ╔═╧═╗ │ ┌┴┐ │ │
│ ╘═╤═╝ ╚══╤═╝ ┌─┤ >> ╟─┐ ║ 0 ║ └┬┘ │ │
│ ┌─┴─╖ ┌────╖ │ │ ╘════╝ │ ╚═══╝ │ │ │
│ │ × ╟─┤ << ╟─┘ ┌─┴─┐ ╔═╧═╗ │ │ │
│ ╘═╤═╝ ╘══╤═╝ ┌┴┐ ┌┴┐ ║ 1 ╟───────────────────┴─┐ │ │
└─────┘ ┌┴┐ └┬┘ └┬┘ ╚═══╝ ├─┘ │
└┬┘ │ └──────────────────────────────┘ │
┌─┴─╖ ┌─┴──╖ │
│ ÷ ╟─┤ << ╟─┐ │
╘═╤═╝ ╘════╝ ├──────────────────────────────────┘
┌┴┐ │
└┬┘ │
╔════╗ ┌─┴──╖ │
║ −1 ╟─┤ << ╟───────┘
╚════╝ ╘════╝
도우미 기능 Ṗp은 다음과 같습니다.
0에 도달 할 때까지 계속 감소하는 실행 카운터입니다.
이미 프라임이 아닌 것으로 알려진 각 숫자에 대해 비트 세트가있는 체. 처음에 최하위 비트는 숫자 2를 나타내지 만 각 반복마다 오른쪽으로 이동합니다.
체의 가장 낮은 비트로 표현되는 숫자를 나타내는 숫자 n ; 이것은 매번 반복 될 때마다 증가합니다.
각 반복에서 체의 가장 낮은 비트가 0이면 소수 n을 찾았습니다 . 그런 다음 NxN 그리드의 행, 열 및 대각선 채우기에 이미 설명 된 공식을 사용 하여 다음 반복으로 이동하기 전에 체에서 n 번째 비트 마다 설정합니다 .
③ Ḟ소인수 분해
╓───╖
║ Ḟ ║
╙─┬─╜
┌───────┴──────┐
│ ┌───╖ ┌────╖ │
└─┤ Ṗ ╟─┤ Ḟp ╟─┘
╘═══╝ ╘═╤══╝
│
┌────────────────────────────────────────────┐
│ ╓┬───╖ │
┌───────┴─┐ ┌───────────────────────┐ ┌─╫┘Ḟp ╟─┘
│ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ┌───┐ ┌────╖ ┌─┴─╖ │ ╙────╜
│ ║ 0 ╟─┤ ╟─┤ · ╟─┘┌┐ └─┤ Ḟp ╟──┐ ┌─┤ · ╟─┴──┐
│ ╚═══╝ └─┬─╜ ╘═╤═╝ └┤ ╘═╤══╝ ├─┘ ╘═╤═╝ │
│ ┌─┴─┐ ┌─┴─╖ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴──╖ ┌─┴─╖
│ │ └─┤ · ╟─╢ ├─┤ ? ╟─┤ · ╟─┤ ÷% ╟─┤ · ╟─┐
│ │ ╘═╤═╝ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤══╝ ╘═╤═╝ │
│ │ ┌──┴─╖ │ ┌─┴─╖ ┌─┴─╖ └──────┘ │
│ │ │ Ḟp ╟───┘ ┌─┤ ? ╟─┤ ≤ ║ │
│ ┌─┴─╖ ╘══╤═╝ │ ╘═╤═╝ ╘═╤═╝ │
└─────┤ · ╟─────┘ ╔═╧═╗ │ ╔═╧═╗ │
╘═╤═╝ ║ 0 ║ ║ 2 ║ │
│ ╚═══╝ ╚═══╝ │
└──────────────────────────────────────────┘
이것은 매우 간단합니다. 소수를 n 까지 반복 하고 어떤 것이 n을 나눕니다 . 하나는 분열 않으면 N 의과에서 수행하는 기억 동일 이 분할하는 경우 우리는 그것을 여러 번 돌려 너무 소수 N 여러 번. 이것은 2보다 작은 수의 빈 시퀀스를 반환합니다.
④ ◇ ◆다이아몬드 생성
이 함수는 문자와 반지름이 주어지면 하나의 다이아몬드를 생성합니다. 캐릭터를 사용하여 다이아몬드 중앙에 배치합니다.
┌───╖
┌─────────────────────┤ ♯ ╟───────────┬─────────┐
│ ┌───╖ ╔═══╗ ┌───┐ ╘═══╝ │ │
└─┤ ♫ ╟─╢ 0 ║ │ ┌─┴─╖ │ │
╘═╤═╝ ╚═══╝ │ │ ʭ ╟───┐ │ │
┌─┴─╖ ┌─────┘ ╘═╤═╝ │ │ │
│ ɱ ╟───┤ ┌───╖ ┌─┴─╖ ╔═══╗ ╓───╖ │ │
╘═╤═╝ └─┤ ɹ ╟─┤ ʓ ╟─╢ 1 ║ ┌─╢ ◇ ╟─┤ │
│ ╔═══╗ ╘═══╝ ╘═══╝ ╚═══╝ │ ╙───╜ │ │
│ ║ 0 ║ │ ┌─┴─╖ │
│ ╚═╤═╝ │ │ ♭ ║ │
╔═╧═╕ │ ╔════╗ │ ╘═╤═╝ │
┌───╢ ├─┘ ┌─╢ 21 ║ ┌─┴─╖ ┌─┴─╖ ┌─┴─┐
│ ╚═╤═╛ │ ╚════╝ ┌────────┤ · ╟───┤ · ╟─┐ ┌─┴─╖ │
│ ┌─┴─╖ ┌─┴──╖ ┌───┘ ╘═╤═╝ ╘═╤═╝ ├─┤ = ║ │
│ ┌─┤ ‼ ╟─┤ >> ║ │ │ ┌─┴─╖ │ ╘═╤═╝ │
│ │ ╘═══╝ ╘═╤══╝ │ │ ┌─┤ ? ╟─┘ │ │
│ │ ┌───╖ │ ┌──┘ │ │ ╘═╤═╝ │ │
│ └─┬─┤ ⇄ ╟─┘ │ ┌─────┐ │ │ ┌─┴─╖ │ │
│ │ ╘═══╝ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ └─┤ · ╟──┬──┘ │
│ └───────┤ · ╟─┤ ? ╟─┤ · ╟─┤ ‼ ║ ╘═╤═╝ │ │
│ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ │ │
│ └─────┘ └─┬───┘ ┌───┤ … ║ │ │
│ ┌─────┐ │ │ ╘═╤═╝ │ │
│ ╔══╧═╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╔═╧══╗ │ │
│ ║ 32 ║ │ … ╟─┤ ‼ ╟─┤ ‼ ║ ║ 32 ║ │ │
│ ╚════╝ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╚════╝ │ │
│ ┌─┴─╖ ╔═╧══╗ │ │
│ ┌───┤ − ╟───┬─┐ ║ 46 ║ │ │
│ ┌─┴─╖ ╘═══╝ │ │ ╚════╝ │ │
└─────────────┤ · ╟─────────┘ └──────────────┘ │
╘═╤═╝ │
└───────────────────────────────────┘
이것은 게으른 시퀀스를 많이 사용합니다. 작동 방식은 다음과 같습니다.
0에서 r 까지의 정수 시퀀스를 생성하십시오 (포함).
이러한 각 정수 α에 대해 ( r - α ) 공백 ( …), 점 다음에 α 공백 으로 구성되는 문자열을 생성합니다. α = r이 아닌 경우에는 더 적은 공간을 생성하고 문자를 추가합니다. 이제 왼쪽 상단이 다이아몬드입니다.
이러한 각 문자열에 동일한 문자열의 다른 사본을 추가하되 문자를 뒤집은 ⇄다음 ( ) 첫 번째 문자를 제거하십시오 ( >> 21). 우리는 이제 다이아몬드의 상반부를 가지고 있습니다.
이 시퀀스를 가져 와서 동일한 시퀀스를 추가하되 반전 시키되 ( ɹ) 첫 번째 요소를 제거하고 ( ʓ) 제거 하십시오. 우리는 이제 전체 다이아몬드를 가지고 있습니다.
이제 우리는 다이아몬드를 구성하는 줄이 있지만 좀 더 많은 정보가 필요합니다. 우리는 다이아몬드의 수직 중앙이 어디에 있는지 알아야합니다. 처음에는 물론 r 이지만, 다른 다이아몬드를 위와 아래에 추가 한 후에는 "중간"다이아몬드의 위치를 추적하여 다른 다이아몬드 스택을 올바르게 정렬 할 수 있도록해야합니다. . 다이아몬드의 수평 범위도 마찬가지입니다 (위와 아래에 다이아몬드를 추가 할 때 필요). 나는 또한 편지를 추적하기로 결정했다. 그렇지 않으면 함수 ⬗(다음 섹션에서 볼)가 4 개의 매개 변수를 가져야하지만 Funciton은 3 개만 허용 하기 때문에 필요합니다 .
┌─────────────────┐
│ ╓───╖ │
├──╢ ◆ ╟──┐ │
│ ╙───╜ │ │
│ ┌─────┴───┐ │
┌─┴─╖ │ ┌───╖ ┌─┴─╖ │
┌─┤ · ╟─┴─┤ › ╟─┤ › ║ │
│ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │
│ ┌─┴─╖ │ ┌─┴─╖ │
│ │ ◇ ╟─────────┤ › ╟─┘
│ ╘═╤═╝ ╘═══╝
└───┘
리스트 API를 사용하여 ( ›요소를리스트 앞에 추가) [ x , y , c , q ]를 포함하는 구조를 만듭니다. 여기서 x 는 다이아몬드의 수평 중심의 x 좌표입니다. y 는 y- 기준선의 좌표, c 는 문자, q 는 느린 문자열 시퀀스입니다. 이 구조는 앞으로 모든 중간 단계를 포함하는 데 사용됩니다.
⑤ ⬗다이아몬드를 세로로 추가
이 함수는 기존 다이아몬드 스택, 반지름 및 새 다이아몬드를 상단 (true) 또는 하단 (false)에 추가할지 여부를 나타내는 부울을 가져옵니다.
┌─────────────────────────────────────────────────┐
┌─┴─╖ ┌───────────────────────────┐ ┌───╖ ┌─┴─╖
┌───┤ · ╟─────────┘ ╔═══╗ ┌───────────────┐ ├─┤ ‹ ╟─┤ ‹ ║
│ ╘═╤═╝ ║ 1 ║ │ ╓───╖ │ │ ╘═╤═╝ ╘═╤═╝
│ │ ╚═╤═╝ └─╢ ⬗ ╟─┐ │ ┌─┴─╖ │ ┌─┴─╖
│ │ ┌───╖ ┌───╖ ┌─┴──╖ ╙─┬─╜ │ └─┤ · ╟─┘ ┌─┤ ‹ ╟─┐
│ ┌─┴─┤ + ╟─┤ ♯ ╟─┤ << ║ │ │ ╘═╤═╝ │ ╘═══╝ │
│ │ ╘═╤═╝ ╘═══╝ ╘═╤══╝ │ ┌─┴─╖ │ │ │
│ │ ┌─┴─╖ └───────┴─┤ · ╟───┐ ┌─┴─╖ │ │
│ └───┤ ? ╟─┐ ╘═╤═╝ ┌─┴───┤ · ╟─┐ │ │
│ ╘═╤═╝ ├───────────────────┘ │ ╘═╤═╝ │ │ │
│ ┌───╖ ┌─┴─╖ │ ┌─────┐ │ ┌───╖ │ │ │ │
└─┤ › ╟─┤ › ║ │ ┌───╖ ┌─┴─╖ │ └─┤ − ╟─┘ │ │ │
╘═╤═╝ ╘═╤═╝ │ ┌─┤ ‼ ╟─┤ ‼ ║ │ ╘═╤═╝ │ │ │
│ ┌─┴─╖ │ │ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ ┌─┴─╖ │ │ │
┌───┤ · ╟─┘ │ ┌─┴─╖ ├───┤ · ╟─┤ … ║ │ │ │
┌───┐ │ ╘═╤═╝ └─┤ · ╟───┘ ╘═╤═╝ ╘═╤═╝ │ │ │
│ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ╔══╧═╗ │ │ │
│ │ ʭ ╟─┤ ? ╟─┤ › ╟─┐ ╔═══╗ ╔═╧═╕ │ ║ 32 ║ │ │ │
│ ╘═╤═╝ ╘═╤═╝ ╘═══╝ │ ║ 0 ╟─╢ ├─────────┘ ╚════╝ │ │ │
│ ┌─┘ ┌─┴─╖ │ ╚═══╝ ╚═╤═╛ │ │ │
│ └─┬───┤ ʭ ╟─┐ ┌─┴─╖ ┌─┴─╖ │ │ │
│ ┌─┴─╖ ╘═══╝ ├───┤ · ╟─────┤ ɱ ║ │ │ │
└─┤ · ╟───────┘ ╘═╤═╝ ╘═╤═╝ │ │ │
╘═╤═╝ │ ┌─┴─╖ │ │ │
│ └─────┬─┤ ◇ ╟───────────────────────┘ │ │
│ │ ╘═══╝ ┌─┴─╖ │
│ └─────────────────────────────┤ · ╟─────┘
│ ╘═╤═╝
└─────────────────────────────────────────────────────┘
이것 역시 매우 간단합니다. ‹구조물의 포장을 풀 때 사용 ; ◇새로운 다이아몬드를 생성하는 데 사용 ; ɱ(map)을 사용 하여 새로운 다이아몬드에서 각 줄의 시작과 끝에 공백을 추가하여 모두 같은 너비를 갖도록합니다. APPEND ( ʭ) 이전 상에 새로운 캐릭터 (아래 경우) 새로운 (만약 위) 상에 오래; 마지막으로 ›모든 새로운 값을 포함하는 구조를 만드는 데 사용 합니다. 특히 하단에 추가하는 경우 y 는 변경되지 않지만 상단에 추가하는 경우 y 는 증가해야합니다 ♯(r << 1)( r 은 새 다이아몬드의 반지름).
⑥ ❖스택을 수평으로 연결
이것이 그들 모두의 가장 큰 기능입니다. 나는 이것을 올바르게 얻는 것이 상당히 어리 석다는 것을 부정하지 않을 것이다. 올바른 세로 정렬을 유지하면서 두 개의 스택을 가져 와서 가로로 연결합니다.
┌──────────────────────────────────┬───────────────────────┐
│ ┌──────────────────┐ ┌─┴─╖ ┌─┴─╖
│ │ ┌───────────┐ └───────┤ · ╟───┬───────────────┤ · ╟─────────────┐
│ │ ┌─┴─╖ │ ╘═╤═╝ │ ╘═╤═╝ │
│ │ │ ‹ ╟───┐ │ ┌─┴─╖ ┌─┴─╖ │ │
│ │ ╘═╤═╝ ┌─┴─╖ └─────────┤ · ╟─┤ · ╟─────────┐ │ │
│ │ ├─┐ │ ‹ ╟───┐ ╘═╤═╝ ╘═╤═╝ │ │ │
│ │ └─┘ ╘═╤═╝ ┌─┴─╖ ╓───╖ ┌─┴─╖ │ │ │ │
│ │ │ │ ‹ ╟─╢ ❖ ╟─┤ ‹ ║ │ │ │ │
│ │ │ ╘═╤═╝ ╙───╜ ╘═╤═╝ ┌─┴─╖ ┌─┐ │ │ │
│ │ │ │ └───┤ ‹ ║ └─┤ │ │ │
│ │ │ │ ╘═╤═╝ ┌─┴─╖ │ │ │
│ │ │ │ └───┤ ‹ ║ │ │ │
│ │ │ └─────────────────┐ ╘═╤═╝ │ │ │
│ │ │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │
│ │ │ ┌──────────────┤ · ╟─┤ · ╟─┤ · ╟─┤ · ╟──────┐ │
│ │ └──────┤ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │
│ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │ │ │ │ │
│ ┌─┤ · ╟─────────────┤ · ╟────────────┤ · ╟───┘ │ │ │ │
│ │ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │ │ │
│ │ │ │ ┌────╖ │ ┌─┴─╖ │ │ │
╔═══╗ ┌────╖ │ │ │ │ ┌─┤ << ╟─┴─────────┤ · ╟─┐ │ │ │
║ 1 ╟─┤ << ╟────────┘ │ │ │ │ ╘═╤══╝ ╘═╤═╝ │ │ │ │
╚═══╝ ╘═╤══╝ ╔════╗ │ │ ┌─┴─╖ │ ┌─┴─╖ │ │ │ ┌──┴──┐ │
┌─┴─╖ ║ 32 ╟─┐ │ │ ┌─────────────┤ · ╟───┐ │ │ ♯ ║ │ │ │ ┌─┴─╖ ┌─┴─╖ │
│ ♯ ║ ╚════╝ │ │ └─┤ ┌───╖ ╘═╤═╝ │ │ ╘═╤═╝ ┌───╖ ╔════╗ │ │ │ ┌─┤ ? ╟─┤ < ║ │
╘═╤═╝ ┌───╖ │ │ └─┤ − ╟─────────┴─┐ │ │ └───┤ … ╟─╢ 32 ║ │ │ │ │ ╘═╤═╝ ╘═╤═╝ │
└─────┤ … ╟─┘ │ ╘═╤═╝ ┌─┴─╖ │ └───┐ ╘═╤═╝ ╚════╝ │ │ │ │ ┌─┴─╖ ├───┘
╘═╤═╝ │ ┌───╖ ┌─┴─╖ ┌───────┤ · ╟─┴─┐ ╔═╧═╗ ┌─┴─╖ ┌──────┘ │ │ └─┤ · ╟───┘
│ ┌─┴─┤ ʭ ╟─┤ ȶ ║ │ ┌───╖ ╘═╤═╝ │ ║ 1 ║ │ ⁞ ║ │ ┌────────┘ │ ╘═╤═╝
┌─┴─╖ │ ╘═╤═╝ ╘═╤═╝ └─┤ > ╟───┴─┐ │ ╚═══╝ ╘═╤═╝ │ │ ┌──────┘ └────┐
│ ⁞ ║ │ ┌─┴─╖ ┌─┴─╖ ╘═╤═╝ │ ┌─┴─╖ ┌───╖ │ │ │ ┌─┴─╖ ┌───╖ ┌───╖ ┌─┴─╖
╘═╤═╝ └───┤ ? ╟─┤ · ╟─────┴─┐ │ │ − ╟─┤ ȶ ╟─┴─┐ │ │ │ + ╟─┤ ♯ ╟─┤ › ╟─┤ › ║
┌─┴─╖ ╘═╤═╝ ╘═╤═╝ │ │ ╘═╤═╝ ╘═╤═╝ │ │ │ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝
┌────────────────────┤ · ╟───────┴───┐ └─┐ ┌─┴─╖ └───┘ ┌─┴─╖ │ │ └───┘ │ │
│ ╘═╤═╝ ┌─┴─╖ │ ┌─┤ · ╟───────────┤ · ╟───┘ │ │
│ ┌────────────────┐ │ ┌───────┤ · ╟─┘ │ ╘═╤═╝ ╘═╤═╝ │ │
│ │ ╔════╗ ┌───╖ ┌─┴─╖ └───┤ ┌───╖ ╘═╤═╝ │ │ │ ┌─┴───┐ │
│ │ ║ 32 ╟─┤ ‼ ╟─┤ · ╟───┐ └─┤ ʭ ╟───┘ │ │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ │
│ │ ╚════╝ ╘═╤═╝ ╘═╤═╝ │ ╘═╤═╝ ┌─────┘ │ │ ʭ ╟─┤ · ╟─┤ ? ╟─┐ │
│ │ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ │ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ │ │
│ │ │ ‼ ╟─╢ ├─╢ ├─┤ ʑ ╟───┤ ʭ ║ ┌─┴─╖ └─────┘ │ │ │
│ │ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ┌───┤ · ╟─────────────────────────┘ │ │
│ └──────────┘ │ ╔═╧═╗ │ ├───┘ ╘═╤═╝ │ │
│ └───╢ 0 ║ ┌─┴─╖ ┌─┴─╖ └───────────────────────────────┘ ┌─┴─╖ ╔═══╗
│ ╚═══╝ │ ȶ ╟───┤ · ╟─────────────────────────────────────────────────────┤ › ╟─╢ 0 ║
│ ╘═╤═╝ ╘═╤═╝ ╘═══╝ ╚═══╝
│ ┌─┴─╖ ┌─┴─╖
│ ┌─────┤ ? ╟─┐ │ ɕ ║
│ ┌─┴─╖ ╘═╤═╝ │ ╘═╤═╝
│ ┌───╖ ┌─┤ < ╟───┬─┘ │ │
└────────────┤ ɕ ╟─┤ ╘═══╝ ┌─┴─╖ │ │
╘═══╝ └───────┤ · ╟───┘ │
╘═╤═╝ │
└─────────┘
작동 방식은 다음과 같습니다.
먼저 각 스택에 대해 ⁞문자열 의 무한 시퀀스 ( )를 생성합니다 . 각 문자열에는 …해당 스택의 너비에 따라 공백 ( ) 이 포함 됩니다.
스택 의 y 값은 어느 것이“아래로 이동”해야하는지 그리고 얼마만큼을 알려줍니다. ȶ올바른 길이 ( 잘린 부분 ( ))를 올바른 길이 앞에 붙입니다 (적절한 경우 y1 - y2 또는 y2 - y1 ).
이제 각 문자열 시퀀스의 길이 ( ɕ)를 결정하여 높이를 알려줍니다. 어느 쪽이 더 큰지 알아보십시오.
무한 공간 시퀀스를 두 스택에 추가하십시오.
zip ( ʑ)을 사용 하여 정리하십시오. 각 문자열 쌍마다 ‼추가 공백과 함께 문자열 ( )을 연결하십시오 .
그런 다음 사용하는 ȶ가장 높은 높이로 그 결과를 절단 할 수 있습니다. 이 작업을 늦게 수행하면 패딩이 필요한 것을 신경 쓸 필요가 없습니다.
마지막으로 구조를 다시 생성하십시오. 이 시점에서 더 이상 다이아몬드에 문자가 필요하지 않으므로 0으로 설정합니다. x 값은 합산 및 증분됩니다 (그래서 스택의 너비는 여전히으로 계산 될 수 있음 ♯(x << 1)). Y 값 둘 중 하나 이상으로 설정된다.
⑦ ↯문자열에서 문자를 반복
이것은 라이브러리에 추가 할 또 다른 유용한 기능입니다. 문자열이 주어지면 각 문자 코드를 포함하는 게으른 시퀀스를 제공합니다.
╓───╖
║ ↯ ║
╙─┬─╜
┌──────────────┴────────────────┐
│ ┌─┐ ╔═══╗ ┌───╖ │
│ └─┤ ┌────╢ 0 ╟─┤ ≠ ╟─┴─┐
┌──────┴─┐ ┌┐ ╔═╧═╕ ┌─┴─╖ ╚═══╝ ╘═╤═╝ │
│ ├─┤├─╢ ├─┤ ? ╟──────────┤ │
│ │ └┘ ╚═╤═╛ ╘═╤═╝ ╔════╗ ┌─┴─╖ │
│ ╔══════╧══╗ ┌─┴─╖ │ ║ −1 ╟─┤ ≠ ╟───┘
│ ║ 2097151 ║ │ ↯ ║ ╚════╝ ╘═══╝
│ ╚═════════╝ ╘═╤═╝
│ ┌─┴──╖ ╔════╗
└─────────────┤ >> ╟─╢ 21 ║
╘════╝ ╚════╝
and2097151로 문자열을 보내면 첫 번째 문자가 반환됩니다. >>21만큼 붙이면 제거됩니다. esolangs 페이지에 설명 된 이유로 0과 -1을 모두 확인 합니다 . 이것은이 도전과 관련이 없지만 라이브러리 기능이 정확하기를 원합니다.
⑧ ⬖캐릭터를 다이아몬드 스택으로 변환
이 함수는 단일 문자를 사용하여 해당 문자를 나타내는 세로 스택의 구조를 반환합니다.
╔════╗
║ 96 ║ ╓───╖
╚══╤═╝ ║ ⬖ ║
┌───╖ ┌───╖ ┌─┴─╖ ╙─┬─╜
┌───┤ ɗ ╟─┤ Ḟ ╟─┤ − ║ │
│ ╘═╤═╝ ╘═══╝ ╘═╤═╝ │
│ ┌─┴─╖ ├──────┘ ┌──┐
│ │ ɹ ║ │ ┌───┤ │
│ ╘═╤═╝ ┌─────┘ │ │ │
╔═╧═╗ ┌─┴─╖ ┌─┴─╖ │ ┌┴┐ │
║ 1 ╟─┤ ╟─┤ · ╟─────┐ ╔═╧═╕└┬┘ │
╚═══╝ └─┬─╜ ╘═╤═╝ ┌─┴─╢ ├─┘ ┌┴┐
┌───────────┐ │ └─┐ │ ╚═╤═╛ └┬┘
┌─┴─╖ │ │ ┌───╖ │ └─┐ ╔═╧═╕ ┌──┴─╖ ╔═══╗
┌─────┤ · ╟───┐ │ └─┤ ◆ ╟─┘ ┌─┴─╢ ├─┤ << ╟─╢ 1 ║
┌──┴─┐ ╘═╤═╝ │ │ ╘═╤═╝ │ ╚═╤═╛ ╘════╝ ╚═╤═╝
│ ┌──┴─╖ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖
│ │ >> ╟─┤ ⬗ ╟─╢ ├─╢ ├─┤ ʩ ╟───┤ · ╟─┤ ʑ ╟────────┤ ⸗ ║
│ ╘══╤═╝ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝
│ ╔═╧═╗ ┌┴┐ │ ╔═╧═╗ │ └─────┘ ╔═╧═╗
│ ║ 1 ╟─┐└┬┘ └───╢ 0 ║ ║ 0 ║
│ ╚═══╝ ├─┘ ╚═══╝ ╚═══╝
└────────┘
이 기능은 우리가 다이아몬드를 아래쪽과 위쪽에 교대 로 추가해야하기 때문에 흥미 롭습니다 . 내가 한 방법은 다음과 같습니다.
먼저 96을 빼고 ( 'a'1이 됨) 소수를 가져 오고 ( Ḟ위) ɗ시퀀스가 비어 있으면 요소 1을 더한 다음 ɹ순서 를 반대로 ( ) 사용합니다.
첫 번째 요소를 빼고 호출 ◆하여 스택을 시작하십시오.
이제 ⸗숫자 0과 1을 무기한 번갈아 바꾸는 게으른 시퀀스를 생성하는 데 사용하십시오 .
ʑ그 부분과 나머지 주요 요소에 (zip)을 사용하십시오 . 각 소인수에 대해 1 씩 왼쪽으로 이동 or시키고 0/1은 그 위에 올립니다. 이제 소수 와 상단 / 하단 정보 를 인코딩하는 시퀀스가 있습니다.
마지막으로 ʩ(왼쪽 / 집합)을 사용하십시오. 초기 값은 위의 첫 번째 요소에서 생성 된 스택입니다. 각 값 ν 에 ⬗대해 이전 스택, 프라임 ( ν >> 1) 및 상단 또는 하단 ( ν & 1)을 호출 하여 새 다이아몬드를 추가합니다 .
⑨ 주요 프로그램
여기서 우리는 주요 작업을 수행합니다.
┌─────┐
│ ┌─┴─╖
│ │ ⬖ ║
╔═══╗ ╔═╧═╕ ╘═╤═╝
║ 0 ╟─╢ ├───┘
╚═╤═╝ ╚═╤═╛ ┌───╖ ┌───╖ ╔═══╗
└─┐ └───┤ ɱ ╟─┤ ↯ ╟─╢ ║
┌─────────┐ └─────┐ ╘═╤═╝ ╘═══╝ ╚═══╝
│ ┌─┴─╖ │ ┌─┴─╖
│ ┌───┤ · ╟───┐ └─┤ ╟─┐
│ │ ╘═╤═╝ │ └─┬─╜ │
│ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ │
│ │ ❖ ╟─╢ ├─╢ ├─┤ ʩ ╟─┘
│ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝
└───┘ ╔═╧═╗ │ ┌─┴─╖ ┌─┐
║ 0 ╟───┘ ┌─┤ ‹ ╟─┴─┘
╚═══╝ │ ╘═══╝
┌─┴─╖ ┌─┐
┌─┤ ‹ ╟─┴─┘
│ ╘═══╝
╔════╗ ┌───╖ ┌─┴─╖ ┌─┐
║ 10 ╟─┤ ʝ ╟─┤ ‹ ╟─┴─┘
╚════╝ ╘═╤═╝ ╘═══╝
│
먼저 ɱ입력 문자열 ( ↯) 의 문자 위에 ( )를 매핑 하고을 사용하여 각각을 다이아몬드 스택으로 바꿉니다 ⬖. 첫 번째 요소를 제거 ʩ하고 나머지 요소를 접어서 ( ) 모두 연결하십시오 ( ❖). 마지막으로 ‹문자열 시퀀스에 도달하기 위해을 사용하여 구조의 압축을 풀고 ʝ10을 줄 바꿈 기호로 사용하여 모두 ( ) 결합 하십시오.
출력 예
입력:
crusaders
출력 (계산하는 데 9 초가 걸렸으며 크기 제한으로 인해 여기에 게시 할 수 없음)