छँटाई कल्पना

Question

कहो कि मेरे पास एक सूची है [3, 0, 4, 2, 1], और मैं इसे क्रमबद्ध करने के लिए चयन प्रकार का उपयोग करता हूं, मैं इसे इस तरह से कल्पना कर सकता हूं:

3,0,4,2,1
|-|
0,3,4,2,1
  |-----|
0,1,4,2,3
    |-|
0,1,2,4,3
      |-|
0,1,2,3,4

यह चुनौती इस तरह की कल्पना करने के बारे में है।

इनपुट

आपका इनपुट सकारात्मक पूर्णांक की एक सूची होगी, जो किसी भी प्रारूप में आपको पसंद है।

कार्य

आपके सबमिशन में एक बार में केवल दो तत्वों की अदला-बदली करके इनपुट सूची को सॉर्ट किया जाना चाहिए, और प्रत्येक स्वैप पर, सबमिशन को सूची को प्रदर्शित करना चाहिए, और स्वैप किए जाने वाले प्रत्येक तत्वों के नीचे एक चरित्र होना चाहिए। यदि किसी संख्या की अदला-बदली की गई थी, जिसमें एक से अधिक अंक हैं, तो वर्ण इसके नीचे कहीं भी हो सकता है। अंत में, सबमिशन को क्रमबद्ध सूची प्रदर्शित करनी चाहिए।

अन्य नियम

• छँटाई में n ^{4 की} तुलना में कम स्वैप का उपयोग करना चाहिए , जहाँ n सूची की लंबाई है।
• छंटाई को नियतात्मक नहीं होना चाहिए।
• स्वैप किए गए अक्षर वर्ण को छोड़कर कोई भी हो सकता है।

Comments

क्या मैं मान सकता हूं कि पूर्णांक अद्वितीय हैं?

— जार्ज ह्यूल्समैन 14

n^4? आप यहाँ थोड़े उदार हो रहे हैं।

— orlp 14

@ JörgHülsermann नहीं

— Loovjo

अगर किसी को toptal.com/developers/sorting-algorithms

— exussum

आप कहते हैं कि इनपुट धनात्मक पूर्णांक है, लेकिन आपके उदाहरण में एक है 0(कृपया केवल उदाहरण को ठीक करें ताकि उन उत्तरों को अमान्य न किया जा सके जो 0 को हैंडल नहीं कर सकते हैं)

— टन हास्पेल

Answer 1

पर्ल, 62 बाइट्स

के लिए +3 शामिल है -p

STDIN पर संख्याओं की एकल पंक्ति के रूप में इनपुट दें:

perl -M5.010 visisort.pl <<< "3 0 4 2 1"

बार-बार पहला उलटा स्वैप करता है। स्वैप जटिलता है O(n^2), समय जटिलता है O(n^3)। चिह्न के रूप में बदली जा रही संख्याओं का उपयोग करता है:

3 0 4 2 1
3 0
0 3 4 2 1
    4 2
0 3 2 4 1
  3 2
0 2 3 4 1
      4 1
0 2 3 1 4
    3 1
0 2 1 3 4
  2 1
0 1 2 3 4

visisort.pl:

#!/usr/bin/perl -p
$&>$'&&say$_.$"x"@-".!s/(\S+) \G(\S+)/$2 $1/.$&while/\S+ /g

कार्यक्रम नकारात्मक मूल्यों और फ्लोटिंग पॉइंट नंबरों का भी समर्थन करता है

यदि आप एक कनेक्टिंग कैरेक्टर पर जोर देते हैं तो कोड 66 बाइट्स हो जाता है:

#!/usr/bin/perl -p
$&>$'&&say$_.$"x"@-".!s/(\S+) \G(\S+)/$2 $1/.$1.-$2while/\S+ /g

लेकिन अब यह नकारात्मक संख्याओं और 0 का समर्थन नहीं करता है (लेकिन कार्यक्रम को केवल सकारात्मक पूर्णांक का समर्थन करना है। 0उदाहरण में यह एक गलती है)

Comments

यह देखते हुए कि The characters under the swapped can be any char except space. आपके पास अंक रेखा में संख्या के बीच रिक्त स्थान नहीं होना चाहिए

— edc65

@ edc65 स्वैप किए जा रहे तत्वों के अंतर्गत वर्ण (एस) एक स्थान नहीं है। उनके बीच के पात्रों के बारे में कुछ भी नहीं कहा जाता है

— टन हास्पेल

पूरी तरह से आश्वस्त नहीं है, लेकिन ठीक है। मैं बहुत तेज़ डाउनवोटिंग कर रहा था (लेकिन मुझे आपका ध्यान आ गया)। यदि आप अपने उत्तर में एक (खाली) संपादन करते हैं तो मैं अपना वोट

— बदलूंगा

@ edc65 ठीक है, आपकी टिप्पणी ने मुझे चुनौती को बहुत सावधानी से पूरा किया। ध्यान दें कि वह मल्टीडिजिट संख्याओं के मामले के बारे में भी स्पष्ट रूप से बताता है कि आप उदाहरण के लिए सिर्फ एक _पहले अंक के तहत रख सकते हैं, जिसका अर्थ है कि सभी अक्षर inbetween वास्तव में रिक्त स्थान होंगे)। इसलिए मैं अपनी व्याख्या (जब तक कि ओपी बिल्कुल असहमत नहीं है) के साथ खड़ा हूं। बस आपको खुश करने के लिए मैं अंतरिक्ष के बिना भी एक संस्करण जोड़ा :-) खुश करने के लिए

— टन हास्पेल

Answer 2

जावास्क्रिप्ट (ईएस 6), 158 बाइट्स

a=>{for(;;){console.log(``+a);i=a.findIndex((e,i)=>e<a[i-1]);if(i<0)break;console.log(` `.repeat(`${a.slice(0,i)}`.length-1)+`|-|`);t=a[i];a[i]=a[--i];a[i]=t}}

बबल शॅाट। नमूना उत्पादन:

3,0,4,2,1
|-|
0,3,4,2,1
    |-|
0,3,2,4,1
  |-|
0,2,3,4,1
      |-|
0,2,3,1,4
    |-|
0,2,1,3,4
  |-|
0,1,2,3,4

Comments

@nimi चूंकि मैं हमेशा आसन्न तत्वों की अदला-बदली कर रहा हूं, मैं हमेशा -नीचे रख सकता हूं ,और फिर दोनों |एस हमेशा आसन्न संख्याओं के तहत होंगे।

— नील

आह, चतुर! धन्यवाद!

— नीम

बबल सॉर्ट स्वैप संख्याओं के हाइलाइटिंग को आसान बनाने के लिए वास्तव में एक विवेकपूर्ण विकल्प है। बहुत बढ़िया!

— अरनौलड

Answer 3

PHP, 248 बाइट्स

बबलर्ट बोरिंग जीतता है

<?for($c=count($a=$_GET[a]);$c--;){for($s=$i=0;$i<$c;){$l=strlen($j=join(",",$a));if($a[$i]>$a[$i+1]){$t=$a[$i];$a[$i]=$a[$i+1];$a[$i+1]=$t;$m=" ";$m[$s]=I;$m[$s+strlen($a[$i].$a[$i+1])]=X;echo"$j\n$m\n";}$s+=strlen($a[$i++])+1;}}echo join(",",$a);

PHP, 266 array_slice और min के साथ एक तरह से बाइट करता है

के I Xबजाय संशोधित उत्पादन*~~*

<?for($c=count($a=$_GET[a]);$i<$c;){$j=join(",",$s=($d=array_slice)($a,$i));$x=array_search($m=min($s),$s);echo($o=join(",",$a));$a[$x+$i]=$a[$i];$a[$i]=$m;if($i++!=$c-1){$t=" ";$t[$z=($f=strlen)($o)-($l=$f($j))]=I;$t[$l+$z-$f(join(",",$d($s,$x)))]=X;echo"\n$t\n";}}

282 बाइट्स

<?for($c=count($a=$_GET[a]);$i<$c;){$j=join(",",$s=($d=array_slice)($a,$i));$x=array_search($m=min($s),$s);echo($o=join(",",$a));$a[$x+$i]=$a[$i];$a[$i]=$m;if($i++!=$c-1)echo"\n".str_repeat(" ",($f=strlen)($o)-($l=$f($j))).($x?str_pad("*",$l-$f(join(",",$d($s,$x))),"~"):"")."*\n";}

यह काम किस प्रकार करता है

किसी सरणी में न्यूनतम के लिए लगता है और इसे पहली स्थिति पर ले जाएँ। पहली स्थिति के बिना न्यूनतम के लिए देखें .... और यदि कोई मान दोगुना है तो पहला मान स्वैप होगा

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

31,7,0,5,5,5,753,5,99,4,333,5,2,1001,35,1,67
*~~~~*
0,7,31,5,5,5,753,5,99,4,333,5,2,1001,35,1,67
  *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*
0,1,31,5,5,5,753,5,99,4,333,5,2,1001,35,7,67
    *~~~~~~~~~~~~~~~~~~~~~~~~~*
0,1,2,5,5,5,753,5,99,4,333,5,31,1001,35,7,67
      *~~~~~~~~~~~~~~*
0,1,2,4,5,5,753,5,99,5,333,5,31,1001,35,7,67
        *
0,1,2,4,5,5,753,5,99,5,333,5,31,1001,35,7,67
          *
0,1,2,4,5,5,753,5,99,5,333,5,31,1001,35,7,67
            *~~~*
0,1,2,4,5,5,5,753,99,5,333,5,31,1001,35,7,67
              *~~~~~~*
0,1,2,4,5,5,5,5,99,753,333,5,31,1001,35,7,67
                *~~~~~~~~~~*
0,1,2,4,5,5,5,5,5,753,333,99,31,1001,35,7,67
                  *~~~~~~~~~~~~~~~~~~~~~*
0,1,2,4,5,5,5,5,5,7,333,99,31,1001,35,753,67
                    *~~~~~~*
0,1,2,4,5,5,5,5,5,7,31,99,333,1001,35,753,67
                       *~~~~~~~~~~~*
0,1,2,4,5,5,5,5,5,7,31,35,333,1001,99,753,67
                          *~~~~~~~~~~~~~~~*
0,1,2,4,5,5,5,5,5,7,31,35,67,1001,99,753,333
                             *~~~~*
0,1,2,4,5,5,5,5,5,7,31,35,67,99,1001,753,333
                                *~~~~~~~~*
0,1,2,4,5,5,5,5,5,7,31,35,67,99,333,753,1001
                                    *
0,1,2,4,5,5,5,5,5,7,31,35,67,99,333,753,1001

Comments

इसके बजाय echo$t."\n";, आप echo"$t\n";एक बाइट का उपयोग और सहेज सकते हैं ।

— इस्माइल मिगेल

@IsmaelMiguel मेरी पोस्ट को संपादित करने के लिए स्वतंत्र महसूस करें यदि आपको कुछ सुधारने के लिए मिल जाए

— Jörg Hülsermann

पदों पर कोड संपादन आमतौर पर पर आधारित होते हैं, जिनसे मैं पूरी तरह सहमत हूं।

— इस्माईल मिगुएल

Answer 4

हास्केल, 165 164 162 बाइट्स

s%c=drop 2$show s>>c
p#x|(h,t:s)<-span(/=minimum x)x=id=<<[show$p++x,"\n ",[' '|p>[]],p%" ","|",h%"-",['|'|h>[]],"\n",(p++[t])#(drop 1h++take 1h++s)]|1<2=""
([]#)

यह चयन प्रकार की कल्पना करता है। उपयोग उदाहरण:

*Main> putStr $ ([]#) [31,7,0,5,5,5,753,5,99,4,333,5,2,1001,35,1,67]
[31,7,0,5,5,5,753,5,99,4,333,5,2,1001,35,1,67]
 |----|
[0,7,31,5,5,5,753,5,99,4,333,5,2,1001,35,1,67]
   |-------------------------------------|
[0,1,31,5,5,5,753,5,99,4,333,5,2,1001,35,7,67]
     |-------------------------|
[0,1,2,5,5,5,753,5,99,4,333,5,31,1001,35,7,67]
       |--------------|
[0,1,2,4,5,5,753,5,99,5,333,5,31,1001,35,7,67]
         |
[0,1,2,4,5,5,753,5,99,5,333,5,31,1001,35,7,67]
           |
[0,1,2,4,5,5,753,5,99,5,333,5,31,1001,35,7,67]
             |---|
[0,1,2,4,5,5,5,753,99,5,333,5,31,1001,35,7,67]
               |------|
[0,1,2,4,5,5,5,5,99,753,333,5,31,1001,35,7,67]
                 |----------|
[0,1,2,4,5,5,5,5,5,753,333,99,31,1001,35,7,67]
                   |---------------------|
[0,1,2,4,5,5,5,5,5,7,333,99,31,1001,35,753,67]
                     |------|
[0,1,2,4,5,5,5,5,5,7,31,99,333,1001,35,753,67]
                        |-----------|
[0,1,2,4,5,5,5,5,5,7,31,35,333,1001,99,753,67]
                           |---------------|
[0,1,2,4,5,5,5,5,5,7,31,35,67,1001,99,753,333]
                              |----|
[0,1,2,4,5,5,5,5,5,7,31,35,67,99,1001,753,333]
                                 |--------|
[0,1,2,4,5,5,5,5,5,7,31,35,67,99,333,753,1001]
                                     |
[0,1,2,4,5,5,5,5,5,7,31,35,67,99,333,753,1001]
                                         |

यह काम किस प्रकार करता है:

s % cएक सहायक समारोह है जो length (show s) - 2चरित्र की प्रतियां बनाता है c। इसका उपयोग दोनों के पहले |, एक समय के साथ c == ' 'और एक समय के साथ रिक्ति के लिए किया जाता है c == '-'।

मुख्य कार्य #एक सूची लेता है pजो सूची का क्रमबद्ध भाग xहोता है और जो भाग को क्रमबद्ध करना होता है। पैटर्न मैच (h,t:s)<-span(/=minimum x)xसूची विभाजन xइसकी न्यूनतम तत्व और बांध में h, कम से कम पहले भाग के लिए tकम से कम अपने आप को और sकम से कम के बाद वाले हिस्से को। 1) अपनी वर्तमान स्थिति (कम से सूची: बाकी दो पंक्तियों स्वरूपण है p++x) और 2) |----|भाग का एक पुनरावर्ती कॉल के बाद #साथ tके साथ जोड़ दिया pऔर के सिर hकी पूंछ के बीच डाला hऔर s।

पुनश्च: नेगेटिव और / या फ्लोटिंग पॉइंट नंबरों के साथ भी काम करता है:

*Main> putStr $ ([]#) [-3,-1,4e33,-7.3]
[-3.0,-1.0,4.0e33,-7.3]
 |----------------|
[-7.3,-1.0,4.0e33,-3.0]
      |-----------|
[-7.3,-3.0,4.0e33,-1.0]
           |------|
[-7.3,-3.0,-1.0,4.0e33]
                |

संपादित करें: @BlackCap ने 2 बाइट्स बचाए। धन्यवाद!

Comments

id=<<[show$p++x,"\n ",[' '|p>[]],p%" ","|",h%"-",['|'|h>[]],"\n",(p++[t])#(drop 1h++take 1h++s)]

— ब्लैककैप

Answer 5

पायथन 2, 267 बाइट्स

यह दशमलव और ऋणात्मक संख्याओं के साथ भी काम करता है।

p=1
while p!=len(a):    
 q=p-1;k=a[p:];m=min(k);n=k.index(m)+p;b=map(str,a)
 if a[q]>m:print','.join(b)+'\n'+''.join(' '*len(i)for i in b[:q])+' '*q+'*'+'-'*(len(b[n])+n-q-2)+''.join('-'*len(i)for i in b[q:n])+'*';a[q],a[n]=[a[n],a[q]]
 p+=1
print','.join(map(str,a))

उदाहरण:

7,2,64,-106,52.7,-542.25,54,209,0,-1,200.005,200,3,6,1,0,335,-500,3.1,-0.002
*----------------------*
-542.25,2,64,-106,52.7,7,54,209,0,-1,200.005,200,3,6,1,0,335,-500,3.1,-0.002
        *-------------------------------------------------------*
-542.25,-500,64,-106,52.7,7,54,209,0,-1,200.005,200,3,6,1,0,335,2,3.1,-0.002
             *-----*
-542.25,-500,-106,64,52.7,7,54,209,0,-1,200.005,200,3,6,1,0,335,2,3.1,-0.002
                  *-------------------*
-542.25,-500,-106,-1,52.7,7,54,209,0,64,200.005,200,3,6,1,0,335,2,3.1,-0.002
                     *-----------------------------------------------------*
-542.25,-500,-106,-1,-0.002,7,54,209,0,64,200.005,200,3,6,1,0,335,2,3.1,52.7
                            *--------*
-542.25,-500,-106,-1,-0.002,0,54,209,7,64,200.005,200,3,6,1,0,335,2,3.1,52.7
                              *-----------------------------*
-542.25,-500,-106,-1,-0.002,0,0,209,7,64,200.005,200,3,6,1,54,335,2,3.1,52.7
                                *------------------------*
-542.25,-500,-106,-1,-0.002,0,0,1,7,64,200.005,200,3,6,209,54,335,2,3.1,52.7
                                  *-------------------------------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,64,200.005,200,3,6,209,54,335,7,3.1,52.7
                                    *--------------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,200.005,200,64,6,209,54,335,7,3.1,52.7
                                      *-------------------------------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,200,64,6,209,54,335,7,200.005,52.7
                                          *------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,6,64,200,209,54,335,7,200.005,52.7
                                            *-----------------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,6,7,200,209,54,335,64,200.005,52.7
                                              *----------------------------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,6,7,52.7,209,54,335,64,200.005,200
                                                   *----*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,6,7,52.7,54,209,335,64,200.005,200
                                                      *--------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,6,7,52.7,54,64,335,209,200.005,200
                                                         *-----------------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,6,7,52.7,54,64,200,209,200.005,335
                                                             *---------*
-542.25,-500,-106,-1,-0.002,0,0,1,2,3,3.1,6,7,52.7,54,64,200,200.005,209,335

Answer 6

जावास्क्रिप्ट (ईएस 6), 147 155

N * n तुलना का उपयोग करना, लेकिन (मेरा मानना ​​है) स्वैप की न्यूनतम संख्या। और बोरिंग बबल सॉर्ट की तुलना में स्वैप पोजिशन अधिक परिवर्तनशील होती हैं।

l=>l.reduce((z,v,i)=>l.map((n,j)=>s+=`${j>i?n<l[i]?l[p=j,t=s,i]=n:0:u=s,n},`.length,s=p=0)|p?z+`
${l[p]=v,' '.repeat(u)}^${Array(t-u)}^
`+l:z,''+l)

कम गोल्फ और उम्मीद है कि अधिक समझ में आता है

l=>
  l.reduce( (z,v,i) => // update z for each list element v at position i
    ( // begin outer loop body
      // loop to find the least value that is to be placed at pos i
      l.map( (n,j) => // for each list element n at position j
        ( // begin inner loop body
          j > i ? // check if at position after i
            n < l[i] && // check if lower value 
            (
              p = j, // remember position in p 
              l[i] = n, // store value in l[i] (could change later)
              t = s // in t, string length of list elements up element preciding j
            )
          : // else, position up to i
            u = s, // in u, string length of list elements up element preciding i
          s += `${n},`.length, // string length of list elements up to this point (value length + comma)
        ) // end inner loop body
        , s = p = 0 // init s and p at start of inner loop
      ), 
      p ? (// if found a lower value, complete the swap and update output
          l[p] = v, // complete swap, l[i] was assigned before
          z + '\n' + ' '.repeat(u) + // spaces to align 
               '^' + // left marker
               Array(t-u) + // swap highlight, using sequence of commas
               '^\n' + // right marker, newline
               l + // list values after the swap, newline
      )
      : z // else output is unchanged
    ) // end outer loop body
    , ''+l // init string output at start of outer loop
  ) // output is the result of reduce

परीक्षा

f=
l=>l.reduce((z,v,i)=>l.map((n,j)=>s+=`${j>i?n<l[i]?l[p=j,t=s,i]=n:0:u=s,n},`.length,s=p=0)|p?z+`
${l[p]=v,' '.repeat(u)}^${Array(t-u)}^
`+l:z,''+l)

function sort()
{
  var list=I.value.match(/-?[\d.]+/g).map(x=>+x)
  O.textContent = f(list)
}

sort()

#I { width:80% }

<input id=I value='3, 0, 4, 2, 1'>
<button onclick='sort()'>Sort</button>
<pre id=O></pre>

Answer 7

जावा 7, 256 241 282 बाइट्स

15 बाइट्स बचाने के लिए @Geobits और @Axelh को धन्यवाद

 void f(int[]a){int m,i,j,l=a.length;for(i=0;i<l;j=a[i],a[i]=a[m],a[m]=j,i++){for(int k:a)System.out.print(k+" ");System.out.println();for(j=i+1,m=i;j<l;m=a[j]<a[m]?j:m,j++);for(j=0;j<=m&i!=l-1;j++)System.out.print(j==i|j==m?a[j]+" ":"  ");System.out.println();}}

Ungolfed

 void f(int[]a){
    int m,i,j,l=a.length;
for(i=0;i<l;j=a[i],a[i]=a[m],a[m]=j,i++){
    for(int k:a)
        System.out.print(k+" ");
    System.out.println();
     for(j=i+1,m=i;j<l;m=a[j]<a[m]?j:m,j++);
      for(j=0;j<=m&i!=l-1;j++)
      System.out.print(j==i|j==m?a[j]+" ":"  ");
      System.out.println();        

}
}

उत्पादन

3 0 1 4 2 
3 0 
0 3 1 4 2 
  3 1 
0 1 3 4 2 
    3   2 
0 1 2 4 3 
      4 3 
0 1 2 3 4 

Comments

यह अभी भी घोषणा को याद नहीं कर रहा है out, आपको PrintStream out=System.out;अपने कोड में कहीं और कुछ डालने की आवश्यकता है ।

— लवजो

के आयात / घोषणा को ठीक करने के बाद out, आपको इसके बजाय एक टर्नरी का उपयोग करना चाहिएif/else दोनों शाखाओं पर मुद्रण करने जा रहे हैं, आपको । कुछ इस तरहout.print(a>b?a:b);इसके बजायif(a>b)out.print(a);else out.print(b);

— जियोबिट्स

आप इसे कम कर सकते हैं यदि इसे छोड़ दें: if(j==i|j==m)out.print(a[j]);out.print(" ");या एक टर्नरी के साथ भी बेहतरout.print((j==i|j==m?a[j]:" ")+" "); और फिर आप लूप पीएस के {} को हटा सकते हैं: मैं आउट उदाहरण के लिए एक आयात स्थैतिक का उपयोग करता हूं, अगर यह ठीक है;)

— एक्सिलएच

हम्म, दूसरों से गोल्फिंग टिप्स के अलावा, आउटपुट गलत है। यहाँ आपके कोड को कॉपी-पेस्ट (और जोड़ा गया) के साथ एक विचारधारा हैSystem.out एस के सामने गया ) के , और यह पिछले दो स्वैप लाइनों पर 2और गायब है 3।

— केविन क्रूज़सेन

@ केविनक्रूजसेन मैंने इसे ठीक कर दिया। आमतौर पर मैं इस चर में जे चर (मुझे होना चाहिए) के साथ for(j=0;j<=m&i!=l-1;j++)

— मिलाता है

Answer 8

जेली , 36 बाइट्स

I;0CMḢ;L‘ṬCœṗ¹UF©µÐĿ,n+32Ọ$¥¥2\;/®ṭG

इसे ऑनलाइन आज़माएं!

व्याख्या

I;0CMḢ;L‘ṬCœṗ¹UF©µÐĿ,n+32Ọ$¥¥2\;/®ṭG
                 µÐĿ                 Repeat until we see a previously seen value:
I;0                                    Take differences of adjacent inputs, and 0
   CM                                  Find the indices (M) of the smallest (C) 
           œṗ                          Split {the input} into pieces
        ‘Ṭ                               that end
      ;L  C                              everywhere except
     Ḣ                                 the first of the chosen deltas
             ¹                         Resolve parser ambiguity
              U                        Reverse each piece
               F                       Concatenate the pieces back into a list
                ©                      Store the value in a register
                                     Then, on the accumulated list of results:
                             2\        Look at each consecutive pair of results
                    ,       ¥  ;/      and return the first element, followed by
                      +32Ọ$            the character with code 32 plus
                     n     ¥           1 (if unequal), 0 (if equal)
                                 ®ṭ  Append the value of the register
                                   G Output in grid form

TIO लिंक में दिखाया गया उदाहरण इस कार्यक्रम के लिए विशेष रूप से कठिन है; ;0शुरू के निकट यह सुनिश्चित करें कि पाश सिर्फ बिंदु जहां इनपुट अनुसार क्रमबद्ध हो जाता है पर समाप्त होता है के लिए आवश्यक है। यह सामान्य रूप से आवश्यक नहीं है (क्योंकि यह एक और पुनरावृत्ति के बाद समाप्त हो जाएगा), लेकिन अगर अंतिम स्वैप पहले दो तत्वों का है (जैसा कि यहां देखा गया है), एक-अधिक-पुनरावृत्ति नहीं होगी और इसे समाप्त करना असंभव बनाता है लगातार सूची। जैसे, हमें यह सुनिश्चित करने की आवश्यकता है कि हम अंतिम लूप पुनरावृत्ति पर कुछ भी स्वैप न करें।