Cho một từ chỉ bao gồm các chữ cái viết thường, làm như sau:

1. Đối với mỗi chữ cái, hãy lấy thừa số nguyên tố của vị trí của nó trong bảng chữ cái.
2. Đối với mỗi thừa số nguyên tố, p , vẽ một viên kim cương có độ dài cạnh p và dán chữ cái ở giữa viên kim cương.
3. Viên kim cương lớn nhất nằm ở giữa, những viên kim cương nhỏ hơn (từ lớn nhất đến nhỏ nhất) xen kẽ giữa đi xuống dưới hoặc trên cùng.

Lưu ý: Đối với lá thư một sử dụng một bên dài trong tổng số 1.

Ví dụ: con mèo

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

Sơ đồ:

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

Ví dụ: chó

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

Sơ đồ:

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

-20% tiền thưởng nếu chương trình của bạn xuất ra tệp văn bản có tên "[your-word] .txt". Sau đó, nhập một từ thực (hoặc cụm từ, viết thường không có khoảng trắng) dài ít nhất 20 chữ cái và chưa có ai chọn, và dán đầu ra giữa a <pre>và a </pre>trong câu trả lời của bạn.

Matlab, 466 393 - 20% = 314,4 byte

Golfed: (Có thể tiết kiệm thêm một số byte, cũng nhờ sự giúp đỡ của @ 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

Nó cũng hoạt động trong Octave (mã nguồn mở), nhưng chỉ với rất nhiều cảnh báo. Sử dụng phiên bản này nếu bạn muốn dùng thử trong quãng tám (đầu ra cho bàn điều khiển, thay vì tệp):

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 và giải thích:

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

Từ được yêu cầu: (Và đây là một tệp: (thu nhỏ rất nhiều): supercalifragilisticexpialidocious.txt )

                       . . .                   
                      . . . . . .                  
                     . . . . . .                 
                    . . . . . .                
                   . . . . . .               
                  . . . . . .              
                 . . . . . .             
                . . . . . .            
               . . . . . .           
              . . . . . . .          
             . . . . . . . .         
            . . . . . . . . . t. . . . .        
           . . . . . . . . . . . . . . . . . . . . . . . . .       
          . . . . . . . r. . l. . r. . . . l. . . . . x. . . . l. . . . .      
         . . . . . tr. . . . . . . . . . . . . . . . . . . tr. . . . . . . . .     
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
    . 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 .
     . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
      . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .  
       . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .   
        . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .    
         . . . . . tr. . . . . . . . . . . . . . . . . . . . . . . . . . . . . tr. . . . . . . . d. . . . . . . . .     
          . . . . . . . . . l. . . . f. . . . . . . . l. . . . . . . . . x. . . . . . l. . . . . . . . . . . . .      
           . . . . . r. . . . tôi . . . r. . . tôi . . . tôi . . . . . tôi . . . . tôi . . . tôi . . . . tôi . . . . .       
            . . . . . . . . . . . . . . . . . . . . t. . . . . . . . . . . . . . . . . . .        
             . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . o. . . . o. . . . .         
              . . . . . tr. . . . . . . . . . . . . tr. . . . . . . . . . . .          
               . . . bạn . . . . . x. . . . . . . . bạn . .           
                . . . . . . . . . . . . . . . .            
                 . . . . . . . . . . .             
                  . . . . . . . .              
                   . . . . . .               
                    . . . . . .                
                     . . . . . .                 
                      . . . . . .                  
                       . . .                   

Funciton , không cạnh tranh, 29199 byte

Tôi rất thích thử thách này vì nó nhấn mạnh việc thiếu một số chức năng thư viện rất hữu ích. Tôi sẽ bao gồm tất cả các hàm đó ở đây (và trong số byte) vì tôi đã viết chúng sau khi thử thách này được đăng.

Nguồn đầy đủ trong một tệp duy nhất

Giải trình

Như mọi khi, có được kết xuất tốt hơn bằng cách thực hiện javascript:(function(){$('pre,code').css({lineHeight:5/4});})()trong bảng điều khiển trình duyệt của bạn.

① ɹ ⇄Xếp

Như bạn có thể biết hoặc không biết, Funciton đi kèm với một thư viện chứa đầy đủ các hàm cho danh sách , là các giá trị được mã hóa trong một số nguyên đơn lẻ, cũng như một thư viện riêng cho các chuỗi được đánh giá lười biếng , sử dụng các biểu thức lambda (hàm ẩn danh) trong để được lười biếng. Tất nhiên cũng có một thư viện cho các hàm xử lý chuỗi.

Đối với thử thách này, tôi cần một hàm để đảo ngược chuỗi và một hàm để đảo ngược chuỗi được đánh giá lười biếng. Đáng ngạc nhiên, tôi chỉ có một danh sách - chính xác là danh sách tôi không cần. Vì vậy, đây là các hàm đảo ngược cho chuỗi lười biếng ( ɹ) và cho chuỗi ( ⇄):

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

Trình tự lười biếng mà người ta sử dụng ʬ, đó là phần tử gắn thêm một phần tử vào cuối chuỗi lười biếng. Chuỗi một sử dụng ʃ(chuỗi con) và ‼(chuỗi nối).

② ṖPrimes

Mặc dù tôi có thể thực hiện thừa số nguyên tố bằng cách chỉ cần chia n cho tất cả các yếu tố theo thứ tự, tôi quyết định tôi muốn một hàm thư viện tạo ra các số nguyên tố. Hàm sau lấy một số nguyên n và thực hiện Sàng của Eratosthenes để tạo ra tất cả các số nguyên tố lên đến n . Nó thực hiện điều này như một chuỗi lười biếng, vì vậy nó sẽ chỉ tạo ra nhiều số nguyên tố như bạn thực sự đánh giá.

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

Hàm trợ giúp Ṗp, mất:

• Một bộ đếm đang chạy mà cứ giảm dần cho đến khi nó về 0.

• Sàng, có một chút thiết lập cho mỗi số đã được biết là không nguyên tố. Ban đầu, bit có ý nghĩa ít nhất đại diện cho số 2, nhưng chúng tôi thay đổi quyền này với mỗi lần lặp.

• Một số n chỉ số nào được biểu thị bằng bit thấp nhất của sàng; điều này được tăng lên với mỗi lần lặp.

Ở mỗi lần lặp, nếu bit thấp nhất của sàng là 0, chúng ta đã tìm thấy một số nguyên tố n . Sau đó, chúng tôi sử dụng công thức tôi đã mô tả trong Điền vào các hàng, cột và đường chéo của lưới NxN để đặt mọi bit thứ n trong sàng trước khi chuyển sang lần lặp tiếp theo.

Nhân Ḟtố chính

                             ╓───╖
                             ║ Ḟ ║
                             ╙─┬─╜
                       ┌───────┴──────┐
                       │ ┌───╖ ┌────╖ │
                       └─┤ Ṗ ╟─┤ Ḟp ╟─┘
                         ╘═══╝ ╘═╤══╝
                                 │
               ┌────────────────────────────────────────────┐
               │                                     ╓┬───╖ │
       ┌───────┴─┐     ┌───────────────────────┐   ┌─╫┘Ḟp ╟─┘
       │ ╔═══╗ ┌─┴─╖ ┌─┴─╖ ┌───┐ ┌────╖      ┌─┴─╖ │ ╙────╜
       │ ║ 0 ╟─┤   ╟─┤ · ╟─┘┌┐ └─┤ Ḟp ╟──┐ ┌─┤ · ╟─┴──┐
       │ ╚═══╝ └─┬─╜ ╘═╤═╝  └┤   ╘═╤══╝  ├─┘ ╘═╤═╝    │
       │       ┌─┴─┐ ┌─┴─╖ ╔═╧═╕ ┌─┴─╖ ┌─┴─╖ ┌─┴──╖ ┌─┴─╖
       │       │   └─┤ · ╟─╢   ├─┤ ? ╟─┤ · ╟─┤ ÷% ╟─┤ · ╟─┐
       │       │     ╘═╤═╝ ╚═╤═╛ ╘═╤═╝ ╘═╤═╝ ╘═╤══╝ ╘═╤═╝ │
       │       │    ┌──┴─╖   │   ┌─┴─╖ ┌─┴─╖   └──────┘   │
       │       │    │ Ḟp ╟───┘ ┌─┤ ? ╟─┤ ≤ ║              │
       │     ┌─┴─╖  ╘══╤═╝     │ ╘═╤═╝ ╘═╤═╝              │
       └─────┤ · ╟─────┘     ╔═╧═╗ │   ╔═╧═╗              │
             ╘═╤═╝           ║ 0 ║     ║ 2 ║              │
               │             ╚═══╝     ╚═══╝              │
               └──────────────────────────────────────────┘

Điều này là khá đơn giản. Chỉ cần lặp qua các số nguyên tố lên đến n và xem cái nào chia n . Nếu một người chia n , hãy nhớ tiếp tục với cùng một số nguyên tố để chúng ta trả lại nhiều lần nếu nó chia n nhiều lần. Điều này trả về chuỗi trống cho bất kỳ số nào nhỏ hơn 2.

④ ◇ ◆Tạo một viên kim cương

Hàm này tạo ra một viên kim cương duy nhất cho một ký tự và bán kính. Nó chỉ sử dụng nhân vật để đặt nó vào trung tâm của viên kim cương.

                                   ┌───╖
             ┌─────────────────────┤ ♯ ╟───────────┬─────────┐
             │ ┌───╖ ╔═══╗   ┌───┐ ╘═══╝           │         │
             └─┤ ♫ ╟─╢ 0 ║   │ ┌─┴─╖               │         │
               ╘═╤═╝ ╚═══╝   │ │ ʭ ╟───┐           │         │
               ┌─┴─╖   ┌─────┘ ╘═╤═╝   │           │         │
               │ ɱ ╟───┤ ┌───╖ ┌─┴─╖ ╔═══╗   ╓───╖ │         │
               ╘═╤═╝   └─┤ ɹ ╟─┤ ʓ ╟─╢ 1 ║ ┌─╢ ◇ ╟─┤         │
                 │ ╔═══╗ ╘═══╝ ╘═══╝ ╚═══╝ │ ╙───╜ │         │
                 │ ║ 0 ║                   │     ┌─┴─╖       │
                 │ ╚═╤═╝                   │     │ ♭ ║       │
               ╔═╧═╕ │   ╔════╗            │     ╘═╤═╝       │
           ┌───╢   ├─┘ ┌─╢ 21 ║          ┌─┴─╖   ┌─┴─╖     ┌─┴─┐
           │   ╚═╤═╛   │ ╚════╝ ┌────────┤ · ╟───┤ · ╟─┐ ┌─┴─╖ │
           │   ┌─┴─╖ ┌─┴──╖ ┌───┘        ╘═╤═╝   ╘═╤═╝ ├─┤ = ║ │
           │ ┌─┤ ‼ ╟─┤ >> ║ │              │     ┌─┴─╖ │ ╘═╤═╝ │
           │ │ ╘═══╝ ╘═╤══╝ │              │   ┌─┤ ? ╟─┘   │   │
           │ │   ┌───╖ │ ┌──┘              │   │ ╘═╤═╝     │   │
           │ └─┬─┤ ⇄ ╟─┘ │     ┌─────┐     │   │ ┌─┴─╖     │   │
           │   │ ╘═══╝ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ └─┤ · ╟──┬──┘   │
           │   └───────┤ · ╟─┤ ? ╟─┤ · ╟─┤ ‼ ║   ╘═╤═╝  │      │
           │           ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝   ┌─┴─╖  │      │
           │             └─────┘     └─┬───┘ ┌───┤ … ║  │      │
           │               ┌─────┐     │     │   ╘═╤═╝  │      │
           │            ╔══╧═╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ╔═╧══╗ │      │
           │            ║ 32 ║ │ … ╟─┤ ‼ ╟─┤ ‼ ║ ║ 32 ║ │      │
           │            ╚════╝ ╘═╤═╝ ╘═══╝ ╘═╤═╝ ╚════╝ │      │
           │                   ┌─┴─╖       ╔═╧══╗       │      │
           │               ┌───┤ − ╟───┬─┐ ║ 46 ║       │      │
           │             ┌─┴─╖ ╘═══╝   │ │ ╚════╝       │      │
           └─────────────┤ · ╟─────────┘ └──────────────┘      │
                         ╘═╤═╝                                 │
                           └───────────────────────────────────┘

Điều này làm cho việc sử dụng nặng các trình tự lười biếng. Đây là cách nó hoạt động:

• Tạo chuỗi số nguyên từ 0 đến r (đã bao gồm).

• Đối với mỗi số nguyên như α , tạo ra một chuỗi gồm ( r - α ) không gian ( …), tiếp theo là một dấu chấm, tiếp theo là α không gian - trừ khi α = r , trong trường hợp này tạo ra một không gian ít hơn và thêm lá thư. Bây giờ chúng ta có quý trên cùng bên trái của viên kim cương.

• Đối với mỗi chuỗi này, nối thêm một bản sao khác của cùng một chuỗi, nhưng với các ký tự đảo ngược ( ⇄) và sau đó ký tự đầu tiên bị xóa ( >> 21). Bây giờ chúng ta có nửa trên của viên kim cương.

• Lấy chuỗi này và nối với nó cùng một chuỗi, nhưng đảo ngược ( ɹ) và với phần tử đầu tiên bị loại bỏ ( ʓ). Bây giờ chúng ta có toàn bộ kim cương.

Bây giờ chúng ta có các chuỗi tạo nên kim cương, nhưng chúng ta cần thêm một chút thông tin. Chúng ta cần biết vị trí giữa của viên kim cương. Ban đầu đây là khóa học r , nhưng một khi chúng ta đã gắn các viên kim cương khác lên trên cùng và dưới cùng của nó, chúng ta sẽ cần theo dõi vị trí của viên kim cương giữa trung gian để chúng ta có thể sắp xếp theo chiều dọc các khối kim cương khác một cách chính xác . Điều tương tự cũng xảy ra đối với phạm vi ngang của viên kim cương (cần điều đó khi gắn kim cương vào đỉnh và đáy). Tôi cũng quyết định theo dõi bức thư; Tôi cần điều đó bởi vì nếu không thì hàm ⬗(mà chúng ta có trong phần tiếp theo) sẽ phải có bốn tham số, nhưng Funciton chỉ cho phép ba tham số.

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

Chúng tôi sử dụng API danh sách ( ›thêm các phần tử vào phía trước danh sách) để tạo cấu trúc chứa [ x , y , c , q ], trong đó x là tọa độ x của tâm ngang của hình thoi, y là y- tọa độ của đường cơ sở, c là chữ cái và q là chuỗi lười biếng của chuỗi. Cấu trúc này sẽ được sử dụng để chứa tất cả các giai đoạn trung gian kể từ bây giờ.

⑤ ⬗Nối kim cương theo chiều dọc

Hàm này lấy một ngăn xếp kim cương hiện có, bán kính và boolean cho biết nên thêm viên kim cương mới vào đỉnh (đúng) hay dưới cùng (sai).

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

Điều này cũng khá đơn giản; sử dụng ‹để giải nén cấu trúc; sử dụng ◇để tạo ra kim cương mới; sử dụng ɱ(bản đồ) để thêm khoảng trắng vào đầu và cuối của mỗi chuỗi trong viên kim cương mới sao cho tất cả đều có cùng chiều rộng; nối ( ʭ) các chuỗi mới vào cũ (nếu dưới) hoặc cũ lên mới (nếu trên cùng); và cuối cùng sử dụng ›để xây dựng cấu trúc chứa tất cả các giá trị mới. Cụ thể, nếu chúng ta đang nối vào đáy, y sẽ không thay đổi, nhưng nếu chúng ta đang nối vào đỉnh, y phải tăng thêm ♯(r << 1)( r là bán kính của viên kim cương mới).

Ghép các ❖ngăn xếp theo chiều ngang

Đây là chức năng lớn nhất của tất cả chúng. Tôi sẽ không phủ nhận rằng nó khá khó khăn để có được điều này đúng. Phải mất hai ngăn xếp và nối chúng theo chiều ngang trong khi tôn trọng sự liên kết dọc chính xác.

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

Đây là cách nó hoạt động.

• Đầu tiên, đối với mỗi ngăn xếp, tạo một chuỗi vô hạn ( ⁞) chuỗi, mỗi chuỗi chứa khoảng trắng ( …) theo chiều rộng của ngăn xếp đó.

• Các giá trị y của các ngăn xếp cho chúng ta biết ai cần phải di chuyển xuống và điều đó là bao nhiêu. Chuẩn bị chuỗi không gian thích hợp, cắt ngắn ( ȶ) theo đúng độ dài ( y1 - y2 hoặc y2 - y1 nếu phù hợp).

• Bây giờ hãy xác định độ dài của từng chuỗi chuỗi ( ɕ), cho chúng ta biết chiều cao của chúng. Tìm xem cái nào cao hơn.

• Nối các chuỗi không gian vô hạn vào cả hai ngăn xếp.

• Sử dụng zip ( ʑ) để đặt chúng lại với nhau. Đối với mỗi cặp chuỗi, nối chúng ( ‼) cùng với một khoảng trắng ở giữa.

• Sau đó sử dụng ȶđể cắt kết quả của nó đến chiều cao cao nhất. Bằng cách thực hiện điều này muộn, chúng ta không cần phải quan tâm ai trong số họ cần phần đệm.

Cuối cùng, tạo cấu trúc một lần nữa. Tại thời điểm này, chúng ta không còn cần ký tự trong các viên kim cương nữa, vì vậy chúng ta đặt giá trị đó thành 0. Giá trị x chỉ được tính tổng và tăng (để chiều rộng của ngăn xếp vẫn có thể được tính là ♯(x << 1)). Các y trị được đặt thành một cao hơn của cả hai.

⑦ ↯lặp trên ký tự trong một chuỗi

Đây là một chức năng hữu ích khác mà tôi sẽ thêm vào thư viện. Đưa ra một chuỗi, nó cung cấp cho bạn một chuỗi lười biếng chứa mỗi mã ký tự.

                                        ╓───╖
                                        ║ ↯ ║
                                        ╙─┬─╜
                           ┌──────────────┴────────────────┐
                           │      ┌─┐          ╔═══╗ ┌───╖ │
                           │      └─┤     ┌────╢ 0 ╟─┤ ≠ ╟─┴─┐
                    ┌──────┴─┐ ┌┐ ╔═╧═╕ ┌─┴─╖  ╚═══╝ ╘═╤═╝   │
                    │        ├─┤├─╢   ├─┤ ? ╟──────────┤     │
                    │        │ └┘ ╚═╤═╛ ╘═╤═╝ ╔════╗ ┌─┴─╖   │
                    │ ╔══════╧══╗ ┌─┴─╖   │   ║ −1 ╟─┤ ≠ ╟───┘
                    │ ║ 2097151 ║ │ ↯ ║       ╚════╝ ╘═══╝
                    │ ╚═════════╝ ╘═╤═╝
                    │             ┌─┴──╖ ╔════╗
                    └─────────────┤ >> ╟─╢ 21 ║
                                  ╘════╝ ╚════╝

anding một chuỗi với 2097151 trả về ký tự đầu tiên. >>ing nó bởi 21 loại bỏ nó. Chúng tôi kiểm tra cả 0 và for1 vì một lý do được giải thích trong trang esolangs ; Điều này không liên quan đến thử thách này, nhưng tôi muốn chức năng thư viện là chính xác.

⑧ ⬖Chuyển đổi nhân vật để ngăn xếp kim cương

Hàm này nhận một ký tự và trả về cấu trúc cho ngăn xếp dọc biểu thị cho một ký tự đó.

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

Chức năng này rất thú vị vì chúng ta cần những viên kim cương được gắn xen kẽ vào đáy và đỉnh. Đây là cách tôi đã làm:

• Đầu tiên, trừ 96 ( 'a'trở thành 1), lấy các thừa số nguyên tố ( Ḟở trên), sử dụng ɗđể thêm phần tử 1 nếu chuỗi trống, sau đó đảo ngược ( ɹ) thứ tự.

• Lấy phần tử đầu tiên ra và gọi ◆để khởi động ngăn xếp.

• Bây giờ, sử dụng ⸗để tạo ra một chuỗi lười biếng chỉ xen kẽ các số 0 và 1 vô thời hạn.

• Sử dụng ʑ(zip) trên đó và các yếu tố chính còn lại. Đối với mỗi yếu tố chính, hãy dịch chuyển nó sang trái 1 và or0/1 vào nó. Bây giờ chúng ta có một chuỗi mã hóa các số nguyên tố và thông tin trên cùng / dưới cùng.

• Cuối cùng, sử dụng ʩ(gấp trái / tổng hợp). Giá trị ban đầu là ngăn xếp mà chúng ta đã tạo từ phần tử đầu tiên ở trên. Đối với mỗi giá trị ν , hãy gọi ⬗(nối một viên kim cương mới) với ngăn xếp trước đó, số nguyên tố ( ν >> 1) và cho dù trên hay dưới ( ν & 1).

Chương trình chính

Ở đây chúng tôi làm công việc chính.

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

Đầu tiên, ánh xạ ( ɱ) qua các ký tự trong chuỗi đầu vào ( ↯) và biến từng ký tự thành một ngăn xếp kim cương bằng cách sử dụng ⬖. Lấy phần tử đầu tiên ra khỏi đó và gập ( ʩ) trên phần còn lại để nối tất cả chúng ( ❖). Cuối cùng, giải nén cấu trúc bằng cách sử dụng ‹chuỗi chuỗi và nối tất cả chúng ( ʝ) bằng cách sử dụng 10 (dòng mới) làm dấu phân cách.

Ví dụ đầu ra

Đầu vào:

crusaders

Đầu ra (mất 9 giây để tính toán; không thể đăng ở đây vì giới hạn kích thước).