このCode Golfの目標は、組み込みの並べ替え方法（Array.Sort().NET、sort()PHP など）を使用せずに、文字列のリストを（昇順で）並べ替えるプログラムを作成することです。この制限は、配列を降順で並べ替えてから逆に並べ替える組み込みメソッドの使用を除外することに注意してください。

いくつかの詳細：

• プログラムは入力を要求するはずです。この入力は、ASCII小文字のアルファベット文字のみを含む文字列のリストであり、a-zスペースなしでコンマで区切られています。例えば：

  code,sorting,hello,golf
  

• 出力は、指定された文字列のリストである必要がありますが、昇順で並べ替えられ、スペースなしでコンマ区切りのままです。例えば：

  code,golf,hello,sorting
  

GolfScript、26 25バイト

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

Bubble Sortのまっすぐな実装。

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

ルビー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ソート）

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文字（バブルソート）

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反復、もう1つは実際には問題ではなく、2文字を節約できるからです。

楽しみのために、クイックソートバージョン：

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

ハスケル、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

Scala、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))

標準入力から読み込む場合は、より長いバージョン。

これは、ソートされたリストにつまずくまで、指定されたリストのすべての順列を繰り返します。10個の要素のリストを並べ替えるのに約12秒かかり、11個の要素のリストを並べ替えるのに1分以上かかるため、高速ではありません。

[編集]アイテムは一意であるか、<で置き換えることができます<=。また、ネクロもごめんなさい。

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)

デモフィドル。

私は排除する方法を探してい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~","],","]

組み込み記号なしのその他のソリューション Ordering：

ボゴソート：84 74

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

バブルソート：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の答えからインスピレーションを得ていますが、whileループの代わりにリストの内包表記を使用しています。反復回数はコピーされたリストから取得されるlため、追加のアンパック一般化とPython 3.5が必要です。

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

R

バブルソート：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=",")

ボゴソート：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"

これは勝つチャンスがありませんでしたが、混乱であってもロジックが好きだったので共有することにしました:)その背後にあるアイデアは、各単語を整数に変換することです（ ord関数ます）、数を保存しますハッシュのキーおよび値としての文字列として、すべての整数（この場合は1..10 ** 100）を繰り返し処理し、その方法で文字列をソートします。

警告：このコードは1兆以上の整数をループするため、コンピューターで実行しないでください。テストする場合は、範囲の上限を下げて、長い文字列を入力することができます。何らかの理由でこれがルールに違反している場合はお知らせください。エントリを削除します。

JS：107文字-バブルソート

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の答えを見て、それを改善しようとしましたが、最終的には少し異なって実装しました。

Java、134バイト

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バイト

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

ゴルフをしていない：

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

基本的に、入力から最小値を再帰的に削除し、別の配列にプッシュします。

セイロン（ボゴソート）、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 ,]

オンラインでお試しください！