शब्दों की कल्पना करना

Question

केवल निचले अक्षरों से मिलकर बने शब्द को देखते हुए, निम्नलिखित करें:

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>।

Comments

आपके उदाहरण आकार p + 1 डॉट्स के हीरे का उपयोग करने लगते हैं ...

— Jaykul

@ जयकुल अच्छा सवाल। पक्ष की लंबाई डॉट्स के बीच रिक्त स्थान की संख्या से निर्धारित होती है।

— जियोकॉवेल

Answer 1

मतलाब , 466 393 - 20% = 314.4 बाइट्स

गोल्फ: (@ 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

यह ऑक्टेव (ओपनसोर्स) में भी काम करना चाहिए, लेकिन केवल बहुत सारी चेतावनियों के साथ। यदि आप इसे ओक्टेव (आउटपुट को कंसोल, फ़ाइल के बजाय) में आज़माना चाहते हैं, तो इस संस्करण का उपयोग करें:

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

असंगठित और समझाया गया:

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

अनुरोधित शब्द: (और यहां एक फ़ाइल के रूप में: (बहुत बाहर ज़ूम करें): supercalifragilisticexpialidocert.txt )

                       । । ।                   
                      । । । । । ।                  
                     । । । । । ।                 
                    । । । । । ।                
                   । । । । । ।               
                  । । । । । ।              
                 । । । । । ।             
                । । । । । ।            
               । । । । । ।           
              । । । । । । ।          
             । । । । । । । ।         
            । । । । । । । । । टी। । । । ।        
           । । । । । । । । । । । । । । । । । । । । । । । । ।       
          । । । । । । । आर। । एल। । आर। । । । एल। । । । । एक्स । । । । एल। । । । ।      
         । । । । । पी। । । । । । । । । । । । । । । । । । । पी। । । । । । । । ।     
        । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।    
       । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।   
      । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।  
     । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।
    । 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। ।
     । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।
      । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।  
       । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।   
        । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ।    
         । । । । । पी। । । । । । । । । । । । । । । । । । । । । । । । । । । । । पी। । । । । । । । d। । । । । । । । ।     
          । । । । । । । । । एल। । । । च। । । । । । । । एल। । । । । । । । । एक्स । । । । । । एल। । । । । । । । । । । । ।      
           । । । । । आर। । । । मैं । । । । आर। । । मैं । । । । मैं । । । । । । मैं । । । । । मैं । । । । मैं । । । । । मैं । । । । । ।       
            । । । । । । । । । । । । । । । । । । । । टी। । । । । । । । । । । । । । । । । । ।        
             । । । । । । । । । । । । । । । । । । । । । । । । । । । । । । ओ। । । । ओ। । । । ।         
              । । । । । पी। । । । । । । । । । । । । पी। । । । । । । । । । । ।          
               । । । यू। । । । । । एक्स । । । । । । । । यू। । ।           
                । । । । । । । । । । । । । । । ।            
                 । । । । । । । । । । ।             
                  । । । । । । । ।              
                   । । । । । ।               
                    । । । । । ।                
                     । । । । । ।                 
                      । । । । । ।                  
                       । । ।                   

Comments

A=A(find(sum(A,2)),find(sum(A)));एक कदम में गद्दी हटाने के लिए पर्याप्त नहीं होगा?

— एंड्रस डीक

जब मैंने दो <pre>टैग के बीच आउटपुट टेक्स्ट को चिपकाया तो मुझे वास्तव में सही परिणाम मिले । आप ऐसा क्यों नहीं करते!

— 1

क्या आप सुनिश्चित हैं कि आपको आवश्यकता है sort(factor())? MATLAB factorपहले से ही हल किया जा रहा है। और आप के लिए एक चर को परिभाषित कर सकते हैं max(f), क्योंकि आप एक ही मात्रा में दो बार उपयोग कर रहे हैं।

— एंड्रास डेक

@geokavel मेरा मानना ​​है कि आप इसे दूसरे तरीके से देख रहे हैं :) से [[बाइबल] (en.wikipedia.org): MATLAB -> "प्रारंभिक रिलीज़ - 1984", GNU ऑक्टेव -> प्रारंभिक रिलीज़ - 1988 "। कैसे क्या यह है कि मैथवर्क्स अपने वाणिज्यिक उत्पाद को इस तरह के मामूली विवरणों तक कॉपी करने की अनुमति देता है? या यदि आप सिर्फ इसका मतलब यह है कि यह अभी भी लाभदायक क्यों है: मुझे यकीन है कि उपलब्ध MATLAB टूलबॉक्स और फीचर्स अच्छी तरह से ओक्टेव को प्रभावित करते हैं (हालांकि ऑक्टेव का सिंटैक्स कभी-कभी समृद्ध होता है) )। गति का उल्लेख नहीं है (मुझे लगता है)।

— एंड्रास डीक

@geokavel यह है जैसा कि एंड्रासडेक ने कहा: ऑक्टेव मतलाब का एक क्लोन है, लेकिन दुर्भाग्य से एक आदर्श नहीं है, क्योंकि डेवलपर्स ने भी भाषा में सुधार करने की कोशिश की। यहाँ एक थोड़ा संशोधित संस्करण है कि ऑनलाइन भी दुभाषिया में काम करता है: goo.gl/Jk7mpV

— flawr

Answer 2

फंकिटॉन , गैर-प्रतिस्पर्धी, 29199 बाइट्स

मुझे इस चुनौती का आनंद मिला क्योंकि इसने कुछ बहुत उपयोगी पुस्तकालय कार्यों की कमी को उजागर किया। मैं उन सभी कार्यों को यहां (और बाइट की गिनती में) शामिल करूंगा क्योंकि मैंने उन्हें इस चुनौती के पोस्ट होने के बाद लिखा था।

एकल फ़ाइल में पूर्ण स्रोत

व्याख्या

हमेशा की तरह, javascript:(function(){$('pre,code').css({lineHeight:5/4});})()अपने ब्राउज़र कंसोल में निष्पादित करके एक बेहतर प्रतिपादन प्राप्त करें।

① ɹ ⇄उल्टा

जैसा कि आप जानते हैं या नहीं जान सकते हैं, फ़ंसीटन सूचियों के लिए फ़ंक्शंस से भरी एक लाइब्रेरी के साथ आता है , जो एक एकल ह्यूमरस पूर्णांक में एन्कोड किए गए मान हैं, साथ ही आलसी-मूल्यांकन वाले अनुक्रमों के लिए एक अलग लाइब्रेरी है , जिसमें लैम्ब्डा एक्सप्रेशन (अनाम फ़ंक्शन) का उपयोग किया जाता है आलसी होने का आदेश। बेशक स्ट्रिंग हैंडलिंग कार्यों के लिए एक पुस्तकालय भी है।

इस चुनौती के लिए, मुझे एक स्ट्रिंग को रिवर्स करने के लिए एक फ़ंक्शन और एक आलसी-मूल्यांकन अनुक्रम को रिवर्स करने के लिए एक फ़ंक्शन की आवश्यकता थी। हैरानी की बात है, मैं केवल सूचियों के लिए एक था - वास्तव में एक जिसकी मुझे जरूरत नहीं थी। तो यहाँ आलसी दृश्यों के लिए उल्टे कार्य हैं ( ɹ) और तार के लिए ( ⇄):

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

आलसी-क्रम एक का उपयोग करता है ʬ, जो "आलसी अनुक्रम के अंत में एक तत्व को जोड़ता है"। स्ट्रिंग एक का उपयोग करता है ʃ(प्रतिस्थापित) और ‼(स्ट्रिंग समवर्ती)।

② Ṗप्राइम्स

हालाँकि, मैं सभी कारकों द्वारा n को विभाजित करने की कोशिश करके प्रधान गुणनखंडन कर सकता था , फिर भी मैंने निर्णय लिया कि मुझे एक पुस्तकालय समारोह चाहिए जो अभाज्य संख्याएँ उत्पन्न करे। निम्न फ़ंक्शन एक पूर्णांक n लेता है और सभी प्राइम संख्याओं को n तक उत्पन्न करने के लिए Eratosthenes की छलनी को लागू करता है । यह एक आलसी अनुक्रम के रूप में करता है, इसलिए यह केवल उतने ही प्राइम उत्पन्न करेगा जितना आप वास्तव में मूल्यांकन करते हैं।

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

सहायक कार्य Ṗp, लेता है:

• एक रनिंग काउंटर जो केवल 0 तक पहुंचने तक घटता रहता है।

• छलनी, जिसमें प्रत्येक संख्या के लिए थोड़ा सा सेट होता है जो पहले से ही ज्ञात नहीं है-प्रधान है। प्रारंभ में, कम से कम महत्वपूर्ण बिट नंबर 2 का प्रतिनिधित्व करता है, लेकिन हम प्रत्येक पुनरावृत्ति के साथ इस अधिकार को स्थानांतरित करते हैं।

• एक संख्या n जो यह दर्शाता है कि छलनी की सबसे कम बिट द्वारा किस संख्या को दर्शाया गया है; यह हर पुनरावृत्ति के साथ बढ़ा हुआ है।

प्रत्येक पुनरावृत्ति पर, अगर छलनी सबसे कम 0 है, तो हमने एक प्राइम एन पाया है । फिर हम उस सूत्र का उपयोग करते हैं जो मैंने पहले ही वर्णित है NxN ग्रिड की पंक्तियों, स्तंभों और विकर्णों को अगले पुनरावृत्ति में जाने से पहले छलनी में प्रत्येक n- बिट को सेट करने के लिए।

Ization Ḟप्रधान कारक

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

यह काफी सीधा-सीधा है। बस n तक के primes के माध्यम से पुनरावृत्ति करें और देखें कि कौन से व्यक्ति n को विभाजित करते हैं । यदि कोई n को विभाजित करता है , तो उसी प्राइम के साथ ले जाना याद रखें ताकि हम इसे कई बार लौटाएं यदि यह n को कई बार विभाजित करता है। यह किसी भी संख्या में 2 से कम के लिए खाली क्रम देता है।

Diamond ◇ ◆हीरा पैदा करो

यह फ़ंक्शन एक एकल हीरे को एक चरित्र और एक त्रिज्या देता है। यह केवल हीरे के केंद्र में रखने के लिए चरित्र का उपयोग करता है।

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

यह आलसी दृश्यों का भारी उपयोग करता है। यहां देखिए यह कैसे काम करता है:

• पूर्णांकों के क्रम को 0 से r (समावेशी) तक उत्पन्न करें ।

• प्रत्येक ऐसे पूर्णांक α के लिए , ( r - α ) रिक्त स्थान ( …) से युक्त एक स्ट्रिंग उत्पन्न करें , उसके बाद एक बिंदु, जिसके बाद α रिक्त स्थान होता है - जब तक कि α = r , जिसमें स्थिति एक कम स्थान उत्पन्न करती है और पत्र को जोड़ती है। अब हमारे पास हीरे का शीर्ष-बाएँ भाग है।

• इन तारों में से प्रत्येक के लिए, उसी स्ट्रिंग की एक और प्रति संलग्न करें, लेकिन पात्रों के साथ उलट ( ⇄) और फिर पहले वर्ण को हटा दिया ( >> 21)। अब हमारे पास हीरे का आधा हिस्सा है।

• इस अनुक्रम को लें और इसे उसी क्रम में जोड़ें, लेकिन उलटा ( ɹ) और पहले तत्व को हटा दिया गया ( ʓ)। हमारे पास अब पूरा हीरा है।

अब हमारे पास ऐसे तार हैं जो हीरे को बनाते हैं, लेकिन हमें थोड़ी और जानकारी चाहिए। हमें यह जानने की जरूरत है कि हीरे का ऊर्ध्वाधर मध्य कहां है। प्रारंभ में यह निश्चित रूप से आर का है , लेकिन एक बार जब हमने अन्य हीरे को ऊपर और नीचे से जोड़ दिया है, तो हमें "मध्य" हीरे की स्थिति पर नज़र रखने की आवश्यकता होगी ताकि हम हीरे के अन्य ढेर को सही ढंग से संरेखित कर सकें । वही हीरे की क्षैतिज सीमा के लिए जाता है (जरूरत है कि जब हीरे को ऊपर और नीचे से जोड़ दिया जाए)। मैंने पत्र पर नज़र रखने का भी फैसला किया; मुझे इसकी आवश्यकता है क्योंकि अन्यथा फ़ंक्शन ⬗(जो हमें अगले भाग में मिलता है) में चार पैरामीटर होने चाहिए, लेकिन फ़ंसीटोन केवल तीन की अनुमति देता है।

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

हम सूची का उपयोग करते हैं एपीआई ( ›तत्वों को एक सूची के सामने जोड़ता है) एक संरचना बनाने के लिए [ x , y , c , q ], जहां x हीरे के क्षैतिज केंद्र का x- समन्वय है, y y है- बेसलाइन का समन्वय, c अक्षर है और q तार का आलसी अनुक्रम है। इस संरचना का उपयोग अब से सभी मध्यवर्ती चरणों को समाहित करने के लिए किया जाएगा।

⑤ ⬗हीरे को लंबवत रूप से लगाएं

यह फ़ंक्शन एक मौजूदा डायमंड स्टैक, एक त्रिज्या और एक बूलियन लेता है जो दर्शाता है कि नए हीरे को शीर्ष (सच्चा) या निचला (झूठा) जोड़ना है या नहीं।

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

यह काफी सीधा-आगे भी है; ‹संरचना को अनपैक करने के लिए उपयोग ; ◇नए हीरे उत्पन्न करने के लिए उपयोग ; ɱनए हीरे में प्रत्येक स्ट्रिंग की शुरुआत और अंत में रिक्त स्थान जोड़ने के लिए (मानचित्र) का उपयोग करें ताकि यह सभी की चौड़ाई समान हो; परिशिष्ट ( ʭ) नए तार पुराने (यदि नीचे) या पुराने पर नए (यदि शीर्ष); और अंत ›में सभी नए मूल्यों वाले ढांचे के निर्माण के लिए उपयोग करें। विशेष रूप से, यदि हम नीचे की ओर अपील कर रहे हैं, तो y परिवर्तन नहीं करता है, लेकिन यदि हम शीर्ष पर जोड़ रहे हैं, तो y को बढ़ना चाहिए ♯(r << 1)( r नए हीरे की त्रिज्या है)।

⑥ ❖जुटना क्षैतिज स्टैक्स

यह उन सभी का सबसे बड़ा कार्य है। मैं इस बात से इनकार नहीं करूंगा कि यह अधिकार प्राप्त करने के लिए यह बहुत ही उचित था। यह दो स्टैक लेता है और सही ऊर्ध्वाधर संरेखण का सम्मान करते हुए उन्हें क्षैतिज रूप से समतल करता है।

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

यहां देखिए यह कैसे काम करता है।

• सबसे पहले, प्रत्येक स्टैक के लिए, ⁞स्ट्रिंग्स की अनंत अनुक्रम ( ) उत्पन्न करें , जिनमें से प्रत्येक में …स्टैक की चौड़ाई के अनुसार रिक्त स्थान ( ) शामिल हैं ।

• Y के ढेर के मूल्यों हमें बताओ जो "नीचे ले जाने के लिए" और कितना द्वारा एक जरूरत है। उपयुक्त स्थान अनुक्रम, ȶसही लंबाई ( y1 - y2 या y2 - y1 उपयुक्त) पर छोटा करें।

• अब प्रत्येक स्ट्रिंग अनुक्रम ( ɕ) की लंबाई निर्धारित करें , जो हमें उनकी ऊंचाई बताता है। पता करें कि कौन सा लंबा है।

• दोनों ढेर के लिए अनंत अंतरिक्ष दृश्यों को जोड़ें।

• ʑउन्हें एक साथ रखने के लिए जिप ( ) का उपयोग करें । तार के प्रत्येक जोड़े के लिए, उन्हें ( ‼) को बीच में एक अतिरिक्त स्थान के साथ मिलाएं ।

• फिरȶ सबसे लंबी ऊंचाई तक उस परिणाम को छोटा करने के लिए उपयोग करें। देर से ऐसा करने से, हमें यह ध्यान रखने की ज़रूरत नहीं है कि उनमें से किसे पैडिंग की आवश्यकता है।

अंत में, फिर से संरचना उत्पन्न करें। इस बिंदु पर, हमें अब हीरे में चरित्र की आवश्यकता नहीं है, इसलिए हम सेट करते हैं कि 0. x मान को केवल संक्षेपित और संवर्धित किया जाता है (ताकि स्टैक की चौड़ाई अभी भी गणना की जा सके ♯(x << 1))। Y मूल्य दो के उच्च एक को तैयार है।

A ↯एक स्ट्रिंग में वर्णों पर फेरबदल

यह एक और उपयोगी कार्य है जिसे मैं पुस्तकालय में जोड़ूंगा। एक स्ट्रिंग को देखते हुए, यह आपको प्रत्येक वर्ण कोड वाला एक आलसी अनुक्रम देता है।

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

and2097151 के साथ एक स्ट्रिंग आईएनजी पहला चरित्र देता है। >>आईएनजी 21 द्वारा इसे हटा देता है। हम esolangs पृष्ठ में बताए गए एक कारण के लिए 0 और and1 दोनों की जांच करते हैं ; यह इस चुनौती के लिए प्रासंगिक नहीं है, लेकिन मैं चाहता हूं कि पुस्तकालय का कार्य सही हो।

⑧ ⬖चरित्र को हीरे के ढेर में बदलें

यह फ़ंक्शन एकल वर्ण लेता है और उस एक वर्ण का प्रतिनिधित्व करने वाले ऊर्ध्वाधर स्टैक के लिए संरचना लौटाता है।

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

यह फ़ंक्शन दिलचस्प है क्योंकि हमें हीरे को नीचे और ऊपर बारी-बारी से संलग्न करने की आवश्यकता थी । यहाँ मैंने यह कैसे किया:

• सबसे पहले, 96 घटाएं (इसलिए 'a'1 हो जाता है), प्रमुख कारक प्राप्त करें ( Ḟऊपर), ɗतत्व को जोड़ने के लिए 1 का उपयोग करें यदि अनुक्रम खाली है, और फिर ɹक्रम रिवर्स ( )।

• पहला तत्व बंद करें और ◆स्टैक जम्पस्टार्ट करने के लिए कॉल करें ।

• अब, ⸗एक आलसी अनुक्रम उत्पन्न करने के लिए उपयोग करें जो केवल संख्या 0 और 1 को अनिश्चित काल के लिए वैकल्पिक करता है।

• ʑउस पर और शेष मुख्य कारकों का उपयोग (ज़िप) करें । प्रत्येक प्रमुख कारक के लिए, इसे 1 और or0/1 द्वारा छोड़ दिया गया । अब हमारे पास एक अनुक्रम है जो अभाज्य संख्याओं और शीर्ष / नीचे की जानकारी को कूटबद्ध करता है ।

• अंत में, उपयोग करें ʩ(बाएं / समग्र गुना)। प्रारंभिक मूल्य वह स्टैक है जिसे हमने पहले तत्व से उत्पन्न किया था। प्रत्येक मान ν के लिए , ⬗पिछले स्टैक के साथ कॉल (एक नया हीरा) जोड़ें, प्राइम ( ν >> 1) और चाहे टॉप या बॉटम ( ν & 1)।

⑨ मुख्य कार्यक्रम

यहां हम मुख्य काम करते हैं।

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

ɱइनपुट स्ट्रिंग ( ↯) में वर्णों के ऊपर पहला, नक्शा ( ) और प्रत्येक का उपयोग करके हीरे के ढेर में बदल दें ⬖। पहले तत्व को उस पर ले जाएं, और ʩबाकी हिस्सों को उन सभी को समेटने के लिए मोड़ें ( ❖)। अंत में, ‹स्ट्रिंग्स के अनुक्रम को पाने के लिए और उन सभी को जोड़ने के लिए ( ʝ10 लाइन (न्यूलाइन) विभाजक के रूप में) का उपयोग करके संरचना को अनपैक करें ।

उदाहरण आउटपुट

इनपुट:

crusaders

आउटपुट (गणना करने में 9 सेकंड का समय, यहां पोस्ट नहीं कर सकता क्योंकि आकार सीमा)।