11

यह एक कोड-गोल्फ प्रश्न है।

इनपुट

जो भी प्रारूप में गैर-नकारात्मक पूर्णांक की एक सूची सबसे सुविधाजनक है।

उत्पादन

जो भी प्रारूप में क्रमबद्ध क्रम में वही सूची सबसे सुविधाजनक है।

बंधन

आपका कोड ओ (एन लॉग एन) समय में सबसे खराब स्थिति में चलना चाहिए जहां nइनपुट में पूर्णांकों की संख्या है। इसका मतलब यह है कि यादृच्छिक quicksort उदाहरण के लिए बाहर है। हालाँकि चुनने के लिए कई अन्य विकल्प हैं।
किसी भी प्रकार की लाइब्रेरी / फ़ंक्शन / समान का उपयोग न करें। इसके अलावा किसी भी चीज का उपयोग न करें जो आपके लिए ढेर पुस्तकालय की तरह छँटाई का काम करता है। मूल रूप से, आप जो भी लागू करते हैं, उसे खरोंच से लागू करते हैं।

आप एक फ़ंक्शन को परिभाषित कर सकते हैं यदि आपको पसंद है लेकिन फिर कृपया एक पूर्ण कार्यक्रम वास्तव में काम कर रहा है, इसका एक उदाहरण दिखाएं। यह नीचे दिए गए सभी परीक्षण मामलों पर सफलतापूर्वक और जल्दी से चलना चाहिए।

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

In: [9, 8, 3, 2, 4, 6, 5, 1, 7, 0]
Out:[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In: [72, 59, 95, 68, 84]
Out:[59, 68, 72, 84, 95]

In: [2, 2, 1, 9, 3, 7, 4, 1, 6, 7]
Out:[1, 1, 2, 2, 3, 4, 6, 7, 7, 9]

In: [2397725, 1925225, 3304534, 7806949, 4487711, 8337622, 2276714, 3088926, 4274324,  667269]
Out:[667269,1925225, 2276714, 2397725,3088926, 3304534, 4274324, 4487711, 7806949, 8337622]

आपके उत्तर

कृपया आपके द्वारा लागू किए गए सॉर्टिंग एल्गोरिदम और आपके उत्तर की शीर्षक में आपके समाधान की लंबाई बताएं।

ओ (एन लॉग एन) एल्गोरिदम को छांटने का समय

अस्तित्व में कई ओ (एन लॉग एन) समय एल्गोरिदम हैं। इस तालिका में उनमें से कुछ की सूची है।

कुछ सेट फ़ंक्शंस जैसे कि intersectस्वचालित रूप से सरणी को सॉर्ट करते हैं। मुझे लगता है कि आप उन लोगों को भी नियम देना चाहते हैं। कैसे के बारे में unique(डुप्लिकेट निकालें, परिणाम को सॉर्ट करें)?

— लुइस मेन्डो

@DonMuesli मैं करता हूं .. मुझे लगता intersectहै कि यह "समान" के तहत आता है अगर यह स्वचालित रूप से सरणी को सॉर्ट करता है। यदि आप डुप्लिकेट निकालते हैं तो आप गलत आउटपुट देंगे।

गलत इनपुट देने के बारे में, कि मुझे छोड़ दो :-) तो "डुप्लिकेट को हटाएं और सॉर्ट करें" का उपयोग किया जा सकता है?

— लुइस मेंडो

3

नाइटपिक: 0 एक सकारात्मक पूर्णांक नहीं है। ( इनपुट के तहत )

— बीकर

1

मुझे यह पसंद है कि जैसे ही प्रश्न का प्रदर्शन के साथ कुछ भी करना है सभी को गोल्फ भाषाओं से दूर झुकाते हैं भले ही यह अभी भी कोड-गोल्फ है और सबसे छोटा समाधान अभी भी जीत जाएगा।

— साइओस

8

हास्केल, 87 80 89

s%[]=s
(x:a)%q|x<=q!!0=x:a%q
p%q=q%p
j(x:y:s)=x%y:j s
j a=a
r[x]=x
r s=r$j s
s=r.map(:[])

यह मर्ज सॉर्ट है, जिसे नीचे से ऊपर तक लागू किया गया है। पहले हम प्रत्येक तत्व को अपनी सूची में पैकेज करते हैं, और फिर उन्हें दो-बाय-टू मर्ज करते हैं, और फिर उन्हें दो-दो-दो में विलय कर देते हैं, जब तक कि हम एक सूची के साथ नहीं रहते।

(%)मर्ज फ़ंक्शन
jएक सूची में जोड़े को मर्ज करता है सूचियों का
rपूर्ण विलय होता है सूचियों की एक पूरी सूची
sसॉर्टिंग फ़ंक्शन है।

उपयोग: एक दुभाषिया चलाएं, और दर्ज करें s [3,5,2,6,7]।

संपादित करें: जिस तरह से मैं चीजों का विलय कर रहा था, वह सही क्रम नहीं था, इसलिए इसे ठीक करने के लिए मुझे 9 और पात्रों की आवश्यकता थी।

— गर्वित हेकलर
स्रोत

1

@Lembik यदि आप प्रोग्राम का परीक्षण करना चाहते हैं, और आप हास्केल को स्थापित नहीं करना चाहते हैं, तो आप आइडोन का उपयोग कर सकते हैं, और एक पंक्ति जोड़ सकते हैं main = print (s [5,3,6,8]), जो सॉर्टिंग के परिणाम को प्रिंट करने के लिए मुख्य सेट करेगा।

— गर्वित हैकेलर

मुझे लगता है कि आपको इसकी आवश्यकता नहीं है []%s=s, क्योंकि यदि पहला तत्व है [], तो (x:a)मैच विफल हो जाता है और अंतिम मामला तत्वों को फ़्लिप करता है, जिससे वह s%[]सफल होता है।

— nimi

आप विजेता हैं! कम बाइट्स का उपयोग करने वाला एकमात्र उत्तर O (n लॉग एन) में नहीं चला।

@ लेम्बिक राइट, मैं भूल गया कि जेली जवाब का पालन नहीं किया।

— गर्वित हैकेलर

1

अब ऐसा लगता है :)

5

जावास्क्रिप्ट (ईएस 6), 195 193 191 189 188 186 183 182 179 174 172 बाइट्स

यह एक भारी कार्यान्वयन है। मैं उम्मीद करता हूं कि कोई व्यक्ति छोटे विलय के साथ आएगा, लेकिन मुझे यह पसंद है: पी

अद्यतन: आर मर्जर्ट पीटा। रूबी नेक्स्ट: डी

S=l=>{e=l.length
W=(a,b)=>[l[a],l[b]]=[l[b],l[a]]
D=s=>{for(;(c=s*2+1)<e;s=r<s?s:e)s=l[r=s]<l[c]?c:s,W(r,s=++c<e&&l[s]<l[c]?c:s)}
for(s=e>>1;s;)D(--s)
for(;--e;D(0))W(0,e)}

परीक्षण (फ़ायरफ़ॉक्स)

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

S=l=>{e=l.length
W=(a,b)=>[l[a],l[b]]=[l[b],l[a]]
D=s=>{for(;(c=s*2+1)<e;s=r<s?s:e)s=l[r=s]<l[c]?c:s,W(r,s=++c<e&&l[s]<l[c]?c:s)}
for(s=e>>1;s;)D(--s)
for(;--e;D(0))W(0,e)}

document.querySelector('#d').addEventListener("click",function(){a=JSON.parse(document.querySelector('#a').value);S(a);document.querySelector('#b').innerHTML=JSON.stringify(a)});

<textarea id="a">[9,4,1,2,7,3,5,8,6,10]</textarea><br><button id="d">Sort</button><br><pre id="b"></pre>

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

— PurkkaKoodari
स्रोत

मैं एक उत्कट उत्तर लिखने के लिए प्यार करता था, लेकिन यह हास्केल के साथ वास्तव में अच्छा काम नहीं करता है। मेरा अगला प्रयास JS होगा, लेकिन आपने इसे पूरा कर लिया है। शायद मैं फिर भी ऐसा करूंगा। Idk

— गर्व haskeller

@proudhaskeller आह हाँ .. मैंने अभी देखा stackoverflow.com/a/2186785/2179021 ।

3

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

def S(l):
 if len(l)<2:return l
 a,b,o=S(l[::2]),S(l[1::2]),[]
 while a and b:o.append([a,b][a[-1]<b[-1]].pop())
 return a+b+o[::-1]

साधारण मर्ज। बाइट्स के बहुत सारे खर्च यह सुनिश्चित करने के लिए खर्च किए गए थे कि यह वास्तव में ओ (एन लॉग एन) में चलता है, अगर केवल एल्गोरिथ्म , लेकिन कार्यान्वयन को ओ (एन लॉग एन) होने की आवश्यकता नहीं है , तो इसे छोटा किया जा सकता है:

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

def m(a,b):
 while a+b:yield[a,b][a<b].pop(0)
S=lambda l:l[1:]and list(m(S(l[::2]),S(l[1::2])))or l

यह O (n log n) नहीं .pop(0)है क्योंकि O (n) है, जो मर्ज फ़ंक्शन O (n ^ 2) बनाता है। लेकिन यह काफी कृत्रिम है, क्योंकि .pop(0)आसानी से ओ (1) हो सकता है।

— orlp
स्रोत

इसके लिए शुक्रिया। मेरा निश्चित रूप से मतलब था कि एल्गोरिथ्म और कार्यान्वयन ओ होना चाहिए (एन लॉग एन)।

स्पष्ट होने के लिए, इसका मतलब है कि 132 संस्करण ठीक है लेकिन 99 बाइट संस्करण गैर-अनुपालन योग्य है।

2

जूलिया, 166 बाइट्स

m(a,b,j=1,k=1,L=endof)=[(j<=L(a)&&k<=L(b)&&a[j]<b[k])||k>L(b)?a[(j+=1)-1]:b[(k+=1)-1]for i=1:L([a;b])]
M(x,n=endof(x))=n>1?m(M(x[1:(q=ceil(Int,n÷2))]),M(x[q+1:n])):x

प्राथमिक फ़ंक्शन को कहा जाता है Mऔर यह एक सहायक फ़ंक्शन को कॉल करता है m। यह मर्ज सॉर्ट का उपयोग करता है , जिसमें ओ ( एन लॉग एन ) इसकी सबसे खराब स्थिति है।

उदाहरण का उपयोग करें:

x = [9, 8, 3, 2, 4, 6, 5, 1, 7, 0]
println(M(x))              # prints [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
println(M(x) == sort(x))   # prints true

Ungolfed:

function m(a, b, i=1, k=1, L=endof)
    return [(j <= L(a) && k <= L(b) && a[j] < b[k]) || k > L(b) ?
            a[(j+=1)-1] : b[(k+=1)-1] for i = 1:L([a; b])]
end

function M(x, n=endof(x))
    q = ceil(Int, n÷2)
    return n > 1 ? m(M(x[1:q]), M([q+1:n])) : x
end

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

जूलिया को यहां देखना अच्छा है। अब हमें निम और जंग की भी आवश्यकता है :)

1

@ लिम्बिक मुझे लगता है कि क्रमशः Sp3000 और Doorknob हमारे निवासी निम और जंग विशेषज्ञ हैं। उम्मीद है कि वे मस्ती में भी शामिल हों। ;)

— एलेक्स ए।

2

आर, 181 बाइट्स, मर्जसॉर्ट

L=length;s=function(S)if(L(S)<2){S}else{h=1:(L(S)/2);A=s(S[h]);B=s(S[-h]);Z=c();if(A[L(A)]>B[1])while(L(A)&L(B))if(A[1]<B[1]){Z=c(Z,A[1]);A=A[-1]}else{Z=c(Z,B[1]);B=B[-1]};c(Z,A,B)}

नई कहानियों के साथ प्रस्तुत:

L=length
s=function(S)
    if(L(S)<2){
        S
    }else{
        h=1:(L(S)/2)
        A=s(S[h])
        B=s(S[-h])
        Z=c()
        if(A[L(A)]>B[1])
#Merge helper function incorporated from here ...
            while(L(A)&L(B))
                if(A[1]<B[1]){
                    Z=c(Z,A[1])
                    A=A[-1]
                }else{
                    Z=c(Z,B[1])
                    B=B[-1]
                }
#...to here. Following line both finishes merge function and handles 'else' case:
        c(Z,A,B)
    }

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

> L=length;s=function(S)if(L(S)<2){S}else{h=1:(L(S)/2);A=s(S[h]);B=s(S[-h]);Z=c();if(A[L(A)]>B[1])while(L(A)&L(B))if(A[1]<B[1]){Z=c(Z,A[1]);A=A[-1]}else{Z=c(Z,B[1]);B=B[-1]};c(Z,A,B)}
> s(c(2397725, 1925225, 3304534, 7806949, 4487711, 8337622, 2276714, 3088926, 4274324,  667269))
 [1]  667269 1925225 2276714 2397725 3088926 3304534 4274324 4487711 7806949 8337622
> s(c(2, 2, 1, 9, 3, 7, 4, 1, 6, 7))
 [1] 1 1 2 2 3 4 6 7 7 9
> s(c(72, 59, 95, 68, 84))
 [1] 59 68 72 84 95
> s(c(9, 8, 3, 2, 4, 6, 5, 1, 7, 0))
 [1] 0 1 2 3 4 5 6 7 8 9

— plannapus
स्रोत

2

स्काला, 243 बाइट फ़ंक्शन (315 बाइट्स स्टैंड-अलोन ऐप), मर्जसॉर्ट

इस उत्तर का उद्देश्य एक फ़ंक्शन होना है, लेकिन इसे स्टैंड-अलोन एप्लिकेशन के रूप में विस्तारित किया जा सकता है।

फंक्शन-ओनली (243 बाइट्स):

object G{
type S=Stream[Int]
def m(f:(S,S)):S=f match{
case(x#::a,b@(y#::_))if x<=y=>x#::m(a,b)
case(a,y#::b)=>y#::m(a,b)
case(a,Empty)=>a
case(_,b)=>b}
def s(a:S):S=if(a.length>1)((q:S,w:S)=>m(s(q),s(w))).tupled(a.splitAt(a.length/2))else a
}

स्टैंड-अलोन एप्लिकेशन (315 बाइट्स):

object G extends App{
type S=Stream[Int]
def m(f:(S,S)):S=f match{
case(x#::a,b@(y#::_))if x<=y=>x#::m(a,b)
case(a,y#::b)=>y#::m(a,b)
case(a,Empty)=>a
case(_,b)=>b}
def s(a:S):S=if(a.length>1)((q:S,w:S)=>m(s(q),s(w))).tupled(a.splitAt(a.length/2))else a
println(s(args(0).split(",").map(_.toInt).toStream).toList)
}

उपयोग:

समारोह: G.s(List(**[Paste your array here]**).toStream).toList

आवेदन: sbt "run **[Paste your array here]**"

उदाहरण इनपुट:

scala> G.s(List(10,2,120,1,8,3).toStream).toList

(OR)

$ sbt "run 5423,123,24,563,65,2,3,764"

आउटपुट:

res1: सूची [इंट] = सूची (1, 2, 3, 8, 10, 120)

या

सूची (2, 3, 24, 65, 123, 563, 764, 5423)

अड़चनें और विचार:

स्केलाज़ की आवश्यकता है (बहुत सामान्य पुस्तकालय, यहाँ छँटाई के लिए उपयोग नहीं किया गया है)
100% कार्यात्मक है (कुछ भी नहीं है!)

श्रेय:

m()इस जवाब से प्रेरित कार्यान्वयन ( कार्य): https://codereview.stackexchange.com/a/21590/28856

— रुस्लान
स्रोत

2

जेली, 29 बाइट्स, मर्ज सॉर्ट

ऑर्लप के पायथन उत्तर की तरह, यह list.pop(0)हुड के तहत उपयोग करता है , जो है O(n), लेकिन कार्यान्वयन औपचारिक रूप से है O(n log n)।

ṛð>ṛḢð¡Ḣ;ñ
ç;ȧ?
s2Zß€ç/µL>1µ¡

इसे यहाँ आज़माएँ।

व्याख्या

               Define f(x, y):    (merge helper)
                 Implicitly store x in α.
ṛ    ð¡          Replace it with y this many times:
 ð>ṛḢ              (x > y)[0].
       Ḣ         Pop the first element off that list (either x or y).
        ;ñ       Append it to g(x, y).

               Define g(x, y):    (merge)
  ȧ?             If x and y are non-empty:
ç                  Return f(x, y)
                 Else:
 ;                 Return concat(x, y).

               Define main(z):    (merge sort)
       µL>1µ¡    Repeat (len(z) > 1) times:
s2                 Split z in chunks of length two.   [[9, 7], [1, 3], [2, 8]]
  Z                Transpose the resulting array.     [[9, 1, 2], [7, 3, 8]]
   ß€              Apply main() recursively to each.  [[1, 2, 9], [3, 7, 8]]
     ç/            Apply g on these two elements.     [1, 2, 3, 7, 8, 9]

— लिन
स्रोत

क्या आप कृपया कुछ स्पष्टीकरण जोड़ना चाहेंगे।

समझाने के लिए बहुत कुछ है :) मुझे देखने दें कि क्या मैं आखिरी पंक्ति को थोड़ा और नीचे कर सकता हूं

— लिन

जब आप कहते हैं कि कार्यान्वयन हे (n लॉग एन) है, लेकिन यह हुड के तहत लिस्ट। पॉप (0) का उपयोग करता है, जो कि हे (एन) मैं भ्रमित हूं। क्या मतलब?

मेरा मतलब है कि orlp ने अपने उत्तर में क्या लिखा है: यह O (n log n) नहीं .pop(0)है क्योंकि O (n) है, जो मर्ज फंक्शन O (n ^ 2) बनाता है। लेकिन यह काफी कृत्रिम है, क्योंकि .pop(0)आसानी से ओ (1) हो सकता है।

— लिन

जेली को पायथन में लागू किया गया है और Ḣइसे लागू किया गया है .pop(0)।

— लिन

1

रूबी, 167 बाइट्स

गोल्फ मर्ज सॉर्ट एल्गोरिथ्म, जिसमें सबसे खराब स्थिति ओ (एन लॉग एन) है

f=->x{m=->a,b{i,j,l,y,z=0,0,[],a.size,b.size
while i<y&&j<z
c=a[i]<b[j]
l<<(c ?a[i]:b[j])
c ?i+=1:j+=1
end
l+=a[i,y]+b[j,z]}
l=x.size
l>1?m[f[x[0,l/2]],f[x[l/2,l]]]:x}

यह यहाँ परीक्षण!

विंडो में कोड का परीक्षण, कॉपी और पेस्ट करने के लिए, और puts f[x]सबसे नीचे जोड़ें , जहां x इनपुट के साथ एक सरणी है। (सुनिश्चित करें कि आप रूबी को भाषा के रूप में चुनते हैं, निश्चित रूप से) उदाहरण के लिए,puts f[[2, 2, 1, 9, 3, 7, 4, 1, 6, 7]]

— मान स्याही
स्रोत

इसके लिए शुक्रिया! क्या आप इसे काम करते हुए भी दिखा सकते हैं?

1

मैंने एक लिंक जोड़ा ताकि आप इसका परीक्षण कर सकें।

— वैल्यू इंक

1

रूबी, 297 बाइट्स

मर्ज़ सॉर्ट। एक कार्यक्रम के बजाय पूरा कार्यक्रम। रनटाइम पर दो तर्कों की आवश्यकता होती है: इनपुट फ़ाइल और आउटपुट फ़ाइल, प्रत्येक एक लाइन प्रति तत्व के साथ।

if $0==__FILE__;v=open(ARGV[0]).readlines.map{|e|e.to_i}.map{|e|[e]};v=v.each_slice(2).map{|e|a,b,r=e[0],e[1],[];while true;if(!a)||a.empty?;r+=b;break;end;if(!b)||b.empty?;r+=a;break;end;r<<(a[0]<b[0]?a:b).shift;end;r}while v.size>1;open(ARGV[1],"w"){|f|f.puts(v[0].join("\n"))if !v.empty?};end

— jose_castro_arnaud
स्रोत

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

— गर्वित हैकेलर

यदि आप इसे फंक्शन के बजाय पूर्ण प्रोग्राम के रूप में रखने जा रहे हैं, तो क्या मैं क्रमशः इनपुट / आउटपुट के रूप में STDIN और STDOUT का उपयोग करने का सुझाव दे सकता हूं? $stdin.readlinesपहले से ही कम से कम बाइट्स open(ARGV[0]).readlines, के साथ एक ही putsखत्म हो गयाopen(ARGV[1],"w"){|f|f.puts

— मूल्य इंक

2

और सामान की तरह if $0==__FILE__एक कोड गोल्फ में वास्तव में अनावश्यक है। आप ;एक नई पंक्ति के साथ प्रत्येक की जगह कंडेनसर भी ले सकते हैं - यह एक ही बाइट गिनती है और (शायद) कोड के क्षैतिज स्क्रॉल को हटा देता है। इसके अलावा, मैं रूबी में गोल्फ के लिए युक्तियों की जांच करने की सलाह दूंगा ।

— डानिएरो

क्लासिक सॉर्टिंग कोड-गोल्फ प्रश्न

हास्केल, 87 80 89

जावास्क्रिप्ट (ईएस 6), 195 193 191 189 188 186 183 182 179 174 172 बाइट्स

परीक्षण (फ़ायरफ़ॉक्स)

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

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

जूलिया, 166 बाइट्स

आर, 181 बाइट्स, मर्जसॉर्ट

स्काला, 243 बाइट फ़ंक्शन (315 बाइट्स स्टैंड-अलोन ऐप), मर्जसॉर्ट

जेली, 29 बाइट्स, मर्ज सॉर्ट

व्याख्या

रूबी, 167 बाइट्स

रूबी, 297 बाइट्स