Das Ziel dieses Code Golf ist es, ein Programm zu erstellen, das eine Liste von Strings (in aufsteigender Reihenfolge) sortiert, ohne eine eingebaute Sortiermethode zu verwenden (wie Array.Sort()in .NET, sort()in PHP, ...). Beachten Sie, dass diese Einschränkung die Verwendung einer integrierten Methode ausschließt, die ein Array in absteigender Reihenfolge sortiert und anschließend das Array umkehrt.

Ein paar Details:

• Ihr Programm sollte zur Eingabe auffordern. Bei dieser Eingabe handelt es sich um eine Liste von Zeichenfolgen, die nur ASCII-Kleinbuchstaben enthalten a-z, die durch Kommas ohne Leerzeichen voneinander getrennt sind. Beispielsweise:

  code,sorting,hello,golf
  

• Die Ausgabe sollte die angegebene Liste von Zeichenfolgen sein, jedoch in aufsteigender Reihenfolge sortiert und ohne Leerzeichen durch Kommas getrennt. Beispielsweise:

  code,golf,hello,sorting
  

GolfScript, 26 25 Bytes

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

Einfache Implementierung von Bubble Sort.

Versuchen Sie es online in Web GolfScript .

Wie es funktioniert

","/     # 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.

Ruby 76 54 51 Zeichen

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

k (16 Zeichen)

Wahrscheinlich wird er dem Geist des Problems nicht wirklich gerecht. In k gibt es keinen eingebauten Sortieroperator . <xGibt eine Liste der Indexe der Elemente in x in sortierter Reihenfolge zurück.

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

SED, 135

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

Basierend auf meinem vorherigen Sortierungseintrag

Rubin, 99 Zeichen ( Gnomensorte )

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*?,

Dies übertrifft meine Implementierung der Blasensortierung kaum:

Ruby, 110 104 101 Zeichen ( Blasensorte )

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*?,

Dies führt list.lengthIterationen durch, da das Worst-Case-Szenario list.length - 1Iterationen erfordert und eines davon wirklich keine Rolle spielt und 2 Zeichen spart.

Nur zum Spaß eine Quicksort-Version:

Ruby, 113 Zeichen ( Quicksort )

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+/]*?,

Haskell, 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

Zumindest ist es ... irgendwie effizient.

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

Scala, 122 Bytes

Als Einzeiler (88 Bytes):

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

(Es wird eine Liste sortieren, indem es einfach tut list.permutations.fil...)

Als Programm (122 Bytes):

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

Eine längere Version, wenn Sie möchten, dass es von stdin liest.

Dadurch werden alle Permutationen der angegebenen Liste durchlaufen, bis eine sortierte Liste gefunden wird. Es ist nicht schnell, da es ungefähr 12 Sekunden dauert, um eine Liste mit 10 Elementen zu sortieren, und weit über eine Minute, um eine Liste mit 11 Elementen zu sortieren.

[Bearbeiten] Elemente müssen eindeutig sein oder <können durch ersetzt werden <=. Tut mir auch leid für Nekro.

Javascript 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)

DEMO Geige .

Ich suche nach einem Weg, um zu beseitigen b.

PHP 83 Bytes

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

Eine O (n ³ ) -Implementierung einer Auswahlsortierung. Das Óist Zeichen 211; ein etwas invertiertes Komma.

Beispielnutzung:

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

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

Python 3 (80 Zeichen)

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

Hier ist eine Variation der while-Anweisung, die gleich lang ist:

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

Mathematica 66 56

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

Einige andere Lösungen ohne das eingebaute Symbol Ordering:

Bogosort: 84 74

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

Blasensortierung: 93 83

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

Eine andere Lösung so ineffizient wie Bogosort: 82 72

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

Python 3.5+, 73 Bytes

Dies lässt sich von Steven Rumbalskis Antwort inspirieren , verwendet jedoch das Listenverständnis anstelle einer while-Schleife. Die Anzahl der Iterationen ergibt sich aus der kopierten Liste l, weshalb zusätzliche Generalisierungen zum Entpacken und Python 3.5 erforderlich sind

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

R

Bubble Sort: 122 118 Zeichen

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=",")

Bogosort: 100 Zeichen

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

Perl, 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"

Dies hatte nie eine Chance zu gewinnen, aber ich habe beschlossen, es zu teilen, weil mir die Logik gefallen hat, auch wenn es ein Chaos ist :) Die Idee dahinter ist, jedes Wort in eine ganze Zahl umzuwandeln (gemacht mit der ord- Funktion), wir speichern die Zahl als Schlüssel in einem Hash und die Zeichenkette als Wert, und dann iterieren wir zunehmend durch alle ganzen Zahlen (1..10 ** 100 in diesem Fall) und auf diese Weise bekommen wir unsere Zeichenketten sortiert.

WARNUNG : Führen Sie diesen Code nicht auf Ihrem Computer aus, da er Billionen von ganzen Zahlen durchläuft. Wenn Sie es testen möchten, können Sie die obere Bereichsgrenze senken und nicht lange Zeichenfolgen eingeben. Wenn dies aus irgendeinem Grund gegen die Regeln verstößt, lass es mich wissen und ich werde den Eintrag löschen!

JS: 107 Zeichen - Bubble Sort

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)

Ich habe mir die Antwort von @ tryingToGetProgrammingStraight angesehen und versucht, sie zu verbessern, habe sie aber letztendlich etwas anders implementiert.

Java, 134 Bytes

Eine Methode, die Gnome Sort implementiert.

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++;}}

Schnell, 101 Bytes

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)
}

𝔼𝕊𝕄𝕚𝕟, 24 Zeichen / 30 Byte (nicht konkurrenzfähig)

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

Try it here (Firefox only).

Auswahl sortieren!

Erläuterung

ï⇔Ĕ⍪;↻ïꝈ)ΞÿѨŗ ï,⇀$≔МƵï;Ξ // 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

Entfernt das Minimum rekursiv und verschiebt es von der Eingabe in ein anderes Array.

Ceylon (Bogosort), 119

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

Probieren Sie es online!

Ich fand die permutationsMethode und landete bei Bogosort (eine nicht zufällige Variante).

Formatiert und kommentiert:

// 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
    ;

Ohne das Formatieren und Parsen werden es nur 90 Bytes:

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

Probieren Sie es online!

Perl 5 , 77 Bytes

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

Probieren Sie es online!

Einfache Blasensorte.

ruby -plaF, 70 Bytes

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

O (n), wenn Sie so tun, als wäre die Größenänderung und Komprimierung eines Arrays kostenlos (es ist sehr unfrei).

Wir erzeugen ein tief und ungleichmäßig verschachteltes Array, oindem wir einen String mit den Bytes b ₁ , b ₂ ... b _n an der Position o [b ₁ ] [b ₂ ] ... [b _n ] in das Array einfügen. Das Ergebnis sieht so aus[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

Dann machen wir es flach und geben es aus.

Wiederverwenden meiner eigenen Antwort auf Sortieren einer Ganzzahlliste

Tcl , 211 Bytes

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 ,]

Probieren Sie es online!