Bu Code Golf'ün amacı, herhangi bir yerleşik sıralama yöntemi (örneğin Array.Sort().NET, sort()PHP, ... gibi) kullanmadan dizelerin listesini (artan sırada) sıralayan bir program oluşturmaktır . Bu kısıtlamanın, bir dizi azalan ve ardından diziyi tersine çeviren yerleşik bir yöntem kullanmanın dışında olduğunu unutmayın.

Bazı detaylar:

• Programınız girdi istemelidir ve bu girdi, a-zboşluk olmadan virgülle ayrılmış, yalnızca ASCII küçük harfli alfabetik karakterleri içeren dizelerin listesidir . Örneğin:

  code,sorting,hello,golf
  

• Çıktı verilen dize listesi olmalıdır, ancak artan sırada sıralanmış, boşluk olmadan virgülle ayrılmış olmalıdır. Örneğin:

  code,golf,hello,sorting
  

GolfScript, 26 25 bayt

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

Bubble Sort'un düz ekran uygulaması.

Web GolfScript'te çevrimiçi deneyin .

Nasıl çalışır

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

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

k (16 karakter)

Muhtemelen sorunun ruhuna uygun bir şekilde yaşamıyor. K'de, yerleşik sıralama operatörü yoktur. <xx cinsinden öğelerin endekslerini sıralanmış düzende döndürür.

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

SED, 135

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

Önceki sıralama girişime dayanarak

Ruby, 99 karakter ( Gnome sıralaması )

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

Bu benim kabarcık sıralama uygulaması zar zor yener:

Yakut, 110 104 101 karakter ( Kabarcık sıralama )

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

Bu list.lengthyinelemeler yapar , çünkü en kötü senaryo list.length - 1yinelemeleri alır ve bir tanesi daha önemli değildir ve 2 karakter kaydeder.

Sadece eğlence için bir Quicksort versiyonu:

Yakut, 113 karakter ( 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

En azından… bir çeşit etkilidir.

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 bayt

Tek astar olarak (88 bayt):

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

(listeyi sadece yaparak sıralar list.permutations.fil...)

Bir program olarak (122 bayt):

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

Stdin'den okumak istiyorsanız daha uzun bir versiyon.

Bu, sıralı listeye rastlayana kadar verilen listenin tüm permütasyonlarını tekrarlar. 10 element listesini sıralamak yaklaşık 12 saniye ve 11 element için bir dakikadan fazla sürmesi hızlı değildir.

[Düzenle] öğelerin benzersiz olması veya <bununla değiştirilebilir <=. Ayrıca, necro için özür dilerim.

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 keman .

ortadan kaldırmak için bir yol arıyorum b.

PHP 83 bayt

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

Bir seçim türünün O (n ³ ) uygulaması. ÓKarakteri 211 olduğu; biraz ters virgül.

Örnek kullanım:

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

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

Python 3 (80 karakter)

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

Eşit uzunluktaki while ifadesinin bir varyasyonu:

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

Mathematica 66 56

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

Yerleşik sembolü olmayan diğer bazı çözümler Ordering:

Bogosort: 84 74

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

Kabarcık Sırala: 93 83

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

Bogosort kadar verimsiz başka bir çözüm: 82 72

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

Python 3.5+, 73 bayt

Bu Steven Rumbalski'nin cevabından ilham alıyor ancak bir süre döngüsü yerine liste kavrayışı kullanıyor; yineleme sayısı kopyalanan listeden gelir, lbu da bunun ek açma genellemeleri ve Python 3.5 gerektirir

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

R,

Kabarcık Sıralaması: 122118 karakter

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 karakter

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"

Bu asla kazanma şansı olmadı, ama paylaşmaya karar verdim çünkü bir karışıklık olsa bile mantığı sevdim :) Arkasındaki fikir, her kelimeyi bir tam sayıya dönüştürmek ( ord işlevi ), sayıyı kaydediyoruz bir karma ve dize değer olarak bir anahtar olarak, ve sonra giderek artan bir şekilde tüm tamsayılar (bu durumda 1..10 ** 100) ve yineleyerek dizelerimizi sıraladık.

UYARI : Trilyonlarca + tamsayıdan geçtiği için bu kodu bilgisayarınızda çalıştırmayın. Test etmek isterseniz, üst aralık sınırını düşürebilir ve uzun olmayan dizeler girebilirsiniz. Herhangi bir nedenle bu kurallara aykırı ise, lütfen bana bildirin, girişi silerim!

JS: 107 karakter - Kabarcık Sırala

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)

@ TryingToGetProgrammingStraight'ın cevabına baktım ve onu geliştirmeye çalıştım, ancak biraz farklı bir şekilde uyguladım.

Java, 134 bayt

Gnome Sort uygulayan bir yöntem.

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

Swift, 101 bayt

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 karakter / 30 bayt (rekabetçi değil)

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

Try it here (Firefox only).

Seçim sıralama kullanarak!

açıklama

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

Temel olarak özyinelemeyi kaldırır ve minimum değeri girişten başka bir diziye iter.

Seylan (Bogosort), 119

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

Çevrimiçi deneyin!

permutationsYöntemi buldum ve böylece Bogosort (rastgele olmayan bir varyant) ile sona erdi.

Biçimlendirilmiş ve yorumlanmış:

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

Biçimlendirme ve ayrıştırma olmadan sadece 90 bayt olur:

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

Çevrimiçi deneyin!

Perl 5 , 77 bayt

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

Çevrimiçi deneyin!

Basit kabarcık sıralama.

ruby -plaF, , 70 bayt

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

O (n), bir diziyi yeniden boyutlandırmanın ve sıkıştırmanın ücretsiz olduğunu iddia ederseniz (çok ücretsiz değildir).

B [, ₁ ] [b ₂ ] ... [b _n ] konumundaki diziye ob ₁ , b ₂ ... b _n baytlarını içeren bir dize koyarak derin ve düzensiz yuvalanmış bir dizi oluştururuz . Sonuç şuna benziyor[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

Sonra düzleştirip çıktısını alıyoruz.

Yeniden kullanma Kendi cevabı üzerine sırala bir tamsayı listesi

Tcl , 211 bayt

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

Çevrimiçi deneyin!