सॉर्ट करना 2-आयामी सरणी के लिए कोई मतलब नहीं है ... या करता है?

आपका कार्य एक इनपुट ग्रिड लेना है और एक बबल-सॉर्ट-जैसे एल्गोरिथ्म इसे तब तक लागू करना है जब तक कि ग्रिड के सभी मान बाएं से दाएं और हर पंक्ति और स्तंभ के साथ ऊपर से नीचे तक घटते न हों।

यह एल्गोरिथ्म इस प्रकार काम करता है:

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

उदाहरण

4 2 1
3 3 5
7 2 1

पास की पहली पंक्ति 4 और 2 को स्वैप करेगी, फिर 1 के साथ 4।

2 1 4
3 3 5
7 2 1

जब हम मध्य 3 प्राप्त करते हैं, तो इसे नीचे 2 के साथ स्वैप किया जाएगा

2 1 4
3 2 5
7 3 1

फिर 5 नीचे 1 के साथ स्वैप हो जाता है

2 1 4
3 2 1
7 3 5

पहली पास की अंतिम पंक्ति दाईं ओर 7 सभी तरफ जाती है

2 1 4
3 2 1
3 5 7

फिर हम फिर से शीर्ष पंक्ति पर वापस जाते हैं

1 2 1
3 2 4
3 5 7

और पंक्ति द्वारा पंक्ति जारी रखें ...

1 2 1
2 3 4
3 5 7

... जब तक ग्रिड "क्रमबद्ध" है

1 1 2
2 3 4
3 5 7

एक और उदाहरण

3 1 1
1 1 1
1 8 9

हो जाता है

1 1 1
1 1 1
3 8 9

बजाय

1 1 1
1 1 3
1 8 9

क्योंकि एक सेल के दाएं और नीचे दोनों पड़ोसी समान होने पर नीचे की ओर स्वैप प्राथमिकता लेते हैं।

एक चरण-दर-चरण संदर्भ कार्यान्वयन यहां पाया जा सकता है ।

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

5 3 2 6 7 3 1 0
3 2 1 9 9 8 3 0
3 2 2 8 9 8 7 6

हो जाता है

0 0 1 1 2 2 3 6
2 2 3 3 6 7 8 8
3 3 5 7 8 9 9 9

2 1 2 7 8 2 1 0
2 2 2 2 3 2 1 0
1 2 3 4 5 4 3 2
9 8 7 6 5 4 3 6
6 5 4 3 2 2 1 0

हो जाता है

0 0 0 1 1 1 2 2
1 1 2 2 2 2 2 2
2 2 2 2 3 3 3 3
3 4 4 4 4 5 6 6
5 5 6 7 7 8 8 9

नियम

आप किसी भी सुविधाजनक प्रारूप में इनपुट ग्रिड ले सकते हैं
आप मान सकते हैं कि ग्रिड मान अहस्ताक्षरित 16-बिट श्रेणी (0-65535) में सभी गैर-नकारात्मक पूर्णांक हैं।
आप मान सकते हैं कि ग्रिड एक सही आयत है और दांतेदार सरणी नहीं है। ग्रिड कम से कम 2x2 पर होगा।
यदि आप छंटाई का एक और एल्गोरिथ्म का उपयोग करते हैं, तो आपको एक सबूत देना होगा कि यह हमेशा उसी परिणामी क्रम का उत्पादन करेगा जैसे कि 2 डी बबल सॉर्टिंग का विशेष ब्रांड, इनपुट चाहे जो भी हो। मुझे उम्मीद है कि यह एक गैर-तुच्छ प्रमाण है, इसलिए आप वर्णित एल्गोरिथ्म का उपयोग करके संभवतः बेहतर होंगे।

हैप्पी गोल्फिंग!

code-golf grid

— Beefster
स्रोत

क्या हमें आपकी चुनौती में निर्दिष्ट सटीक एल्गोरिदम को लागू करना है?

— अज्ञानता का अवतार

1

सरणी कम से कम 2x2 होगी?

— Οवसंत

3

@EododimentofIgnorance: केवल तभी यदि आप यह साबित करते हैं कि यह सभी मामलों में एक समान क्रम में परिणाम करता है । मुझे उम्मीद है कि यह एक गैर-तुच्छ प्रमाण होगा।

— बीफस्टर

4

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

— बीफ़स्टर

3

जावास्क्रिप्ट (Node.js) , 129 बाइट्स

a=>[...a+''].map(t=>a.map((l,y)=>l.map((v,x)=>(L=a[y+1]||[],d=L[X=x],r=l[x+1],v>r?r>=d||(L=l,X++):v>d||(L=l),l[x]=L[X],L[X]=v))))

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

— TSH
स्रोत

2

एपीएल (डायलॉग यूनिकोड) , 75 बाइट्स^SBCS

11 बाइट बचाने के लिए @ Adám को धन्यवाद।

{m⊣{d r←⍵∘(s⌊+)¨↓∘.=⍨⍳2⋄∨/c>a c b←m[r⍵d]:m⊢←⌽@⍵(d r⊃⍨1+b>a)⊢m⋄⍬}¨⍳s←⍴m←⍵}⍣≡

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

— voidhawk
स्रोत

-११

— १०

1

वोल्फ्राम भाषा (गणितज्ञ) , 183 बाइट्स

(R=#;{a,b}=Dimensions@R;e=1;g:=If[Subtract@@#>0,e++;Reverse@#,#]&;While[e>0,e=0;Do[If[j<b,c=R[[i,j;;j+1]];R[[i,j;;j+1]]=g@c]If[i<a,c=R[[i;;i+1,j]];R[[i;;i+1,j]]=g@c],{i,a},{j,b}]];R)&

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

मैं एक गणितज्ञ विशेषज्ञ नहीं हूं, मुझे यकीन है कि इसे कम किया जा सकता है। विशेष रूप से मुझे लगता है कि डबल अगर बयान का उपयोग करके छोटा किया जा सकता है, Transposeलेकिन मुझे नहीं पता कि कैसे।

— काई
स्रोत

1

आर , 169 165 144 132 बाइट्स

function(m,n=t(m)){while(any(F-(F=n)))for(i in 1:sum(1|n)){j=(j=i+c(0,r<-nrow(n),!!i%%r))[order(n[j])[1]];n[c(i,j)]=n[c(j,i)]};t(n)}

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

— किरिल एल।
स्रोत

0

साफ , 240 बाइट्स

import StdEnv
$l=limit(iterate?l)
?[]=[]
?l#[a:b]= @l
=[a: ?b]
@[[a,b:c]:t]#(t,[u:v])=case t of[[p:q]:t]=([q:t],if(a>p&&b>=p)[b,p,a]if(a>b)[a,b,p][b,a,p]);_=(t,sortBy(>)[a,b])
=[v%(i,i)++j\\i<-[0..]&j<- @[[u:c]:t]]
@l=sort(take 2l)++drop 2l

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

एल्गोरिथ्म का ठीक उसी प्रकार वर्णन करता है जैसा कि वर्णित है।

लिंक में प्रश्न में प्रारूप लेने के लिए इनपुट पार्सिंग शामिल है।

— Οurous
स्रोत

0

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

m=input()
h=len(m);w=len(m[0])
while 1:
 M=eval(`m`)
 for k in range(h*w):i,j=k/w,k%w;v,b,a=min([(M[x][y],y,x)for x,y in(i,j),(i+(i<h-1),j),(i,j+(j<w-1))]);M[i][j],M[a][b]=M[a][b],M[i][j]
 M!=m or exit(M);m=M

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

_{-7 बाइट्स, ओव्स के लिए धन्यवाद}

— TFeld
स्रोत

डिबग / एसटीडीआरआर के उत्पादन के साथ 208 बाइट्स ।

— अंडा

@ नोव्स, धन्यवाद :)

— TFeld

0

सी # (.NET कोर) , 310 बाइट्स

LINQ के बिना। फ़ंक्शन लौटाए जाने के बाद केवल आउटपुट स्वरूपण के लिए System.Collections.Generic का उपयोग करता है। बात बड़ी भारी है। गोल्फ के लिए आगे देख!

a=>{int x=a.GetLength(0),y=a.GetLength(1);bool u,o;int j=0,k,l,t,z;for(;j<x*y;j++)for(k=0;k<x;k++)for(l=0;l<y;){o=l>y-2?0>1:a[k,l+1]<a[k,l];u=k>x-2?0>1:a[k+1,l]<a[k,l];z=t=a[k,l];if((u&!o)|((u&o)&&(a[k,l+1]>=a[k+1,l]))){t=a[k+1,l];a[k+1,l]=z;}else if((!u&o)|(u&o)){t=a[k,l+1];a[k,l+1]=z;}a[k,l++]=t;}return a;}

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

— Destroigo
स्रोत

0

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

G=input()
O=e=enumerate
while O!=G:
 O=eval(`G`)
 for i,k in e(G):
	for j,l in e(k):v,x,y=min((G[i+x/2][j+x%2],x&1,x/2)for x in(0,1,2)if i+x/2<len(G)and j+x%2<len(k));G[i][j],G[i+y][j+x]=v,l
print G

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

TFeld के जवाब से स्वतंत्र रूप से विकसित, कुछ मतभेद हैं।

— आउटगोल्फ को एरिक करें
स्रोत

0

चारकोल , 118 बाइट्स

≔Ｉ9.e999η≧⁻ηηＦθ⊞ιη⊞θ⟦η⟧ＦΣＥθＬι«ＦＬθ«≔§θκιＦＬι«≔§ιλζ≔§ι⊕λε≔§§θ⊕κλδ¿››ζδ›δε«§≔§θ⊕κλζ§≔ιλδ»¿›ζε«§≔ι⊕λζ§≔ιλε»»»»¿⊟θ¿Ｅθ⊟ιＥθ⪫ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। मैंने कुछ प्रीटियर फॉर्मेटिंग पर कुछ बाइट्स भी खर्च किए हैं। स्पष्टीकरण:

≔Ｉ9.e999η≧⁻ηηＦθ⊞ιη⊞θ⟦η⟧

जावास्क्रिप्ट के पास सुविधाजनक गुण है a[i]>a[i+1]जो गलत है यदि iसरणी का अंतिम तत्व है। चारकोल में यह अनुकरण करने के लिए, मैं तैरने के लिए nanकास्टिंग द्वारा गणना करता हूं 9.e999और फिर इसे खुद से घटाता हूं । (चारकोल घातीय फ्लोट स्थिरांक का समर्थन नहीं करता है।) मैं फिर दाईं ओर मूल सरणी को पैड करता हूं nanऔर साथ ही एक अतिरिक्त पंक्ति भी जोड़ता हूं nan। (चारकोल के चक्रीय अनुक्रमण का मतलब है कि मुझे उस पंक्ति में केवल एक तत्व की आवश्यकता है।)

ＦΣＥθＬι«

सरणी में प्रत्येक तत्व के लिए लूप। यह काम करने के लिए पर्याप्त छोरों से अधिक होना चाहिए, क्योंकि मैं सभी अतिरिक्त nanएस भी शामिल हूं ।

ＦＬθ«≔§θκι

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

ＦＬι«≔§ιλζ

प्रत्येक कॉलम इंडेक्स पर लूप करें और उस इंडेक्स पर मान प्राप्त करें। फिर, यह डमी मूल्यों पर लूप करेगा लेकिन तुलनाएं फिर से विफल हो जाएंगी।

≔§ι⊕λε≔§§θ⊕κλδ

इसके अलावा दाईं ओर और नीचे मान प्राप्त करें।

¿››ζδ›δε«§≔§θ⊕κλζ§≔ιλδ»

यदि सेल नीचे के मान से अधिक है और यह सही नहीं है कि नीचे का मान दाईं ओर के मूल्य से अधिक है तो नीचे दिए गए मान के साथ सेल को स्वैप करें।

¿›ζε«§≔ι⊕λζ§≔ιλε»»»»

अन्यथा यदि सेल दाईं ओर मान से अधिक है, तो उन्हें स्वैप करें।

¿⊟θ¿Ｅθ⊟ιＥθ⪫ι

nanमान निकालें और निहित आउटपुट के लिए सरणी को प्रारूपित करें।

— नील
स्रोत

0

कोटलिन , 325 बाइट्स

{m:Array<Array<Int>>->val v={r:Int,c:Int->if(r<m.size&&c<m[r].size)m[r][c]
else 65536}
do{var s=0>1
for(r in m.indices)for(c in m[r].indices)when{v(r,c)>v(r+1,c)&&v(r+1,c)<=v(r,c+1)->m[r][c]=m[r+1][c].also{m[r+1][c]=m[r][c]
s=0<1}
v(r,c)>v(r,c+1)&&v(r,c+1)<v(r+1,c)->m[r][c]=m[r][c+1].also{m[r][c+1]=m[r][c]
s=0<1}}}while(s)}

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

— JohnWells
स्रोत

2-डायमेंशनल बबल सॉर्ट

उदाहरण

एक और उदाहरण

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

नियम

जावास्क्रिप्ट (Node.js) , 129 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 75 बाइट्स SBCS

वोल्फ्राम भाषा (गणितज्ञ) , 183 बाइट्स

आर , 169 165 144 132 बाइट्स

साफ , 240 बाइट्स

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

सी # (.NET कोर) , 310 बाइट्स

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

चारकोल , 118 बाइट्स

कोटलिन , 325 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 75 बाइट्स^SBCS