เป้าหมายของ Code Golf นี้คือการสร้างโปรแกรมที่เรียงลำดับรายการสตริง (ตามลำดับจากน้อยไปหามาก) โดยไม่ต้องใช้วิธีการเรียงลำดับแบบบิวด์อิน (เช่นArray.Sort()ใน. NET, sort()ใน PHP, ... ) โปรดทราบว่าข้อ จำกัด นี้ไม่รวมการใช้วิธีการในตัวที่เรียงลำดับจากมากไปน้อยแล้วกลับอาร์เรย์

รายละเอียดบางอย่าง:

• โปรแกรมของคุณควรพร้อมท์ให้ป้อนข้อมูลและอินพุตนี้เป็นรายการของสตริงที่มีเฉพาะอักขระตัวอักษรตัวพิมพ์เล็กและตัวอักษร ASCII a-zคั่นด้วยเครื่องหมายจุลภาคโดยไม่มีช่องว่าง ตัวอย่างเช่น:

  code,sorting,hello,golf
  

• เอาต์พุตควรเป็นรายการของสตริงที่กำหนด แต่เรียงตามลำดับจากน้อยไปมากยังคงคั่นด้วยเครื่องหมายจุลภาคโดยไม่มีช่องว่าง ตัวอย่างเช่น:

  code,golf,hello,sorting
  

GolfScript, 26 25 ไบต์

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

การติดตั้ง Bubble Sorts แบบตรงไปตรงมา

ลองใช้ออนไลน์ในเว็บ GolfScript

มันทำงานอย่างไร

","/     # 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 ตัวอักษร

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

k (16 ตัวอักษร)

อาจไม่ได้ขึ้นอยู่กับวิญญาณของปัญหา ใน k ไม่มีตัวดำเนินการเรียงลำดับในตัว <xส่งคืนรายการดัชนีของรายการใน x เรียงตามลำดับ

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

SED, 135

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

ขึ้นอยู่กับรายการเรียงลำดับก่อนหน้าของฉัน

Ruby, 99 ตัวอักษร ( Gnome sort )

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

นี่เพิ่งเต้นของฉันการจัดเรียงฟอง:

Ruby, 110 104 101 chars ( เรียงลำดับฟอง )

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 ตัวอักษร

เพียงเพื่อความสนุกเวอร์ชัน Quicksort:

Ruby, 113 อักขระ ( 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

อย่างน้อยมันก็เป็น…การจัดเรียงที่มีประสิทธิภาพ

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

สกาลา, 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))

เวอร์ชันที่ยาวขึ้นถ้าคุณต้องการให้อ่านจาก stdin

สิ่งนี้วนซ้ำไปตามพีชคณิตทั้งหมดของรายการที่กำหนดจนกว่ามันจะสะดุดกับรายการที่เรียงลำดับ มันไม่เร็วอย่างที่มันใช้เวลาประมาณ 12 วินาทีในการเรียงลำดับรายการ 10 องค์ประกอบและดีกว่านาทีสำหรับ 11 องค์ประกอบ

[แก้ไข]รายการจะต้องไม่ซ้ำกันหรือสามารถถูกแทนที่ด้วย< <=นอกจากนี้ขออภัยสำหรับ necro

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 ซอ

bฉันกำลังมองหาวิธีที่จะกำจัด

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

Python 3 (80 ตัวอักษร)

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

นี่คือรูปแบบของคำสั่ง while ที่มีความยาวเท่ากัน:

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

Mathematica 66 56

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

โซลูชันอื่น ๆ ที่ไม่มีสัญลักษณ์ build-in Ordering:

โบโกตา: 84 74

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

Bubble Sort: 93 83

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

อีกวิธีการหนึ่งที่ไม่มีประสิทธิภาพเท่ากับ bogosort: 82 72

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

Python 3.5+, 73 ไบต์

สิ่งนี้ใช้แรงบันดาลใจจากคำตอบของ Steven Rumbalskiแต่ใช้ list comprehension แทนที่จะวนเป็นวง จำนวนการวนซ้ำมาจากรายการที่คัดลอกlซึ่งเป็นสาเหตุที่ทำให้ต้องมีการเปิดทั่วไปเพิ่มเติมและ Python 3.5

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

R

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

Bogosort: 100 ตัวอักษร

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"

นี่ไม่เคยมีโอกาสชนะ แต่ตัดสินใจแบ่งปันเพราะฉันชอบตรรกะแม้ว่ามันจะเลอะเทอะ :) ความคิดเบื้องหลังมันคือการแปลงแต่ละคำให้เป็นจำนวนเต็ม (ทำได้โดยใช้ฟังก์ชั่นอ๊อด ) เราบันทึกหมายเลข เป็นคีย์ในแฮชและสตริงเป็นค่าจากนั้นเราวนซ้ำทั้งหมดผ่านจำนวนเต็มทั้งหมด (1..10 ** 100 ในกรณีนี้) และวิธีการที่เราได้เรียงสตริงของเรา

คำเตือน : อย่าเรียกใช้รหัสนี้ในคอมพิวเตอร์ของคุณเนื่องจากมีการวนรอบ + จำนวนเต็มล้านล้าน หากคุณต้องการทดสอบคุณสามารถลดขีด จำกัด ช่วงบนและป้อนสตริงที่ไม่ใช่ความยาวได้ หากด้วยเหตุผลใดก็ตามนี้ผิดกฎกรุณาแจ้งให้เราทราบและฉันจะลบรายการ!

JS: 107 ตัวอักษร - 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)

ฉันดูคำตอบของ @ พยายามToGetProgrammingStraightและพยายามปรับปรุงมัน

Java, 134 ไบต์

วิธีการที่ใช้การจัดเรียง Gnome

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

สวิฟท์ 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)
}

𝔼𝕊𝕄𝕚𝕟, 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

โดยทั่วไปจะลบซ้ำและผลักดันขั้นต่ำจากอินพุตไปยังอาร์เรย์อื่น

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

ลองออนไลน์!

ฉันพบpermutationsวิธีการและจบลงด้วย Bogosort (ตัวแปรที่ไม่สุ่ม)

จัดรูปแบบและแสดงความคิดเห็น:

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

ลองออนไลน์!

Perl 5 , 77 ไบต์

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

ลองออนไลน์!

เรียงฟองง่าย ๆ

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โดยการใส่สตริงด้วยไบต์ b ₁ , b ₂ ... b _nเข้าไปในอาร์เรย์ที่ตำแหน่ง o [b ₁ ] [b ₂ ] ... [b _n ] ผลลัพธ์ดูเหมือนว่า[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

จากนั้นเราแผ่แบนและเอาท์พุทมัน

ใช้คำตอบของฉันเองซ้ำในการเรียงลำดับรายการจำนวนเต็ม

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

ลองออนไลน์!