Mục tiêu của Code Golf này là tạo ra một chương trình sắp xếp danh sách các chuỗi (theo thứ tự tăng dần), mà không sử dụng bất kỳ phương thức sắp xếp tích hợp nào (như Array.Sort()trong .NET, sort()trong PHP, ...). Lưu ý rằng hạn chế này loại trừ sử dụng phương thức tích hợp sắp xếp một mảng giảm dần, sau đó đảo ngược mảng.

Một số chi tiết:

• Chương trình của bạn sẽ nhắc nhở đầu vào và đầu vào này là danh sách các chuỗi chỉ chứa các ký tự chữ cái viết thường ASCII a-z, được phân tách bằng dấu phẩy không có dấu cách. Ví dụ:

  code,sorting,hello,golf
  

• Đầu ra phải là danh sách các chuỗi đã cho, nhưng được sắp xếp theo thứ tự tăng dần, vẫn được phân tách bằng dấu phẩy không có dấu cách. Ví dụ:

  code,golf,hello,sorting
  

GolfScript, 26 25 byte

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

Thực hiện Straightfoward của Bubble Sort.

Dùng thử trực tuyến trong Web GolfScript .

Làm thế nào nó hoạt động

","/     # 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 ký tự

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

k (16 ký tự)

Có lẽ không thực sự sống theo tinh thần của vấn đề. Trong k, không có toán tử sắp xếp được xây dựng . <xtrả về một danh sách các chỉ mục của các mục theo x theo thứ tự được sắp xếp.

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

SED, 135

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

Dựa trên mục sắp xếp trước đây của tôi

Ruby, 99 ký tự ( sắp xếp 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*?,

Điều này chỉ vừa đủ đánh bại việc thực hiện sắp xếp bong bóng của tôi:

Ruby, 110 104 101 ký tự ( Sắp xếp bong bóng )

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

Điều này không list.lengthlặp lại, bởi vì trường hợp xấu nhất có các list.length - 1lần lặp và một lần nữa thực sự không quan trọng, và tiết kiệm được 2 ký tự.

Chỉ để cho vui, một phiên bản Quicksort:

Ruby, 113 ký tự ( 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

Ít nhất thì đó là loại hiệu quả.

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 byte

Là một lớp lót (88 byte):

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

(nó sẽ sắp xếp một danh sách chỉ bằng cách làm list.permutations.fil...)

Là một chương trình (122 byte):

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

Một phiên bản dài hơn nếu bạn muốn nó đọc từ stdin.

Điều này lặp đi lặp lại trên tất cả các hoán vị của danh sách đã cho cho đến khi nó vấp ngã trên một danh sách được sắp xếp. Sẽ không nhanh vì phải mất khoảng 12 giây để sắp xếp danh sách 10 yếu tố và hơn một phút cho 11 yếu tố.

[Chỉnh sửa] các mục cần phải là duy nhất hoặc <có thể được thay thế bằng <=. Ngoài ra, xin lỗi cho 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 fiddle .

tôi đang tìm cách để loại bỏ b.

PHP 83 byte

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

Một triển khai O (n ³ ) của một loại lựa chọn. Các Ólà nhân vật 211; một dấu phẩy ngược.

Sử dụng mẫu:

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

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

Python 3 (80 ký tự)

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

Đây là một biến thể của câu lệnh while có độ dài bằng nhau:

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

Toán học 66 56

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

Một số giải pháp khác không có biểu tượng tích hợp Ordering:

Không có thuốc: 84 74

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

Sắp xếp bong bóng: 93 83

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

Một giải pháp khác không hiệu quả như bogosort: 82 72

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

Python 3,5+, 73 byte

Điều này lấy cảm hứng từ câu trả lời của Steven Rumbalski nhưng sử dụng khả năng hiểu danh sách thay vì vòng lặp while; số lần lặp đến từ danh sách được sao chép l, đó là lý do điều này đòi hỏi phải tổng quát hóa giải nén bổ sung và Python 3.5

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

R

Sắp xếp bong bóng: 122 118 ký tự

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 ký tự

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"

Điều này không bao giờ có cơ hội để giành chiến thắng, nhưng đã quyết định chia sẻ nó vì tôi thích logic ngay cả khi nó là một mớ hỗn độn :) Ý tưởng đằng sau nó, là chuyển đổi từng từ thành một số nguyên (thực hiện bằng cách sử dụng mệnh lệnh hàm ), chúng tôi lưu số như một khóa trong hàm băm và chuỗi là giá trị, và sau đó chúng tôi lặp lại ngày càng nhiều thông qua tất cả các số nguyên (1..10 ** 100 trong trường hợp này) và theo cách đó chúng tôi sắp xếp các chuỗi của mình.

CẢNH BÁO : Không chạy mã này trên máy tính của bạn, vì nó lặp qua hàng nghìn tỷ + số nguyên. Nếu bạn muốn kiểm tra nó, bạn có thể hạ thấp giới hạn phạm vi trên và nhập các chuỗi không dài. Nếu vì bất kỳ lý do gì điều này là trái với quy tắc, xin vui lòng cho tôi biết và tôi sẽ xóa mục!

JS: 107 ký tự - Sắp xếp bong bóng

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)

Tôi đã xem câu trả lời của @ testsToGetProgrammingSt dán và cố gắng cải thiện nó, nhưng cuối cùng lại thực hiện nó một chút khác nhau.

Java, 134 byte

Một phương thức thực hiện 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++;}}

Swift, 101 byte

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

Ung dung:

//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 ký tự / 30 byte (không cạnh tranh)

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

Try it here (Firefox only).

Sử dụng sắp xếp lựa chọn!

Giải trình

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

Về cơ bản đệ quy loại bỏ và đẩy tối thiểu từ đầu vào sang mảng khác.

Tích Lan (Bogosort), 119

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

Hãy thử trực tuyến!

Tôi đã tìm thấy permutationsphương pháp và do đó kết thúc với Bogosort (một biến thể không ngẫu nhiên).

Định dạng và nhận xét:

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

Không có định dạng và phân tích cú pháp, nó sẽ trở thành 90 byte:

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

Hãy thử trực tuyến!

Perl 5 , 77 byte

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

Hãy thử trực tuyến!

Sắp xếp bong bóng đơn giản.

ruby -plaF, , 70 byte

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

O (n), nếu bạn giả vờ rằng thay đổi kích thước và nén một mảng là miễn phí (nó rất không miễn phí).

Chúng ta tạo một mảng lồng sâu và không đồng đều obằng cách đặt một chuỗi có byte b ₁ , b ₂ ... b _n vào mảng ở vị trí o [b ₁ ] [b ₂ ] ... [b _n ]. Kết quả trông như[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

Sau đó, chúng tôi làm phẳng và đầu ra nó.

Sử dụng lại câu trả lời của riêng tôi trên Sắp xếp danh sách số nguyên

Tcl , 211 byte

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

Hãy thử trực tuyến!