किसी भी अंतर्निहित सॉर्ट पद्धति का उपयोग किए बिना स्ट्रिंग्स की एक सूची को सॉर्ट करना

Question

इस कोड गोल्फ का लक्ष्य एक ऐसा प्रोग्राम बनाना है जो बिना किसी अंतर्निहित सॉर्ट विधि (जैसे Array.Sort().NET, sort()PHP, ...) में उपयोग किए बिना स्ट्रिंग्स की एक सूची को सॉर्ट करता है (आरोही क्रम में)। ध्यान दें कि यह प्रतिबंध एक अंतर्निहित पद्धति का उपयोग करके बाहर आता है जो एक सरणी को अवरोही बनाता है, और फिर सरणी को उलट देता है।

कुछ विवरण:

• आपके प्रोग्राम को इनपुट के लिए संकेत करना चाहिए, और यह इनपुट केवल ASCII लोअर-केस अल्फ़ाबेटिक वर्ण a-z, अल्पविराम से अलग किए बिना स्ट्रिंग की एक सूची है । उदाहरण के लिए:

  code,sorting,hello,golf
  

• आउटपुट स्ट्रिंग्स की दी गई सूची होनी चाहिए, लेकिन आरोही क्रम में सॉर्ट किया गया, फिर भी रिक्त स्थान के बिना अल्पविराम से अलग किया गया। उदाहरण के लिए:

  code,golf,hello,sorting
  

Answer 1

गोल्फस्क्रिप्ट, 26 25 बाइट्स

","/.,{{.2$<{\}*}*]}*","*

बबल सॉर्ट का स्ट्रेटफ़ोर्ड कार्यान्वयन।

इसे ऑनलाइन वेब गोल्फस्क्रिप्ट में आज़माएं ।

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

","/     # Split the input string at commas.
.,       # Get the number of chunks.
{        # Do that many times:
  {      #   Reduce; for each element but the first:
    .2$< #     Push 1 if the last two strings are in descending order, 0 if not.
    {\}* #     Swap these strings that many times.
  }*]    #   Collect the strings dumped by reduce in an array.
}*       #
","*     # Join, separating by commas.

Comments

अच्छा! इस एक को उत्तर के रूप में स्वीकार करना क्योंकि यह वर्तमान में स्वीकृत एक से कम है।

— प्रोग्रामफॉक्स

Answer 2

रूबी 76 54 51 चार

x=gets.scan /\w+/;$><<x.dup.map{x.delete(x.min)}*?,

Comments

बहुत अच्छा, bogosort : डी

— दरवाज़े

वाह, अब यह और भी दिलचस्प है! मुझे यह देखने के लिए कुछ समय पहले देखना पड़ा कि क्या हो रहा है। मैं अब लगता है यह चयन की एक मामूली बदलाव प्रकार है: पी

— दरवाज़े

चूंकि आइटम अल्फा वर्ण होने की गारंटी है:x=gets.scan /\w+/

— स्टीवन रूंबल्स्की

Answer 3

k (16 वर्ण)

शायद वास्तव में समस्या की भावना तक नहीं रहती है। K में, सॉर्ट ऑपरेटर में कोई निर्मित नहीं है । <xक्रमबद्ध क्रम में x में वस्तुओं के सूचकांकों की सूची देता है।

{x@<x}[","\:0:0]

Comments

खैर, यह एक तरह का बिल्ट-इन सॉर्टिंग है, इसलिए दुर्भाग्य से, मैं इसे उत्तर के रूप में चिह्नित नहीं कर सकता। मुझे यह विचार पसंद है, फिर भी, +1!

— प्रोग्रामफॉक्स

Answer 4

एसईडी, 135

s/.*/,&,!,abcdefghijklmnopqrstuvwxyz/;:;s/\(,\([^,]*\)\(.\)[^,]*\)\(.*\)\(,\2\(.\)[^,]*\)\(.*!.*\6.*\3\)/\5\1\4\7/;t;s/^,\(.*\),!.*/\1/

मेरी पिछली सॉर्टिंग प्रविष्टि के आधार पर

Answer 5

रूबी, 99 वर्ण ( सूक्ति प्रकार )

a=gets.scan /\w+/
p=1
while a[p]
a[p]>a[p-1]?p+=2:(a[p],a[p-1]=a[p-1],a[p])
p-=1if p>1
end
$><<a*?,

यह मेरे बबल सॉर्ट कार्यान्वयन को मुश्किल से बीट करता है:

रूबी, 110 104 101 वर्ण ( बबल सॉर्ट )

s=gets.scan /\w+/
(z=s.size).times{(0..(z-2)).map{|i|s[i],s[i+1]=s[i+1],s[i]if s[i]>s[i+1]}}
$><<s*?,

यह list.lengthपुनरावृत्तियों करता है , क्योंकि सबसे खराब स्थिति list.length - 1पुनरावृत्तियों को लेती है और एक और वास्तव में कोई फर्क नहीं पड़ता है, और 2 वर्ण बचाता है।

बस मनोरंजन के लिए, एक क्विकसॉर्ट संस्करण:

रूबी, 113 वर्ण ( क्विकॉर्ट )

q=->a{if a[1]
p=a.shift
l=[]
g=[]
a.map{|x|(x>p ?g:l).push x}
q[l]+[p]+q[g]
else
a
end}
$><<q[gets.scan /\w+/]*?,

Comments

मैंने पाया कि इनपुट प्रकार के सभी अद्वितीय नहीं हैं, उदाहरण के लिए, जब gnome सॉर्ट लूप का यह कार्यान्वयन असीम रूप से होता है।

— स्कॉट लेडले

Answer 6

हास्केल, 141

import Data.List
m=minimum
s[]=[]
s l=m l:s(l\\[m l])
t[]=[]
t s=let(a,b)=span(/=',')s in a:t(drop 1 b)
main=interact$intercalate",".s.t.init

कम से कम ... यह कुशल की तरह है।

Comments

आप चयन प्रकार का उपयोग करके 11 वर्णों को बचा सकते हैं: m=minimum s[]=[] s l=m l:(s$l\\[m l])(इन पंक्तियों के साथ अपनी रेखाओं को 2-4 बदलें)।

— user3389669

ऐसा initलगता है कि आवश्यक नहीं है क्योंकि न तो कोई अनुगामी है ,, न ही अनुगामी न्यूलाइन है। t s=let(a,b)=span(/=',')s in a:t(drop 1 b), एक पैटर्न गार्ड का उपयोग कर का उपयोग करके छोटा किया जा सकता (>',')है और बीच की जगह छोड़ने 1 b: t s|(a,b)<-span(>',')s=a:t(drop 1b)।

— लकोनी

सम्मिलित फ़ंक्शन के साथ सम्मिलन का उपयोग x#(y:r)|y<x=y:x#r;x#r=x:rकम है। इसे सीधे उपयोग किया जा सकता है tऔर जैसा कि यह उपयोग नहीं करता है (\\)और intercalate","इसे प्रतिस्थापित किया जा सकता है tail.((',':)=<<), आयात को गिराया जा सकता है। सभी एक साथ 101 बाइट्स: इसे ऑनलाइन आज़माएं!

— लकोनी

Answer 7

vba, 165

Sub q()
c=","
s=InputBox("?")
Z=Split(s, c)
t=UBound(Z)
For i=1 To t-1
For j=i To t
If Z(i)>Z(j) Then a=Z(i):Z(i)=Z(j):Z(j)=a
Next
Next
Debug.Print Join(Z,c)
End Sub

Comments

मैं 165 पात्रों गिनती ...

— दरवाज़े

@Doorknob, फिक्स्ड काउंट ... ग्रीसीमोनी स्क्रिप्ट ने मुझे गलत गणना दी क्योंकि मैं कोड में टाइप कर रहा था।

— सीनसी

आप उस में एक जगह से छुटकारा पा सकते हैं Split।

— Ry-

इस मामले में बाइट की गिनती में दो बार उपयोग करना c=","और कॉल करना c, बाइट की गिनती में 7 बाइट का योगदान देता है, जहां सिर्फ "का उपयोग करते हुए", "दो बार 6 बाइट में योगदान करेगा।" आप सीधे उप कॉल ( sub q(s)) से इनपुट लेकर अपने बाइट कोड को कम कर सकते हैं और मान लेते हैं कि प्रकार variant \ string है। आप को बदलने के द्वारा एक और बाइट खो सकते हैं For i=1 toकरने के लिए for i=1To। आप को बदलने के द्वारा 5 बाइट्स खो सकते हैं Debug.Print Join...करने के लिएDebug.?Join...

— टेलर स्कॉट

Answer 8

स्काला, 122 बाइट्स

एक-लाइनर (88 बाइट्स) के रूप में:

.permutations.filter(_.sliding(2).map(w=>w(0)<w.last).fold(true)((a,b)=>a&&b)).toSeq(0)

(यह सिर्फ करने से एक सूची को सॉर्ट करेगा list.permutations.fil...)

एक कार्यक्रम के रूप में (122 बाइट्स):

println(readLine.split(",").toSeq.permutations.filter(_.sliding(2).map(w=>w(0)<w.last).fold(true)((a,b)=>a&&b)).toSeq(0))

एक लंबा संस्करण यदि आप चाहते हैं कि इसे स्टडिन से पढ़ें।

यह दी गई सूची के सभी क्रमपरिवर्तन पर तब तक पुनरावृत्ति करता है जब तक कि वह छँटे हुए पर नहीं। यह तेजी से नहीं है क्योंकि 10 तत्वों की सूची को सॉर्ट करने के लिए लगभग 12 सेकंड लगते हैं और 11 तत्वों में से एक मिनट के लिए अच्छी तरह से।

[संपादित करें] आइटमों को विशिष्ट होना चाहिए या उनके <द्वारा प्रतिस्थापित किया जा सकता है <=। इसके अलावा, necro के लिए क्षमा करें।

Answer 9

जावास्क्रिप्ट 128

a=prompt().split(',');b=[];for(i in a){b.push(a[i]);k=0;for(j in b){j=k;b[j]>a[i]?[c=b[j],b.splice(j,1),b.push(c)]:k++}}alert(b)

डेमो ।

मैं एक तरह से खत्म करने के लिए देख रहा हूँ b।

Comments

निकालें []के बाद वाले हिस्से के आसपास ?2 वर्ण को बचाने के लिए

— दरवाज़े

@Doorknob मैंने इसे प्राप्त करने से पहले इसकी कोशिश की है SyntaxError: missing : in conditional expressionक्योंकि ?:;(आशुलिपि if/else) केवल कोड के दो पेकेज़ को निष्पादित करने के लिए माना जाता है (यानी true?b++:b--;) का उपयोग करना [, ]एक हैक है, अभी भी निश्चित नहीं है कि यह क्यों काम करता है, मुझे लगता है कि यह एक खाली सरणी के रूप में समझा जाता है घोषणा, एक यादृच्छिक स्ट्रिंग या संख्या को स्टैंड-अलोन कमांड के रूप में रखने की तरह। लेकिन आप अभी भी अपवित्र महसूस कर सकते हैं।

— मैथ चिलर

हम्म, मुझे लगता है कि मुझसे गलती हुई। अल्पविराम ऑपरेटर एक साथ कई टुकड़ों को निष्पादित कर सकता है। कोष्ठक काम करता है का उपयोग करना है, तो मुझे लगता है कि ?:ऑपरेटर के पूर्वता से कम है,

— दरवाज़े

नहीं, तुमने कोशिश की? कोष्ठक अभी भी काम ...

— दरवाज़े

@Doorknob आपका अधिकार , हालांकि मैंने कोशिश की {, }और यह काम नहीं किया - मुझे मिलता है SyntaxError: missing : after property id। जैसा कि पूर्ववर्ती कोष्ठक हमेशा पहले होता है। मैं अभी भी एक उत्थान चाहूंगा ....

— मठ चिलर

Answer 10

PHP 83 बाइट्स

<?for($x=fgetcsv(STDIN);$x;)${$x[0]>min($x)?x:a}[]=array_shift($x)?><?=join(~Ó,$a);

एक O (n ³ ) चयन प्रकार का कार्यान्वयन। Óचरित्र 211 है, एक बिट-उलटा अल्पविराम।

नमूना उपयोग:

$ more in.dat
code,sorting,hello,golf

$ php list-sort.php < in.dat
code,golf,hello,sorting

Answer 11

पायथन 3 (80 वर्ण)

l=input().split(',')
m=[]
while l:m+=[l.pop(l.index(min(l)))]
print(','.join(m))

यहाँ उस समय-कथन का एक रूपांतर है जो समान लंबाई का है:

while l:x=min(l);m+=[x];l.remove(x)

Answer 12

गणितज्ञ 66 56

Row[#[[Ordering@#]]&[InputString[]~StringSplit~","],","]

बिल्ड-इन प्रतीक के बिना कुछ अन्य समाधान Ordering:

बोगोसॉर्ट: 84 74

NestWhile[RandomSample,InputString[]~StringSplit~",",!OrderedQ@#&]~Row~","

बबल सॉर्ट: 93 83

Row[InputString[]~StringSplit~","//.{x___,i_,j_,y___}/;j~Order~i==1:>{x,j,i,y},","]

अशुभ के रूप में अशुभ के रूप में एक और समाधान: 82 72

#~Row~","&/@Permutations[InputString[]~StringSplit~","]~Select~OrderedQ;

Answer 13

पायथन 3.5+, 73 बाइट्स

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

l=input().split(',');print(*[l.pop(l.index(min(l)))for _ in[*l]],sep=',')

Answer 14

आर

बबल सॉर्ट: 122 118 अक्षर

a=scan(,"",sep=",");h=T;while(h){h=F;for(i in 1:(length(a)-1)){j=i+1;if(a[i]>a[j]){a[j:i]=a[i:j];h=T}}};cat(a,sep=",")

बोगोसॉर्ट: 100 अक्षर

a=scan(,"",sep=",");while(any(apply(embed(a,2),1,function(x)x[1]<x[2]))){a=sample(a)};cat(a,sep=",")

Answer 15

पर्ल, 159

perl -F"," -lape "$m=$m<length()?length():$m for@F;$_{10**(2*$m)*sprintf'0.'.'%02d'x$m,map-96+ord,split//}=$_ for@F;$_=join',',map$_{$_+0},grep exists$_{$_+0},'0'.1..'0'.10**100"

यह कभी जीतने का मौका नहीं खड़ा हुआ, लेकिन इसे साझा करने का फैसला किया क्योंकि मुझे तर्क पसंद आया भले ही यह गड़बड़ है :) इसके पीछे का विचार, प्रत्येक शब्द को पूर्णांक में बदलना है ( ऑर्डिनरी फ़ंक्शन का उपयोग करके किया गया ), हम नंबर को सहेजते हैं एक हैश और एक मान के रूप में स्ट्रिंग में एक कुंजी के रूप में, और फिर हम सभी पूर्णांकों (इस मामले में 1..10 ** 100) के माध्यम से तेजी से पुनरावृति करते हैं और इस तरह से हम अपने तारों को क्रमबद्ध करते हैं।

चेतावनी : इस कोड को अपने कंप्यूटर पर न चलाएं, क्योंकि यह पूर्णांक के खरबों + से होकर गुजरता है। यदि आप इसका परीक्षण करना चाहते हैं, तो आप ऊपरी सीमा की सीमा को कम कर सकते हैं और गैर-लंबी तारों को इनपुट कर सकते हैं। यदि किसी भी कारण से यह नियमों के विरुद्ध है, तो कृपया मुझे बताएं और मैं प्रविष्टि को हटा दूंगा!

Answer 16

जेएस: 107 चार्ट - बबल सॉर्ट

a=prompt().split(/,/);for(i=a.length;i--;)for(j=0;j<i;)a[j]>a[j+1]?[b=a[j],a[j]=a[++j],a[j]=b]:j++;alert(a)

मैंने @ tryToGetProgrammingStrect के उत्तर को देखा और इसे बेहतर बनाने की कोशिश की, लेकिन इसे थोड़ा अलग तरीके से लागू किया।

Answer 17

जावा, 134 बाइट्स

एक विधि जो सूक्ति क्रमबद्धता को लागू करती है।

void s(String[]a){int m=a.length-1,i=0;while(i<m){while(i>=0&&a[i].compareTo(a[i+1])>0){String t=a[i];a[i]=a[i+1];a[i+1]=t;i--;}i++;}}

Answer 18

स्विफ्ट, 101 बाइट्स

func s(a:[String])->[String]{return a.count<2 ? a:(s(a.filter{$0<a[0]})+[a[0]]+s(a.filter{$0>a[0]}))}

Ungolfed:

//quicksort
func sort(a:[String]) -> [String]
{
    //return the array if its length is less than or equal to 1
    if a.count <= 1
    {
        return a
    }
    //choose the first element as pivot
    let pivot = a[0]
    //retrieve all elements less than the pivot
    let left = a.filter{ $0 < pivot }
    //retrieve all elements greater than the pivot
    let right = a.filter{ $0 > pivot }
    //sort the left partition, append a new array containing the pivot,
    //append the sorted right partition
    return sort(left) + Array<String>(arrayLiteral: pivot) + sort(right)
}

Comments

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

— लैकोनी

Answer 19

S, 24 चार्ट्स / 30 बाइट्स (गैर-समरूप)

ï⇔Ĕ⍪;↻ïꝈ)ΞÿѨŗ ï,⇀$≔МƵï;Ξ

Try it here (Firefox only).

चयन प्रकार का उपयोग करना!

व्याख्या

ï⇔Ĕ⍪;↻ïꝈ)ΞÿѨŗ ï,⇀$≔МƵï;Ξ // implicit: ï=input, Ξ=[]
ï⇔Ĕ⍪;                    // split ï along commas and set it to ï
     ↻ïꝈ)                // while ï's length > 0
         Ξÿ              // push to Ξ:
           Ѩŗ ï,⇀$≔МƵï;  // removed minimum item(s) from ï using builtin
                       Ξ // get sorted array

मूल रूप से पुनरावृत्ति को हटाता है और इनपुट से दूसरे सरणी में न्यूनतम धक्का देता है।

Answer 20

सीलोन (बोगोसॉर्ट), 119

String s(String i)=>",".join([*i.split(','.equals)].permutations.select((p)=>!any{for([x,y]in p.paired)y<x})[0]else[]);

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

मैंने permutationsविधि ढूंढी और इस तरह बोगोसॉर्ट (एक गैर-यादृच्छिक संस्करण) के साथ समाप्त हुआ।

प्रारूपित और टिप्पणी की गई:

// a function `s` mapping a String `i` to a String
String s(String i) =>
    // the end result is created by joining the iterable in (...).
    ",".join(
        // take the input, split it on commas, make the result a sequence.
        [*
            i.split(','.equals)   // → {String+}
           ]                      // → [String+]
        // get the iterable of all permutations of this sequence.
        // Yes, this is an iterable of O(n!) sequences (though likely
        // lazily computed, we don't need all in memory at once).
        .permutations              // → {[String+]*}
        // filter this iterable for ordered sequences.
        // Using select instead of filter makes this
        // eager instead of lazy, so we are actually iterating
        // through all n! sequences, and storing the ordered
        // ones. (All of those are equal.)
        .select(
            // this is our function to check whether this sequence
            // is ordered in ascending order.
            (p)=>
               // return if none of the following iterable of booleans is true.
                !any {
                   // This is a for-comprehension. Inside an named argument list
                   // (what we have here, although there is no name) for a
                   // function which wants an iterable, this becomes an iterable,
                   // lazily built from the existing iterable p.paired,
                   // which is just an iterable with all pairs of subsequent
                   // elements.
                      for([x,y] in p.paired)
                        // for each such pair, we evaluate this expression, which
                        // is true when the sequence is not ordered correctly.
                           y < x         // → Boolean
                        // → {Boolean*}
                    }  //   → Boolean
                 //  → Boolean([String+])
               ) // → [[String+]*]
         // we now have a sequence of (correctly sorted) sequences.
         // just take the first one.
         // If we had used `.filter` before, this would have to be `.first`.
               [0]    // → [String+]|Null
         // in case this is null, which can only happen if the original array was
         // empty, so there were no permutations, just use the empty sequence
         //  again. (Actually, split never returns an empty array, so this can't
         //  happen, but the type checker can't know that.)
               else []    // → [String*]
    // so that is what we pass to the join method.
        )   // → String
    ;

स्वरूपण और पार्सिंग के बिना यह केवल 90 बाइट्स बन जाता है:

String[]s(String[]i)=>i.permutations.select((p)=>!any{for([x,y]in p.paired)y<x})[0]else[];

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

Answer 21

पर्ल 5 , 77 बाइट्स

map{$F[$_]gt$F[$_+1]&&(@F[$_,$_+1]=@F[$_+1,$_])for 0..@F-2}@F;$_=join',',"@F"

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

साधारण बबल सॉर्ट।

Answer 22

ruby -plaF, , 70 बाइट्स

o=[]
$F.map{|s|i=o;s.bytes{|b|i=i[b]=[*i[b]]};i[0]=s<<?,}
$_=o*''
chop

O (n), यदि आप दिखावा करते हैं कि किसी सरणी को आकार देना और संकुचित करना नि: शुल्क है (यह बहुत मुक्त नहीं है)।

हम oबाइट्स बी ₁ , बी ₂ ... बी _{एन के} साथ स्ट्रिंग ओ में स्थिति ओ [बी ₁ ] [बी ₂ ] ... [बी _एन ] के साथ एक गहरी और असमान रूप से नेस्टेड सरणी बनाते हैं। ] में । परिणाम जैसा दिखता है[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

फिर हम समतल करते हैं और इसे आउटपुट करते हैं।

Answer 23

पुनर्प्रयोग मेरे अपने जवाब पर क्रमबद्ध एक पूर्णांक सूची

टीईसी , 211 बाइट्स

set L [split [gets stdin] ,]
set i 0
time {incr j;set x 0;while \$x<$i {if \"[lindex $L $i]"<"[lindex $L $x]" {set L [lreplace [linsert $L $x [lindex $L $i]] $j $j]};incr x};incr i} [llength $L]
puts [join $L ,]

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