19

एक फ़ंक्शन या प्रोग्राम बनाएं जो दो इनपुट लेता है:

पूर्णांकों की एक सूची जो क्रमबद्ध होगी (20 से कम तत्व)
एक सकारात्मक पूर्णांक, Nयह कहते हुए कि आपको कितनी तुलना करनी चाहिए

फ़ंक्शन बंद हो जाएगा, और Nतुलना के बाद पूर्णांकों की परिणामी सूची का उत्पादन करेगा । यदि Nतुलना किए जाने से पहले सूची को पूरी तरह से सॉर्ट किया जाता है, तो सॉर्ट की गई सूची को आउटपुट किया जाना चाहिए।

बुलबुला तरह एल्गोरिथ्म अच्छी तरह से जाना जाता है, और मुझे लगता है कि ज्यादातर लोगों को यह पता है। निम्नलिखित छद्म कोड और एनीमेशन (दोनों विकिपीडिया-लेख से) आवश्यक विवरण प्रदान करना चाहिए:

procedure bubbleSort( A : list of sortable items )
   n = length(A)
   repeat 
     swapped = false
     for i = 1 to n-1 inclusive do
       /* if this pair is out of order */
       if A[i-1] > A[i] then    
         /* swap them and remember something changed */
         swap( A[i-1], A[i] )
         swapped = true
       end if
     end for
   until not swapped
end procedure

नीचे दिया गया एनीमेशन प्रगति दर्शाता है:

एक उदाहरण (लिंक किए गए विकिपीडिया लेख से सीधे लिया गया) सूची को सॉर्ट करते समय चरणों को दर्शाता है ( 5 1 4 2 8 ):

पहला पास

1: ( 5 1 4 2 8 ) ->  ( 1 5 4 2 8 ) // Here, algorithm compares the first two elements, 
                                   // and swaps since 5 > 1.
2: ( 1 5 4 2 8 ) ->  ( 1 4 5 2 8 ) // Swap since 5 > 4
3: ( 1 4 5 2 8 ) ->  ( 1 4 2 5 8 ) // Swap since 5 > 2
4: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 ) // Now, since these elements are already in order 
                                   // (8 > 5), algorithm does not swap them.

दूसरा पास

5: ( 1 4 2 5 8 ) ->  ( 1 4 2 5 8 )
6: ( 1 4 2 5 8 ) ->  ( 1 2 4 5 8 ) // Swap since 4 > 2
7: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
8: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

अब, सरणी पहले से ही सॉर्ट की गई है, लेकिन एल्गोरिथ्म पता नहीं है कि क्या यह पूरा हो गया है। एल्गोरिथ्म को किसी भी स्वैप के बिना एक पूरे पास की जरूरत है ताकि यह पता चल सके कि यह किस प्रकार का है।

तीसरा पास

9: ( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
10:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
11:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )
12:( 1 2 4 5 8 ) ->  ( 1 2 4 5 8 )

परीक्षण के मामलों:

प्रारूप: Number of comparisons (N): List after N comparisons

Input list:
5  1  4  2  8
Test cases: 
1: 1  5  4  2  8
2: 1  4  5  2  8
3: 1  4  2  5  8
4: 1  4  2  5  8
5: 1  4  2  5  8
6: 1  2  4  5  8
10: 1  2  4  5  8
14: 1  2  4  5  8

Input list:
0: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
Test cases:
1: 15  18  -6  18   9  -7  -1   7  19  19  -5  20  19   5  15  -5   3  18  14  19
21: -6  15  18   9  -7  -1   7  18  19  -5  19  19   5  15  -5   3  18  14  19  20
41: -6   9  -7  15  -1   7  18  18  -5  19  19   5  15  -5   3  18  14  19  19  20
60: -6  -7  -1   9   7  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
61: -6  -7  -1   7   9  15  18  -5  18  19   5  15  -5   3  18  14  19  19  19  20
81: -7  -6  -1   7   9  15  -5  18  18   5  15  -5   3  18  14  19  19  19  19  20
119: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
120: -7  -6  -1  -5   7   9  15   5  15  -5   3  18  14  18  18  19  19  19  19  20
121: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
122: -7  -6  -1  -5   7   9   5  15  15  -5   3  18  14  18  18  19  19  19  19  20
123: -7  -6  -1  -5   7   9   5  15  -5  15   3  18  14  18  18  19  19  19  19  20
201: -7  -6  -5  -1  -5   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20
221: -7  -6  -5  -5  -1   3   5   7   9  14  15  15  18  18  18  19  19  19  19  20

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

code-golf sorting

— स्टीवी ग्रिफिन
स्रोत

2

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

— टन Hospel

क्या सूची गैर-रिक्त होगी?

— मील

इसके अलावा, क्या सूची का आकार 2 से अधिक या बराबर होगा? मैंने देखा कि नीचे दिए गए कुछ उत्तर लंबाई 1 या खाली सूचियों की सूची के लिए काम नहीं करते हैं।

— मील

2

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

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥
JḊṁ¹³W¤;ç/

जे में मेरे जवाब के आधार पर ।

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

तुलनाओं की संख्या सत्यापित करें।

व्याख्या

हेल्पर लिंक सूची में सूची को संशोधित [i-1, i]करके इसे सॉर्ट करता है जो बबल सॉर्ट की तुलना के समान परिणाम उत्पन्न करता है।

ḣ©ṫ-Ṣ®ṖṖ¤;;ṫḊ¥  Helper link - Input: list A, index i
ḣ               Take the first i values
 ©              Save a copy of it
  ṫ-            Take the last two values
    Ṣ           Sort them
         ;      Append them to
     ®            Get the copy
      ṖṖ¤         Pop the last two values (Ṗ is pop)
          ;     Prepend it to
           ṫ      Take the last i values
            Ḋ¥    Dequeue - remove the head

JḊṁ¹³W¤;ç/  Input: list A and # of comparisons n
J           Enumerate the indices of A
 Ḋ          Dequeue - remove the head
  ṁ         Reshape it cyclically to length n
   ¹        Identity function (Just to avoid parsing rules)
       ;    Append it to
    ³         The list A
     W¤       Wrap it as an array
        ç/  Reduce from left to right using the helper link and return

— मील की दूरी पर
स्रोत

9

जावास्क्रिप्ट (ईएस 6), 102 82 80 86 80 बाइट्स

बग फिक्स और 1 बाइट @ edc65 की बदौलत बचा

(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

पुनरावृत्ति ~~निश्चित रूप से नहीं~~ ~~हो सकती~~ है शायद सबसे अच्छा तरीका ~~नहीं~~ है, लेकिन मैं अभी के लिए एक लूप के साथ चिपका रहा हूं।

कोशिश करके देखो:

कोड स्निपेट दिखाएं

f=(a,m)=>eval("for(i=0;m;a[j=i-1]>(b=a[i])?a[a[i]=a[j],j]=b:0)1/a[++i]?m--:i=0;a")

Enter your numbers:<br>
<input id=A rows=10 value="5 1 4 2 8"><br>
Enter the number of steps:<br>
<input type="number" min=0 id=B rows=10 value="1"><br>
<button onclick="C.innerHTML=f((A.value.match(/-?\d+/g)||[]).map(Number),B.value)">Run</button><br>
<pre id=C></pre>

स्निपेट का विस्तार करें

— ETHproductions
स्रोत

मैं आपके पुनरावर्ती संस्करण को 82 बाइट्स तक नीचे ले जाने में सफल रहा f=(a,m,n=0,_,b=a[n+1])=>b+.5?m?f(a,m-1,n+1,a[n]>b?a[a[n+1]=a[n],n]=b:0):a:f(a,m,0)।

— नील

@ नील वाह, यह प्रभावशाली है! यदि आप चाहें तो आप इसे अपने अनुसार पोस्ट कर सकते हैं।

— 21

@ नील आप अपने पुनरावर्ती संस्करण को 80 में भी कर सकते हैं, बस अंतिम को हटा दें,0

— जोनाथन एलन

के 1/bबजाय b+.5जाँच करने के लिए प्रयास करेंundefined

— edc65

ठीक है, 1 / b के लिए मेरा सुझाव अभी भी है

— edc65

7

हास्केल, 83 82 81 बाइट्स

y%x@(a:b:c)=(y++x):(y++[min a b])%(max a b:c)
y%x=[]%(y++x)
[x]!_=[x] 
x!n=[]%x!!n

प्रयोग उदाहरण: [5,1,4,2,8] ! 5-> [1,4,2,5,8]।

फ़ंक्शन % yमें वर्तमान पास के दौरान अब तक देखे गए तत्वों का ट्रैक रखता है, xक्या अभी तक जांच की जानी है। aऔर bअगले दो हैं, यानी उम्मीदवारों को स्वैप करना है। यदि हम सूची के अंत तक पहुँचते हैं, तो हम शुरुआत से शुरू करते हैं y%x = []%(y++x):। सभी चरणों को एक सूची में संग्रहीत किया जाता है जहां मुख्य कार्य nवें तत्व को चुनता है ।

संपादित करें: पिछले संस्करण एकल तत्व सूचियों के लिए काम नहीं करते थे, सौभाग्य से नया संस्करण और भी छोटा है।

— nimi
स्रोत

क्या यह ऑनलाइन परीक्षण करना संभव है? मैं हास्केल के बारे में कुछ भी नहीं जानता, और जब इसे सीधे ऑनलाइन विचारधारा में चिपकाने की कोशिश की जाती है, तो त्रुटियां मिलती हैं। मुझे लगता है कि मुझे कुछ बुनियादी चीजें याद आ रही हैं ...?

— स्टिव ग्रिफिन

f=उत्तर की दूसरी पंक्ति से पहले जोड़ें , फिर कार्यक्रम वाली तीसरी पंक्ति को जोड़ दें main=print(f [5,1,4,2,8] 5)। इसे इसे चलाने योग्य बनाना चाहिए।

— लिन

@WeeingIfFirst: पूरा कार्यक्रम

— nimi

4

पायथन 3, 77 74 बाइट्स

-3 बाइट्स @ धन्यवाद के लिए धन्यवाद ( jघोषणा में init )

lambda l,n,j=0:exec('j*=j<len(l)-1;l[j:j+2]=sorted(l[j:j+2]);j+=1;'*n)or l

मामलों पर परीक्षण आइडोन

उपयोग sortedप्रत्येक तुलना और स्वैप ऑपरेशन करने के लिए है, लेकिन यह एक बुलबुला प्रकार का प्रदर्शन कर रहा है।

सेट j=0(बाएं सूचकांक), फिर nआसन्न सूची आइटम की तुलना और स्वैप करता है , जब भी यह विंडो सीमा से बाहर जाती है, तब रीसेट jहो 0जाती है।

j*=j<len(l)-1गुणा करेंगे jद्वारा False(यानी 0उस बिंदु पर), हर दूसरे समय जबकि यह गुणा करेंगे jद्वारा True(यानी 1)।

(यह अभी भी एक खाली सूची के लिए काम करेगा।)

— जोनाथन एलन
स्रोत

1

मुझे लगता है कि आप लैम्ब्डा डिफाल्ट

— परम्स

1

इसके अलावा, आपको रीसेट करने की आवश्यकता नहीं है j, आप उपयोग कर सकते हैं%

— माल्टीसेन

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

— जोनाथन एलन

1

सभी परीक्षण मामलों के लिए ठीक काम करता है, और मेरे MATLAB उत्तर की तुलना में थोड़ा छोटा है। +1 =) दुर्भाग्य से, मैं evalइनलाइन असाइनमेंट्स के कारण MATLAB के साथ एक ही तकनीक का उपयोग नहीं कर सकता ।

— स्टिव ग्रिफ़िन

1

नए परीक्षण मामलों को शामिल करने के लिए अद्यतन

— जोनाथन एलन

3

PowerShell v2 +, 135 129 बाइट्स

param($a,$n)for($s=1;$s){($s=0)..($a.count-2)|%{if($a[$_]-gt$a[$_+1]){$a[$_],$a[$_+1]=$a[$_+1],$a[$_];$s=1}if(!--$n){$a;exit}}}$a

इसलिए। अनेक। डॉलर।

( सहेजी गयी छह बाइट्स एहसास है कि इस चुनौती हर बार प्रत्येक पास के बाद से है कि के अनुसार क्रमबद्ध गारंटीशुदा, और बजाय पर पिछले तत्व (रों) लंघन के अनुकूलन "मुक्त करने के लिए" एक पूर्ण पास से होकर गुजरती शामिल नहीं है द्वारा। यह ले जाया गया $a.countमें forपाश और $zचर को समाप्त कर दिया । )

सीधे बबल सॉर्ट करें, एक निफ्टी स्पॉट के साथ, एक स्टेप में स्वैप करें -
$a[$_],$a[$_+1]=$a[$_+1],$a[$_]

बाहर निकलने के तर्क के माध्यम से नियंत्रित किया जाता है if(!--$n){$a;exit}

परीक्षण के मामलों

(सरणी को अंतरिक्ष-पृथक के रूप में दिखाया गया है क्योंकि किसी सरणी को संशोधित करने के लिए डिफ़ॉल्ट आउटपुट फ़ील्ड सेपरेटर एक स्थान है। स्ट्रिंग इसलिए होती है क्योंकि हम लेबल के साथ मिल रहे हैं "$_ -> "।)

PS C:\Tools\Scripts\golfing> 1,2,3,4,5,6,10,14|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(5,1,4,2,8) $_)}
1 -> 1 5 4 2 8
2 -> 1 4 5 2 8
3 -> 1 4 2 5 8
4 -> 1 4 2 5 8
5 -> 1 4 2 5 8
6 -> 1 2 4 5 8
10 -> 1 2 4 5 8
14 -> 1 2 4 5 8

PS C:\Tools\Scripts\golfing> 1,21,41,60,61,81,119,120,121,122,123,201,221|%{"$_ -> "+(.\bubble-sorting-in-progress.ps1 @(15,18,-6,18,9,-7,-1,7,19,19,-5,20,19,5,15,-5,3,18,14,19) $_)}
1 -> 15 18 -6 18 9 -7 -1 7 19 19 -5 20 19 5 15 -5 3 18 14 19
21 -> -6 15 18 9 -7 -1 7 18 19 -5 19 19 5 15 -5 3 18 14 19 20
41 -> -6 9 -7 15 -1 7 18 18 -5 19 19 5 15 -5 3 18 14 19 19 20
60 -> -6 -7 -1 9 7 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
61 -> -6 -7 -1 7 9 15 18 -5 18 19 5 15 -5 3 18 14 19 19 19 20
81 -> -7 -6 -1 7 9 15 -5 18 18 5 15 -5 3 18 14 19 19 19 19 20
119 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
120 -> -7 -6 -1 -5 7 9 15 5 15 -5 3 18 14 18 18 19 19 19 19 20
121 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
122 -> -7 -6 -1 -5 7 9 5 15 15 -5 3 18 14 18 18 19 19 19 19 20
123 -> -7 -6 -1 -5 7 9 5 15 -5 15 3 18 14 18 18 19 19 19 19 20
201 -> -7 -6 -5 -1 -5 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20
221 -> -7 -6 -5 -5 -1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

— AdmBorkBork
स्रोत

3

आर, 132 131 112 136 बाइट्स

कार्यक्रम इनपुट निम्नानुसार प्राप्त करता है: पहले N, फिर वेक्टर खुद। उदाहरण के लिए, यदि आप चाहते हैं v = [5 1 4 2 8]और n = 1, वह इनपुट जो अंदर जाता scanहै 1 5 1 4 2 8। तो इस प्रोग्राम को चलाने के लिए, आप पहली लाइन चलाते हैं , कंसोल में एक-एक करके नंबर फीड करते हैं , और फिर बाकी को चलाते हैं (यह एक REPL उत्तर है)।

फिर निम्नलिखित कोड चाल करता है:

v=scan()
s=m=0
while(!s){s=T;for(i in 3:length(v)){m=m+1
if(m>v[1]){s=T;break}
if(v[i-1]>v[i]){v[c(i-1,i)]=v[c(i,i-1)];s=F}}}
cat(v[-1])

परीक्षा:

Input: a vector with N first and the elements to be sorted next
1 5 1 4 2 8
5 5 1 4 2 8
14 5 1 4 2 8
60 15 18 -6 18  9 -7 -1  7 19 19 -5 20 19  5 15 -5  3 18 14 19

Output: 
1 5 4 2 8
1 4 2 5 8
1 2 4 5 8
-6 -7 -1  9  7 15 18 -5 18 19  5 15 -5  3 18 14 19 19 19 20

अद्यतन: गोल्फ 1 बाइट व्लो के कारण ।

— आंद्रे कोस्टीर्का
स्रोत

2

ऐसा प्रतीत होता है कि इनपुट्स को हार्डकोड करने के लिए वैरिएबल के रूप में और अनुमानित रूप से आरईपीएल तंत्र के माध्यम से आउटपुट प्रदर्शित करना आवश्यक है, जो स्वीकार्य I / O तरीकों की हमारी सूची के अनुसार अस्वीकार्य नहीं है ।

— Mego

@Mego ठीक है, मैंने तय किया है। कृपया देखें कि क्या अब यह पूरी तरह से आज्ञाकारी है ...

— आंद्रेost कोस्टिर्का

ऐसा लगता है कि आप पहले s = T को हटा सकते हैं; और अभी भी सही आउटपुट है; यह आपको 4 बाइट बचाता है। संपादित करें: वास्तव में, आप पूरी तरह से, जबकि () लूप को हटा सकते हैं, और ब्रेक के साथ अपने s = T को बदलने के लिए बस () लूप का उपयोग कर सकते हैं, जो हमें कुछ घुंघराले ब्रेसिज़ से छुटकारा पाने की अनुमति देता है। यह पैदावार: v = स्कैन (); s = m = 0; के लिए (मैं 3 में: लंबाई (v)) {m = m + 1; यदि (m> v [1]) विराम; यदि (v [i-) 1]> v [i]; v [c (i-1, i)] = v [c (i, i (1)]; break}}; v [-1] कुल 117 बाइट्स के लिए।

— rturnbull

@rturnbull आपका संस्करण इतना बेहतर है! आप के लिए यश।

— आंद्रे

@rturnbull उन शुरुआती टिप्पणियों में कहां गए? 19 बाइट्स को दूर करने का आपका सुझाव ... इससे बस उस अतिरिक्त लूप को हटा दिया गया जो आवश्यक था क्योंकि बबल सॉर्ट का प्रदर्शन O (n,) है, जबकि उस अतिरिक्त लूप के बिना, यह (n-1) लंबा हो जाता है। मुझे जाँच करनी चाहिए ... अब यह तय हो गया है और इसमें एक विवरण शामिल है कि इनपुट में कैसे फीड किया जाए! क्या यह पहले से बेहतर है?

— आंद्रे

2

पायथ, 34 32 बाइट्स

AQVH=*<ZtlGZ=GsXJcG,Zh=hZ1ShtJ;G

जोनाथन एलन के पायथन के उत्तर का अनुवाद।

यहाँ कोशिश करो!

— स्टीवन एच।
स्रोत

2

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

f=(a,m,n=0,_,b=a[n+1])=>1/b?m?f(a,m-1,n+1,a[n]>b?a[a[n+1]=a[n],n]=b:0):a:f(a,m)

@ ETHproduction के मूल उत्तर के आधार पर। संपादित करें: @JonathanAllan के लिए 2 बाइट्स सहेजे गए। @ Edc65 के लिए 1 बाइट का धन्यवाद सहेजा गया।

— नील
स्रोत

2

जे , 62 60 बाइट्स

>@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)

यह एक क्रिया है जो दो तर्क लेती है: एलएचएस पर तुलना की संख्या और आरएचएस पर पूर्णांकों की सूची। पहले यह जाँचता है कि सूची की लंबाई एक से अधिक है या नहीं। यदि ऐसा नहीं है, तो यह सूची को बिना बताए लौटा देता है, अन्यथा यह परिणाम लौटने से पहले निर्दिष्ट संख्या की तुलना करके उस पर काम करता है।

प्रयोग

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

   f =: >@([:({.,(2/:~@{.}.),]}.~2+[)&.>/]|.@;<:@#@]<@|i.@[)^:(]1<#)
   1 2 3 4 5 6 10 14 ([;f)"0 1 ] 5 1 4 2 8
┌──┬─────────┐
│1 │1 5 4 2 8│
├──┼─────────┤
│2 │1 4 5 2 8│
├──┼─────────┤
│3 │1 4 2 5 8│
├──┼─────────┤
│4 │1 4 2 5 8│
├──┼─────────┤
│5 │1 4 2 5 8│
├──┼─────────┤
│6 │1 2 4 5 8│
├──┼─────────┤
│10│1 2 4 5 8│
├──┼─────────┤
│14│1 2 4 5 8│
└──┴─────────┘
   1 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
   123 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _1 _5 7 9 5 15 _5 15 3 18 14 18 18 19 19 19 19 20
   221 f 15 18 _6 18 9 _7 _1 7 19 19 _5 20 19 5 15 _5 3 18 14 19
_7 _6 _5 _5 _1 3 5 7 9 14 15 15 18 18 18 19 19 19 19 20

व्याख्या

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

   i. # 5 1 4 2 8
0 1 2 3 4
   2 <\ i. # 5 1 4 2 8
┌───┬───┬───┬───┐
│0 1│1 2│2 3│3 4│
└───┴───┴───┴───┘
   2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┐
│0│1│2│3│
└─┴─┴─┴─┘

ये प्रत्येक तुलना के प्रारंभ संकेत हैं। यदि 7 तुलनाएं की जा रही हैं, तो वांछित राशि प्राप्त करने के लिए इसे फिर से खोलें। J, दाएं से बाएं ओर मुड़ता है, इसलिए इसका दायां बाएं से दाएं, गुना-दाएं की तरह कम हो जाता है। प्रारंभिक सूची को संलग्न करें और इसे उल्टा करें।

   7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘
   |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
┌─┬─┬─┬─┬─┬─┬─┬─────────┐
│2│1│0│3│2│1│0│5 1 4 2 8│
└─┴─┴─┴─┴─┴─┴─┴─────────┘

वैकल्पिक रूप से, सीमा [0, 7) बनाई जा सकती है और प्रत्येक मान समान सीमा बनाने के लिए सूची 1 की लंबाई को मापता है।

   (<: # 5 1 4 2 8) <@| i. 7
┌─┬─┬─┬─┬─┬─┬─┐
│0│1│2│3│0│1│2│
└─┴─┴─┴─┴─┴─┴─┘

अंतिम भाग एक क्रिया है जो आरएचएस पर एक सूची और एलएचएस पर एक सूचकांक लेता है जो तुलना के प्रारंभ सूचकांक को चिह्नित करता है। उस इंडेक्स पर शुरू होने वाले दो तत्वों का चयन करें, उन्हें सॉर्ट करें, और उन्हें सूची में प्लग करें और वापस लौटा दें।

   > ({.,(2/:~@{.}.),]}.~2+[)&.>/ |. 5 1 4 2 8 ; 7 $ 2 <@{.\ i. # 5 1 4 2 8
1 2 4 5 8

— मील की दूरी पर
स्रोत

प्रभावशाली, बहुत प्रभावशाली +1।

— मैजिक ऑक्टोपस Urn

1

मतलाब, 93 91 बाइट्स

function l=f(l,m)
n=numel(l)-1;i=0;while n&m;i=mod(i,n)+1;m=m-1;l(i:i+1)=sort(l(i:i+1));end

11 बाइट्स को छोड़ने से बचाता है if l(i)>l(i+1);l(i:i+1)=l([i+1,i]), और इसके बजाय हर बार दो तत्वों को क्रमबद्ध करता है। लंबाई 1 की सूची के लिए काम करता है। ऑक्टेव का उपयोग करके एक बाइट या दो बचा सकता हैm-- ऑपरेटर , लेकिन यह बहुत ज्यादा नहीं है।

सेटिंग करके दो और बाइट्स बचाता है n=numel(l)-1;, क्योंकि तब मैं while nइसके बजाय while n>1, और i=mod(i,n)+1इसके बजाय कर सकता हूं i=mod(i,n-1)+1।

रिकॉर्ड के लिए, यह जवाब चुनौती बनने के कई घंटे बाद लिखा गया था।

— स्टीवी ग्रिफिन
स्रोत

1

ग्रूवी (101 बाइट्स)

{l,n->(l.size()..0).each{i->(0..i-2).each{if(l[it]>l[it+1] && n>0 && it>-1){l.swap(it,it+1)};n--}};l}

संपादित करें: मुझे अपना स्वयं का स्वैप बंद करने की आवश्यकता नहीं थी, ग्रूवी ने इसे बनाया था।
इसे यहाँ आज़माएँ: https://groovyconsole.appspot.com/script/5104724189642752

उदाहरण आउटपुट ट्रेस:

4:[1, 5, 4, 2, 8]
3:[1, 4, 5, 2, 8]
2:[1, 4, 2, 5, 8]
1:[1, 4, 2, 5, 8]
0:[1, 4, 2, 5, 8] - Locks in the final answer.
-1:[1, 4, 2, 5, 8]
-2 (Return):[1, 4, 2, 5, 8]

पुराना कार्यान्वयन (122 बाइट्स)

m={l,n->s={x,y->t=l[x];l[x]=l[y];l[y]=t};((l.size()-2)..2).each{i->(0..i).each{if(l[it]>l[it+1] && n){s(it,it+1)};n--}};l}

इसे यहाँ आज़माएँ: https://groovyconsole.appspot.com/script/6316871066320896

— जादू ऑक्टोपस Urn
स्रोत

दो से कम वस्तुओं वाली सूचियों के लिए यह त्रुटि

— जोनाथन एलन

मेरे मोबाइल पर ... यदि कथन उस समस्या को ठीक करता है तो इसे => 0 में जोड़ देना।

— मैजिक ऑक्टोपस Urn

यह नकारात्मक इनपुट वाली सूचियों के लिए भी विफल होता है। उदाहरण के लिए दूसरा टेस्ट केस।

— स्टूवी ग्रिफिन

अब काम करता है, मैं कल रात एक मोबाइल पर था इसलिए मैं आवश्यक संपादन नहीं कर सका।

— मैजिक ऑक्टोपस Urn

1

php, 148 145 बाइट्स

<?php for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)if($a[$i]>$a[$i+1])list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];echo substr(join(' ',$a),5);

मैं लूप संरचना से बहुत खुश नहीं हूं, लेकिन मुझे सूची स्विच पसंद है और यह काम करता है इसलिए मैं इसे वैसे भी पोस्ट कर रहा हूं। php7.1 मुझे कम से कम 4 बाइट्स बचाने की अनुमति देगा।

अच्छे स्वरूपण के साथ:

<?php 
for($i=2,$a=$argv;$a[1]--;$i=$i==count($a)-2?2:$i+1)
  if($a[$i]>$a[$i+1])
    list($a[$i],$a[$i+1])=[$a[$i+1],$a[$i]];
echo substr(join(' ',$a),5);

संपादित करें: Jörg Hülsermann ने मुझे निहित की बजाय, जुड़ने की याद दिलाई।
नोट: किसी एकल वर्ण फ़ाइल नाम के साथ फ़ाइल में होना चाहिए।

— user59178
स्रोत

php.net/manual/de/function.join.php प्रत्यारोपण का उपनाम

— जॉर्ग हुल्सरमन

$ टी = $ एक [$ i]; $ एक [$ i] = $ एक [$ i + 1]; $ एक [$ i + 1] = $ टी; छोटी है तो सूची ($ [[$ i], $ a [$ i + १]) = [$ [a [$ i + १], $ a [$ i]]; और मुझे यकीन नहीं है कि अगर प्रतिध्वनि की जगह (निहित ('', $ a), 5); यह एक $ एक [1] = शून्य; गूंज में शामिल ('', $ a); बेहतर विकल्प है

— जोर्ग हल्सरमैन

1

अस्थायी चर का उपयोग करते समय 2 बाइट्स छोटी होती हैं, यह भी कई कथन होते हैं, इसलिए आपको घुंघराले ब्रेसिज़ में पूरी चीज़ को घेरने के लिए उन 2 बाइट्स का उपयोग करने की आवश्यकता होती है। व्हॉट्सएप और शुरुआत में फ़ाइल के नाम से बचने के लिए $ a [1] = null के लिए आपको वास्तव में परेशान करना होगा ($ a [0], $ a [1])।

— user59178

1

रूबी, 52 50 बाइट्स

रुको ... नहीं रूबी?

->l,n{n.times{|a|l[s=a%~-l.size,2]=l[s,2].sort};l}

— जीबी
स्रोत

बुलबुला प्रगति में छँटाई

परीक्षण के मामलों:

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

व्याख्या

जावास्क्रिप्ट (ईएस 6), 102 82 80 86 80 बाइट्स

कोशिश करके देखो:

हास्केल, 83 82 81 बाइट्स

पायथन 3, 77 74 बाइट्स

PowerShell v2 +, 135 129 बाइट्स

परीक्षण के मामलों

आर, 132 131 112 136 बाइट्स

पायथ, 34 32 बाइट्स

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

जे , 62 60 बाइट्स

प्रयोग

व्याख्या

मतलाब, 93 91 बाइट्स

ग्रूवी (101 बाइट्स)

उदाहरण आउटपुट ट्रेस:

पुराना कार्यान्वयन (122 बाइट्स)

php, 148 145 बाइट्स

रूबी, 52 50 बाइट्स