Celem tego Code Golf jest stworzenie programu, który sortuje listę ciągów znaków (w porządku rosnącym), bez korzystania z żadnej wbudowanej metody sortowania (np. Array.Sort()W .NET, sort()w PHP, ...). Zauważ, że to ograniczenie wyklucza użycie wbudowanej metody, która sortuje tablicę malejąco, a następnie odwraca tablicę.

Trochę szczegółów:

• Twój program powinien poprosić o podanie danych wejściowych, a jest to lista ciągów zawierających tylko małe litery alfabetu ASCII a-z, oddzielone przecinkami bez spacji. Na przykład:

  code,sorting,hello,golf
  

• Wynikiem powinna być podana lista ciągów znaków, ale posortowana w porządku rosnącym, wciąż oddzielona przecinkami bez spacji. Na przykład:

  code,golf,hello,sorting
  

GolfScript, 26 25 bajtów

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

Prosta implementacja Bubble Sort.

Wypróbuj online w Web GolfScript .

Jak to działa

","/     # 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 znaków

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

k (16 znaków)

Prawdopodobnie tak naprawdę nie pasuje do ducha problemu. W k nie ma wbudowanego operatora sortowania . <xzwraca listę indeksów pozycji w x w posortowanej kolejności.

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

SED, 135

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

Na podstawie mojego poprzedniego wpisu dotyczącego sortowania

Ruby, 99 znaków ( sortowanie według Gnome )

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

To ledwie pobiła moją implementację sortowania bąbelkowego:

Rubin, 110 104 101 znaków ( sortowanie w bąbelkach )

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

Robi to list.lengthiteracje, ponieważ najgorszy scenariusz wymaga list.length - 1iteracji, a jeszcze jeden naprawdę nie ma znaczenia i oszczędza 2 znaki.

Dla zabawy wersja Quicksort:

Ruby, 113 znaków ( 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

Przynajmniej jest to… trochę wydajne.

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 bajty

Jako jednowierszowy (88 bajtów):

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

(posortuje listę po prostu robiąc list.permutations.fil...)

Jako program (122 bajty):

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

Dłuższa wersja, jeśli chcesz czytać ze standardowego wejścia.

Powtarza to wszystkie permutacje z danej listy, aż natknie się na posortowaną. Nie jest to szybkie, ponieważ sortowanie listy 10 elementów zajmuje około 12 sekund, a dla 11 elementów - ponad minutę.

[Edytuj] elementy muszą być unikalne lub <można je zastąpić <=. Również przepraszam za 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)

Skrzypce DEMO .

szukam sposobu na wyeliminowanie b.

PHP 83 bajty

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

O (n = ³ ) realizacja rodzaj selekcji. Jest Óto postać 211; nieco odwrócony przecinek.

Przykładowe użycie:

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

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

Python 3 (80 znaków)

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

Oto odmiana instrukcji while o równej długości:

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

Mathematica 66 56

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

Niektóre inne rozwiązania bez wbudowanego symbolu Ordering:

Bogosort: 84 74

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

Sortowanie bąbelkowe: 93 83

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

Inne rozwiązanie równie nieefektywne jak bogosort: 82 72

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

Python 3.5+, 73 bajty

To czerpie inspirację z odpowiedzi Stevena Rumbalskiego, ale używa rozumienia listy zamiast pętli while; liczba iteracji pochodzi z skopiowanej listy, lco wymaga dodatkowych uogólnień dotyczących rozpakowywania i Pythona 3.5

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

R

Sortowanie bąbelkowe: 122 118 znaków

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 znaków

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"

To nigdy nie miało szansy na wygraną, ale postanowiłem się nim podzielić, ponieważ podobała mi się logika, nawet jeśli jest to bałagan :) Ideą tego jest przekonwertowanie każdego słowa na liczbę całkowitą (wykonaną za pomocą funkcji ord ), zapisujemy liczbę jako klucz w haszu, a łańcuch jako wartość, a następnie coraz częściej iterujemy przez wszystkie liczby całkowite (w tym przypadku 1..10 ** 100) i w ten sposób sortujemy nasze łańcuchy.

OSTRZEŻENIE : Nie uruchamiaj tego kodu na swoim komputerze, ponieważ przechodzi on przez tryliony + liczb całkowitych. Jeśli chcesz to przetestować, możesz obniżyć górną granicę zakresu i wprowadzić ciągi nie długie. Jeśli z jakiegokolwiek powodu jest to niezgodne z zasadami, daj mi znać, a ja usunę wpis!

JS: 107 znaków - Sortowanie bąbelkowe

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)

Spojrzałem na odpowiedź @ próbujeToGetProgrammingStraight i próbowałem ją poprawić, ale ostatecznie wprowadziłem ją nieco inaczej.

Java, 134 bajty

Metoda, która implementuje Gnome Sort.

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

Szybki, 101 bajtów

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

Nie golfowany:

//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 znaki / 30 bajtów (niekonkurencyjne)

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

Try it here (Firefox only).

Za pomocą sortowania wyboru!

Wyjaśnienie

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

Zasadniczo rekurencyjnie usuwa i wypycha minimum z danych wejściowych do innej tablicy.

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[]);

Wypróbuj online!

Znalazłem tę permutationsmetodę i tym samym skończyłem z Bogosortem (wariant nieprzypadkowy).

Sformatowane i skomentowane:

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

Bez formatowania i analizy staje się tylko 90 bajtami:

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

Wypróbuj online!

Perl 5 , 77 bajtów

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

Wypróbuj online!

Proste sortowanie bąbelkowe.

ruby -plaF, , 70 bajtów

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

O (n), jeśli udajesz, że zmiana rozmiaru i kompaktowanie tablicy jest darmowa (to bardzo nie jest wolne).

Tworzymy głęboko i nierównomiernie zagnieżdżoną tablicę o, umieszczając ciąg z bajtami b ₁ , b ₂ ... b _n w tablicy w pozycji o [b ₁ ] [b ₂ ] ... [b _n ]. Wynik wygląda jak[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

Następnie spłaszczamy go i wyprowadzamy.

Ponowne użycie mojej własnej odpowiedzi na liście Sortuj liczby całkowite

Tcl , 211 bajtów

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

Wypróbuj online!