ให้คำที่ประกอบด้วยตัวอักษรตัวพิมพ์เล็กเท่านั้นให้ทำดังนี้

1. สำหรับตัวอักษรแต่ละตัวรับการแยกตัวประกอบเฉพาะของตำแหน่งในตัวอักษร
2. สำหรับปัจจัยหลักแต่ละอันpให้วาดเพชรที่มีความยาวด้านpและติดตัวอักษรที่อยู่ตรงกลางของเพชร
3. เพชรที่ใหญ่ที่สุดอยู่ตรงกลางเพชรที่มีขนาดเล็กตามมา (จากมากไปหาน้อยที่สุด) สลับกันระหว่างการไปที่ด้านล่างหรือด้านบน

หมายเหตุ:สำหรับจดหมายให้ใช้ความยาวด้านข้างเท่ากับ 1

ตัวอย่าง: แมว

• c : 3 = 3
• a : 1 = 1
• t : 20 = 5 * 2 * 2

แผนภาพ:

                 .
                . .
               . t .
                . .
                 .
                 .
                . .
   .           .   .
  . .         .     .
 .   .   .   .       .
.  c  . .a. .    t    .
 .   .   .   .       .
  . .         .     .
   .           .   .
                . .
                 .
                 .
                . .
               . t .
                . .
                 .

ตัวอย่าง: สุนัข

• d : 4 = 2 * 2
• o : 15 = 5 * 3
• g : 7 = 7

แผนภาพ:

                         .
                        . .
           .           .   .
          . .         .     .
         .   .       .       .
  .     .     .     .         .
 . .   .       .   .           .
. d . .    o    . .      g      .
 . .   .       .   .           .
  .     .     .     .         .
  .      .   .       .       .
 . .      . .         .     .
. d .      .           .   .
 . .       .            . .
  .       . .            .
         .   .
        .  o  .
         .   .
          . .
           .

-20% โบนัสหากโปรแกรมของคุณส่งออกเป็นไฟล์ข้อความชื่อ "[your-word] .txt" จากนั้นป้อนคำจริง (หรือวลีเป็นตัวพิมพ์เล็กโดยไม่มีช่องว่าง) ที่มีความยาวอย่างน้อย20 ตัวอักษรและยังไม่มีใครเลือกและวางผลลัพธ์ระหว่าง a <pre>และ a </pre>ในคำตอบของคุณ

Matlab, 466 393 - 20% = 314.4 ไบต์

Golfed: (สามารถบันทึกได้มากกว่าไบต์เนื่องจากความช่วยเหลือของ @ AndreasDeak!)

function q(W);function z=g(l,c);[x,y]=ndgrid(abs(-l:l));z=0*y;z(~x&~y)=c;z(x+y==l)=46;end;w=W-96;n=numel(w);R=n*26;C=1;A=zeros(2*R);for k=1:n;f=sort(factor(w(k)));C=C+max(f)+1;d=-1;r=R;for F=fliplr(f);v=-F:F;while norm(A(r+v,v+C));r=r+d;end;A(r+v,v+C)=g(F,W(k));d=-d;end;C=C+max(f);end;A=A(find(sum(A,2)),find(sum(A)));f=fopen([W,'.txt'],'w');for k=1:size(A,1);fprintf(f,[A(k,:),'\n']);end;end

มันควรจะทำงานใน Octave (opensource) ด้วย แต่มีคำเตือนมากมาย ใช้เวอร์ชันนี้หากคุณต้องการทดลองใช้ในระดับแปดเสียง (เอาต์พุตไปยังคอนโซลแทนไฟล์):

function q(W);function z=g(l,c);[x,y]=ndgrid(abs(-l:l));z=0*y;z(~x&~y)=c;z(x+y==l)=46;end;w=W-96;n=numel(w);R=n*26;C=1;A=zeros(2*R);for k=1:n;f=sort(factor(w(k)));C=C+max(f)+1;d=-1;r=R;for F=fliplr(f);v=-F:F;while norm(A(r+v,v+C));r=r+d;end;A(r+v,v+C)=g(F,W(k));d=-d;end;C=C+max(f);end;A=A(find(sum(A,2)),find(sum(A)));disp([A,'']);end

Ungolfed และอธิบาย:

function q(W)
function z=g(l,c) %get a square matrix for one prime factor
[x,y]=ndgrid(abs(-l:l));
z=0*y;
z(~x&~y)=c;    %character in the middle
z(x+y==l)=46;  %dots
end;
w=W-96;                %convert word to the corresponding indices                  
n=numel(w);
R=n*26;                %keeps track of the main row 
C=1;                   %keeps track of the current column
A=zeros(2*R);          %make a 'canvas' matrix that is way to big 
for k=1:n;
    f=sort(factor(w(k)));          %get all the factors of current character
    C=C+max(f)+1;                  %update current column
    d=-1;                          %search direction
    r=R;
    for F=fliplr(f);              
        v=-F:F;
        while norm(A(r+v,v+C));    %go up or down until there is enough space to write the prime factor
            r=r+d;
        end;
        A(r+v,v+C)=g(F,W(k));     %insert all the prime factors
        d=-d;
    end;
    C=C+max(f);
end;
A=A(find(sum(A,2)),find(sum(A))); %truncate all the unneccessary padding
f=fopen([W,'.txt'],'w');     %write to file
for k=1:size(A,1);
    fprintf(f,[A(k,:),'\n']);
end;

end

คำที่ร้องขอ: (และนี่เป็นไฟล์: (ย่อมาก): supercalifragilisticexpialidocious.txt )

                       . . .                   
                      . . . . . .                  
                     . . . . . .                 
                    . . . . . .                
                   . . . . . .               
                  . . . . . .              
                 . . . . . .             
                . . . . . .            
               . . . . . .           
              . . . . . . .          
             . . . . . . . .         
            . . . . . . . . . t. . . . .        
           . . . . . . . . . . . . . . . . . . . . . . . . .       
          . . . . . . . ร. . ล. . ร. . . . ล. . . . . x. . . . ล. . . . .      
         . . . . . หน้า . . . . . . . . . . . . . . . . . . หน้า . . . . . . . .     
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
    . s .. u .. p .. e .. r .. c .. a .. l .. i .. f .. r ..a .. g .. i .. l .. i .. s .. .. t .. i .. c .. e .. x .. p .. i .. a .. l .. i .. d .. o .. c .. i .. o .. u .. s .. .
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
         . . . . . หน้า . . . . . . . . . . . . . . . . . . . . . . . . . . . . หน้า . . . . . . . วัน . . . . . . . .     
          . . . . . . . . . ล. . . . ฉ. . . . . . . . ล. . . . . . . . . x. . . . . . ล. . . . . . . . . . . . .      
           . . . . . ร. . . . ผม . . . . ร. . . ผม . . . . ผม . . . . . . ผม . . . . . ผม . . . . ผม . . . . . ผม . . . . . .       
            . . . . . . . . . . . . . . . . . . . . t. . . . . . . . . . . . . . . . . . .        
             . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . o . . . o . . . .         
              . . . . . หน้า . . . . . . . . . . . . หน้า . . . . . . . . . . .          
               . . . ยู . . . . . . x. . . . . . . . ยู . . .           
                . . . . . . . . . . . . . . . .            
                 . . . . . . . . . . .             
                  . . . . . . . .              
                   . . . . . .               
                    . . . . . .                
                     . . . . . .                 
                      . . . . . .                  
                       . . .                   

Funcitonไม่ใช่การแข่งขัน 29199 ไบต์

ฉันสนุกกับความท้าทายนี้เพราะมันเน้นถึงการขาดฟังก์ชั่นของห้องสมุดที่มีประโยชน์มาก ฉันจะรวมฟังก์ชั่นทั้งหมดเหล่านี้ไว้ที่นี่ (และในจำนวนไบต์) เพราะฉันเขียนพวกเขาหลังจากมีการโพสต์ความท้าทายนี้

แหล่งที่มาแบบเต็มในไฟล์เดียว

คำอธิบาย

เช่นเคยรับการเรนเดอร์ที่ดีขึ้นด้วยการดำเนินการjavascript:(function(){$('pre,code').css({lineHeight:5/4});})()ในคอนโซลเบราว์เซอร์ของคุณ

① ɹ ⇄ย้อนกลับ

ดังที่คุณทราบหรือไม่อาจรู้ว่า Funciton มาพร้อมกับไลบรารีที่เต็มไปด้วยฟังก์ชั่นสำหรับรายการซึ่งเป็นค่าที่เข้ารหัสในจำนวนเต็ม humongous เดียวเช่นเดียวกับห้องสมุดแยกต่างหากสำหรับการประเมินที่ขี้เกียจซึ่งใช้นิพจน์แลมบ์ดา เพื่อที่จะขี้เกียจ แน่นอนว่ายังมีห้องสมุดสำหรับฟังก์ชั่นการจัดการสตริง

สำหรับความท้าทายนี้ฉันต้องการฟังก์ชั่นเพื่อย้อนกลับสตริงและฟังก์ชั่นเพื่อย้อนกลับลำดับที่ขี้เกียจประเมิน น่าแปลกที่ฉันมีเพียงรายการเดียวเท่านั้น - รายการที่ฉันไม่ต้องการ ดังนั้นที่นี่มีฟังก์ชั่นย้อนกลับสำหรับลำดับที่ขี้เกียจ ( ɹ) และสำหรับสตริง ( ⇄):

              ╓───╖             ╔════╗ ┌────╖        ╓───╖
              ║ ɹ ║             ║ 21 ╟─┤ >> ╟──┐     ║ ⇄ ║
              ╙─┬─╜             ╚════╝ ╘═╤══╝  │     ╙─┬─╜      ┌──┐
          ┌─────┴─────┐                ┌─┴─╖   ├───────┴────────┤  │
        ┌─┴─╖ ┌───╖   │                │ ⇄ ║   │   ╔════╗ ┌───╖ │  │
      ┌─┤   ╟─┤ ɹ ╟─┐ │                ╘═╤═╝   │   ║ −1 ╟─┤ ≠ ╟─┴┐ │
      │ └─┬─╜ ╘═══╝ │ │                ┌─┴─╖ ┌─┴─╖ ╚════╝ ╘═╤═╝  │ │
      │   │   ┌───╖ │ │                │ ‼ ╟─┤ ? ╟──────────┤    │ │
      │   └───┤ ʬ ╟─┘ │                ╘═╤═╝ ╘═╤═╝  ╔═══╗ ┌─┴─╖  │ │
      │       ╘═╤═╝   │                ┌─┴─╖ ╔═══╗  ║ 0 ╟─┤ ≠ ╟──┘ │
      │ ╔═══╗ ┌─┴─╖   │              ┌─┤ ʃ ╟─╢ 1 ║  ╚═╤═╝ ╘═══╝    │
      └─╢ 0 ╟─┤ ? ╟───┘              │ ╘═╤═╝ ╚═══╝    │            │
        ╚═══╝ ╘═╤═╝                  │   └────────────┘            │
                │                    └─────────────────────────────┘

คนขี้เกียจใช้ดังนี้ʬซึ่งคือ“ ผนวกองค์ประกอบต่อท้ายลำดับขี้เกียจ” สตริงที่หนึ่งใช้ʃ(สตริงย่อย) และ‼(สตริงเชื่อมต่อ)

②ช่วงṖเวลา

แม้ว่าฉันสามารถแยกตัวประกอบเฉพาะด้วยการพยายามหารnด้วยปัจจัยทั้งหมดตามลำดับ แต่ฉันตัดสินใจว่าฉันต้องการฟังก์ชันไลบรารีที่สร้างหมายเลขเฉพาะ ฟังก์ชั่นต่อไปนี้จะใช้เวลาเป็นจำนวนเต็มnและดำเนินตะแกรงของ Eratosthenesเพื่อสร้างตัวเลขที่สำคัญทั้งหมดขึ้นอยู่กับn มันทำสิ่งนี้เป็นลำดับที่ขี้เกียจดังนั้นมันจะสร้างเฉพาะช่วงเวลาที่คุณประเมินเท่านั้น

                                       ╓───╖
                                       ║ Ṗ ║
                                 ╔═══╗ ╙─┬─╜
                                 ║ 0 ║ ┌─┴─╖
                                 ╚═╤═╝ │ ♭ ║
                          ╔═══╗ ┌──┴─╖ ╘═╤═╝
                          ║ 2 ╟─┤ Ṗp ╟───┘
                          ╚═══╝ ╘══╤═╝
    ┌──────────────┐               │
    │              ├─────────────────────────────────────────┐
    │            ┌─┴─╖                                       │
    │          ┌─┤ · ╟────────────────────────────┐   ╓┬───╖ │
    │          │ ╘═╤═╝                            ├───╫┘Ṗp ╟─┤
    │          │   │           ╔═══╗ ┌────╖     ┌─┴─╖ ╙─┬──╜ │
    │          │   │           ║ 1 ╟─┤ >> ╟─────┤ · ╟───┴─┐  │
    │          │   │  ┌───╖    ╚═══╝ ╘══╤═╝     ╘═╤═╝     │  │
    │          │ ┌─┴──┤ ♯ ╟─────┐    ┌──┴─╖ ┌───╖ │       │  │
    │          │ │    ╘═══╝ ┌─┐ │ ┌──┤ Ṗp ╟─┤ ♭ ╟─┴─┐     │  │
    │          │ │          ├─┘ └─┤  ╘══╤═╝ ╘═══╝ ┌─┘     │  │
    │          │ │        ╔═╧═╕ ┌─┴─╖ ┌─┴─╖     ┌─┴─╖     │  │
    │          │ └────────╢   ├─┤ · ╟─┤ ? ╟─────┤ · ╟─┐   │  │
    │          │ ┌───╖    ╚═╤═╛ ╘═╤═╝ ╘═╤═╝     ╘═╤═╝ │   │  │
    │        ┌─┴─┤ ♭ ╟─┐ ┌──┴─╖   │   ┌─┴─╖       │   │   │  │
    │        │   ╘═══╝ └─┤ Ṗp ╟───┘ ┌─┤ ? ╟───────┘   │   │  │
    │ ┌───╖  │  ╔════╗   ╘══╤═╝     │ ╘═╤═╝           │   │  │
  ┌─┴─┤ ÷ ╟──┘  ║ −1 ║   ┌──┴─╖   ╔═╧═╗ │            ┌┴┐  │  │
  │   ╘═╤═╝     ╚══╤═╝ ┌─┤ >> ╟─┐ ║ 0 ║              └┬┘  │  │
  │   ┌─┴─╖ ┌────╖ │   │ ╘════╝ │ ╚═══╝               │   │  │
  │   │ × ╟─┤ << ╟─┘ ┌─┴─┐    ╔═╧═╗                   │   │  │
  │   ╘═╤═╝ ╘══╤═╝  ┌┴┐ ┌┴┐   ║ 1 ╟───────────────────┴─┐ │  │
  └─────┘     ┌┴┐   └┬┘ └┬┘   ╚═══╝                     ├─┘  │
              └┬┘    │   └──────────────────────────────┘    │
             ┌─┴─╖ ┌─┴──╖                                    │
             │ ÷ ╟─┤ << ╟─┐                                  │
             ╘═╤═╝ ╘════╝ ├──────────────────────────────────┘
              ┌┴┐         │
              └┬┘         │
      ╔════╗ ┌─┴──╖       │
      ║ −1 ╟─┤ << ╟───────┘
      ╚════╝ ╘════╝

ฟังก์ชั่นตัวช่วยṖp,, ใช้เวลา:

• ตัวนับที่ทำงานอยู่ซึ่งจะลดระดับลงเรื่อย ๆ จนกว่าจะถึง 0

• ตะแกรงซึ่งมีการตั้งค่าเล็กน้อยสำหรับแต่ละหมายเลขที่ทราบกันแล้วว่าไม่สำคัญ เริ่มแรกบิตที่มีนัยสำคัญน้อยที่สุดแสดงถึงหมายเลข 2 แต่เราเลื่อนสิทธิ์นี้ไปกับการวนซ้ำแต่ละครั้ง

• หมายเลขnซึ่งระบุว่าหมายเลขใดถูกแทนด้วยบิตต่ำสุดของตะแกรง นี่จะเพิ่มขึ้นทุกการวนซ้ำ

ในแต่ละซ้ำถ้าบิตต่ำสุดของตะแกรงเป็น 0 เราพบนายกn จากนั้นเราใช้สูตรที่ฉันได้อธิบายไปแล้วในการเติมแถวคอลัมน์และเส้นทแยงมุมของตาราง NxNเพื่อกำหนดทุกบิตn -th ในตะแกรงก่อนที่จะย้ายไปทำซ้ำครั้งถัดไป

③ Ḟนายกตีนเป็ด

                             ╓───╖
                             ║ Ḟ ║
                             ╙─┬─╜
                       ┌───────┴──────┐
                       │ ┌───╖ ┌────╖ │
                       └─┤ Ṗ ╟─┤ Ḟ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แต่เมื่อเราต่อท้ายเพชรอื่น ๆ ไปที่ด้านบนและด้านล่างของนี้เราจะต้องติดตามตำแหน่งของ "กลาง" เพชรเพื่อให้เราสามารถจัดเรียงแนวตั้งของเพชรอื่นได้อย่างถูกต้อง . เช่นเดียวกันสำหรับขอบเขตแนวนอนของเพชร (ต้องการเมื่อผนวกเพชรกับด้านบนและด้านล่าง) ฉันตัดสินใจติดตามจดหมายด้วย ฉันต้องการสิ่งนั้นเพราะมิฉะนั้นฟังก์ชั่น⬗(ที่เราไปถึงในส่วนถัดไป) จะต้องมีสี่พารามิเตอร์ แต่ Funciton อนุญาตเพียงสามเท่านั้น

                             ┌─────────────────┐
                             │  ╓───╖          │
                             ├──╢ ◆ ╟──┐       │
                             │  ╙───╜  │       │
                             │   ┌─────┴───┐   │
                           ┌─┴─╖ │ ┌───╖ ┌─┴─╖ │
                         ┌─┤ · ╟─┴─┤ › ╟─┤ › ║ │
                         │ ╘═╤═╝   ╘═╤═╝ ╘═╤═╝ │
                         │ ┌─┴─╖     │   ┌─┴─╖ │
                         │ │ ◇ ╟─────────┤ › ╟─┘
                         │ ╘═╤═╝         ╘═══╝
                         └───┘

เราใช้ list API ( ›เพิ่มองค์ประกอบที่ด้านหน้าของรายการ) เพื่อสร้างโครงสร้างที่มี [ x , y , c , q ], โดยที่xคือพิกัด x ของพิกัดแนวนอนตรงกลางของเพชร, yคือ y- พิกัดของ baseline, cคือตัวอักษรและqคือลำดับของสตริงที่ขี้เกียจ โครงสร้างนี้จะถูกใช้เพื่อบรรจุสเตจกลางทั้งหมดนับจากนี้เป็นต้นไป

⑤ ⬗เพชรผนวกแนวตั้ง

ฟังก์ชันนี้ใช้สแต็กเพชรที่มีอยู่รัศมีและบูลีนที่ระบุว่าจะเพิ่มเพชรใหม่ไปยังด้านบน (จริง) หรือด้านล่าง (เท็จ)

                 ┌─────────────────────────────────────────────────┐
               ┌─┴─╖         ┌───────────────────────────┐ ┌───╖ ┌─┴─╖
           ┌───┤ · ╟─────────┘ ╔═══╗ ┌───────────────┐   ├─┤ ‹ ╟─┤ ‹ ║
           │   ╘═╤═╝           ║ 1 ║ │ ╓───╖         │   │ ╘═╤═╝ ╘═╤═╝
           │     │             ╚═╤═╝ └─╢ ⬗ ╟─┐       │ ┌─┴─╖ │   ┌─┴─╖
           │     │ ┌───╖ ┌───╖ ┌─┴──╖  ╙─┬─╜ │       └─┤ · ╟─┘ ┌─┤ ‹ ╟─┐
           │   ┌─┴─┤ + ╟─┤ ♯ ╟─┤ << ║    │   │         ╘═╤═╝   │ ╘═══╝ │
           │   │   ╘═╤═╝ ╘═══╝ ╘═╤══╝    │ ┌─┴─╖         │     │       │
           │   │   ┌─┴─╖         └───────┴─┤ · ╟───┐   ┌─┴─╖   │       │
           │   └───┤ ? ╟─┐                 ╘═╤═╝ ┌─┴───┤ · ╟─┐ │       │
           │       ╘═╤═╝ ├───────────────────┘   │     ╘═╤═╝ │ │       │
           │ ┌───╖ ┌─┴─╖ │               ┌─────┐ │ ┌───╖ │   │ │       │
           └─┤ › ╟─┤ › ║ │       ┌───╖ ┌─┴─╖   │ └─┤ − ╟─┘   │ │       │
             ╘═╤═╝ ╘═╤═╝ │     ┌─┤ ‼ ╟─┤ ‼ ║   │   ╘═╤═╝     │ │       │
               │   ┌─┴─╖ │     │ ╘═╤═╝ ╘═╤═╝ ┌─┴─╖ ┌─┴─╖     │ │       │
               ┌───┤ · ╟─┘     │ ┌─┴─╖   ├───┤ · ╟─┤ … ║     │ │       │
     ┌───┐     │   ╘═╤═╝       └─┤ · ╟───┘   ╘═╤═╝ ╘═╤═╝     │ │       │
     │ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖         ╘═╤═╝         │  ╔══╧═╗     │ │       │
     │ │ ʭ ╟─┤ ? ╟─┤ › ╟─┐ ╔═══╗ ╔═╧═╕         │  ║ 32 ║     │ │       │
     │ ╘═╤═╝ ╘═╤═╝ ╘═══╝ │ ║ 0 ╟─╢   ├─────────┘  ╚════╝     │ │       │
     │ ┌─┘   ┌─┴─╖       │ ╚═══╝ ╚═╤═╛                       │ │       │
     │ └─┬───┤ ʭ ╟─┐   ┌─┴─╖     ┌─┴─╖                       │ │       │
     │ ┌─┴─╖ ╘═══╝ ├───┤ · ╟─────┤ ɱ ║                       │ │       │
     └─┤ · ╟───────┘   ╘═╤═╝     ╘═╤═╝                       │ │       │
       ╘═╤═╝             │       ┌─┴─╖                       │ │       │
         │               └─────┬─┤ ◇ ╟───────────────────────┘ │       │
         │                     │ ╘═══╝                       ┌─┴─╖     │
         │                     └─────────────────────────────┤ · ╟─────┘
         │                                                   ╘═╤═╝
         └─────────────────────────────────────────────────────┘

สิ่งนี้ค่อนข้างตรงไปตรงมาเช่นกัน ใช้‹สำหรับแกะโครงสร้าง ใช้◇เพื่อสร้างเพชรใหม่ ใช้ɱ(map) เพื่อเพิ่มช่องว่างไปยังจุดเริ่มต้นและจุดสิ้นสุดของแต่ละสตริงในเพชรใหม่เพื่อให้มันมีความกว้างเท่ากัน ผนวก ( ʭ) สตริงใหม่ลงบนเก่า (ถ้าด้านล่าง) หรือเก่าไปยังใหม่ (ถ้าด้านบน); และสุดท้ายใช้›สร้างโครงสร้างที่มีค่าใหม่ทั้งหมด โดยเฉพาะอย่างยิ่งถ้าเราต่อท้ายที่ด้านล่าง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 ║
                                  ╘════╝ ╚════╝

andไอเอ็นจีสตริงกับ 2097151 ส่งกลับตัวอักษรตัวแรก >>ing โดย 21 ลบออก เราตรวจสอบเหตุผลทั้ง 0 และ −1 ตามที่อธิบายไว้ในหน้า esolangs ; สิ่งนี้ไม่เกี่ยวข้องกับความท้าทายนี้ แต่ฉันต้องการให้ฟังก์ชันไลบรารีถูกต้อง

⑧ ⬖แปลงตัวอักษรเป็นสแต็กเพชร

ฟังก์ชันนี้ใช้อักขระตัวเดียวและส่งกลับโครงสร้างสำหรับสแต็กแนวตั้งที่แสดงถึงอักขระหนึ่งตัว

                                   ╔════╗
                                   ║ 96 ║  ╓───╖
                                   ╚══╤═╝  ║ ⬖ ║
                        ┌───╖ ┌───╖ ┌─┴─╖  ╙─┬─╜
                    ┌───┤ ɗ ╟─┤ Ḟ ╟─┤ − ║    │
                    │   ╘═╤═╝ ╘═══╝ ╘═╤═╝    │
                    │   ┌─┴─╖         ├──────┘  ┌──┐
                    │   │ ɹ ║         │     ┌───┤  │
                    │   ╘═╤═╝   ┌─────┘     │   │  │
                  ╔═╧═╗ ┌─┴─╖ ┌─┴─╖         │  ┌┴┐ │
                  ║ 1 ╟─┤   ╟─┤ · ╟─────┐ ╔═╧═╕└┬┘ │
                  ╚═══╝ └─┬─╜ ╘═╤═╝   ┌─┴─╢   ├─┘ ┌┴┐
            ┌───────────┐ │     └─┐   │   ╚═╤═╛   └┬┘
          ┌─┴─╖         │ │ ┌───╖ │   └─┐ ╔═╧═╕ ┌──┴─╖ ╔═══╗
    ┌─────┤ · ╟───┐     │ └─┤ ◆ ╟─┘   ┌─┴─╢   ├─┤ << ╟─╢ 1 ║
 ┌──┴─┐   ╘═╤═╝   │     │   ╘═╤═╝     │   ╚═╤═╛ ╘════╝ ╚═╤═╝
 │ ┌──┴─╖ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖   ┌─┴─╖ ┌─┴─╖        ┌─┴─╖
 │ │ >> ╟─┤ ⬗ ╟─╢   ├─╢   ├─┤ ʩ ╟───┤ · ╟─┤ ʑ ╟────────┤ ⸗ ║
 │ ╘══╤═╝ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝   ╘═╤═╝ ╘═╤═╝        ╘═╤═╝
 │  ╔═╧═╗  ┌┴┐    │   ╔═╧═╗   │       └─────┘          ╔═╧═╗
 │  ║ 1 ╟─┐└┬┘    └───╢ 0 ║                            ║ 0 ║
 │  ╚═══╝ ├─┘         ╚═══╝                            ╚═══╝
 └────────┘

ฟังก์ชั่นนี้น่าสนใจเพราะเราต้องการให้เพชรถูกต่อท้ายสลับกับด้านล่างและด้านบน นี่คือวิธีที่ฉันทำ:

• ก่อนอื่นลบ 96 ( 'a'กลายเป็น 1) รับปัจจัยสำคัญ ( Ḟด้านบน) ใช้ɗเพื่อเพิ่มองค์ประกอบ 1 หากลำดับว่างเปล่าแล้วย้อนกลับ ( ɹ) คำสั่ง

• ถอดองค์ประกอบแรกออกและโทร◆เพื่อเริ่มการทำงานของสแต็ก

• ตอนนี้ใช้⸗เพื่อสร้างลำดับขี้เกียจที่เพียงแค่สลับตัวเลข 0 และ 1 ไปเรื่อย ๆ

• ใช้ʑ(zip) กับสิ่งนั้นและปัจจัยหลักที่เหลืออยู่ สำหรับแต่ละปัจจัยหลักให้เลื่อนไปทางซ้าย 1 และor0/1 ลงบน ตอนนี้เรามีลำดับที่เข้ารหัสหมายเลขเฉพาะและข้อมูลด้านบน / ล่าง

• สุดท้ายใช้ʩ(พับซ้าย / รวม) ค่าเริ่มต้นคือสแต็กที่เราสร้างขึ้นจากองค์ประกอบแรกข้างต้น สำหรับแต่ละค่าνการโทร⬗(ต่อท้ายเพชรใหม่) พร้อมกับสแต็กก่อนหน้าไพรม์ ( ν >> 1) และไม่ว่าจะเป็นด้านบนหรือล่าง ( ν & 1)

⑨โปรแกรมหลัก

ที่นี่เราทำงานหลัก

                       ┌─────┐
                       │   ┌─┴─╖
                       │   │ ⬖ ║
               ╔═══╗ ╔═╧═╕ ╘═╤═╝
               ║ 0 ╟─╢   ├───┘
               ╚═╤═╝ ╚═╤═╛ ┌───╖ ┌───╖ ╔═══╗
                 └─┐   └───┤ ɱ ╟─┤ ↯ ╟─╢   ║
       ┌─────────┐ └─────┐ ╘═╤═╝ ╘═══╝ ╚═══╝
       │       ┌─┴─╖     │ ┌─┴─╖
       │   ┌───┤ · ╟───┐ └─┤   ╟─┐
       │   │   ╘═╤═╝   │   └─┬─╜ │
       │ ┌─┴─╖ ╔═╧═╕ ╔═╧═╕ ┌─┴─╖ │
       │ │ ❖ ╟─╢   ├─╢   ├─┤ ʩ ╟─┘
       │ ╘═╤═╝ ╚═╤═╛ ╚═╤═╛ ╘═╤═╝
       └───┘   ╔═╧═╗   │   ┌─┴─╖ ┌─┐
               ║ 0 ╟───┘ ┌─┤ ‹ ╟─┴─┘
               ╚═══╝     │ ╘═══╝
                       ┌─┴─╖ ┌─┐
                     ┌─┤ ‹ ╟─┴─┘
                     │ ╘═══╝
      ╔════╗ ┌───╖ ┌─┴─╖ ┌─┐
      ║ 10 ╟─┤ ʝ ╟─┤ ‹ ╟─┴─┘
      ╚════╝ ╘═╤═╝ ╘═══╝
               │

ครั้งแรก map ( ɱ) มากกว่าตัวละครในสายป้อน (คน↯) ⬖และเปิดในแต่ละกองเพชรใช้ ถอดองค์ประกอบแรกออกแล้วพับ ( ʩ) ส่วนที่เหลือเพื่อต่อส่วนทั้งหมด ( ❖) สุดท้ายให้แกะโครงสร้างที่ใช้‹เพื่อไปยังลำดับของสตริงและรวมทั้งหมด ( ʝ) โดยใช้ 10 (ขึ้นบรรทัดใหม่) เป็นตัวคั่น

ตัวอย่างผลลัพธ์

การป้อนข้อมูล:

crusaders

ผลลัพธ์ (ใช้เวลาในการคำนวณ 9 วินาทีไม่สามารถโพสต์ที่นี่ได้เนื่องจากขนาด จำกัด )