Метою цього Code Golf є створення програми, яка сортує список рядків (у порядку зростання), не використовуючи вбудованого методу сортування (наприклад, Array.Sort()у .NET, sort()у PHP, ...). Зауважте, що це обмеження виключає використання вбудованого методу, який сортує масив у спаді та реверсує масив.

Деякі деталі:

• Ваша програма повинна запросити введення, і цей вхід - це список рядків, що містять лише алфавітні символи ASCII з малі літери a-z, розділені комами без пробілів. Наприклад:

  code,sorting,hello,golf
  

• Вихід повинен бути заданим списком рядків, але відсортованим у порядку зростання, все ще розділеним комами без пробілів. Наприклад:

  code,golf,hello,sorting
  

GolfScript, 26 25 байт

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

Безпосередня реалізація сортування бульбашок.

Спробуйте його в Інтернеті у веб-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]

СЕД, 135

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

На основі мого попереднього запису про сортування

Рубін, 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*?,

Це ледве б'є мою реалізацію сортування бульбашок:

Рубі, 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ітерації, і ще один насправді не має значення, і зберігається 2 символи.

Просто для розваги, версія Quicksort:

Рубі, 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))

Більш довга версія, якщо ви хочете, щоб вона читалася з stdin.

Це повторюється над усіма перестановками даного списку, поки він не натрапить на відсортований. Це не швидко, оскільки для сортування списку з 10 елементів потрібно близько 12 секунд і більше 11 хвилин.

[Редагувати] елементи повинні бути унікальними або <їх можна замінити <=. Також вибачте за некроз.

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

О (п ³ ) здійснення вибору виду. ÓЦе характер 211; трохи перевернута кома.

Використання зразка:

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

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

Пітон 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)

Математика 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},","]

Ще одне неефективне рішення, як Богоссорт: 82 72

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

Python 3.5+, 73 байти

Це вимагає натхнення з відповіді Стівена Румбальського, але використовує розуміння списку замість циклу часу; кількість ітерацій надходить із скопійованого списку 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) і таким чином ми сортуємо наші рядки.

ПОПЕРЕДЖЕННЯ . Не запускайте цей код на своєму комп’ютері, оскільки він проходить через трильйони + цілих чисел. Якщо ви хочете перевірити його, ви можете знизити верхню межу діапазону та ввести недовгі рядки. Якщо з будь-якої причини це суперечить правилам, будь ласка, повідомте мене, і я видалю запис!

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)

Я переглянув відповідь @ tryToGetProgrammingStraight і спробував її покращити, але в кінцевому підсумку реалізував її дещо інакше.

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]}))}

Безголівки:

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

Спробуйте в Інтернеті!