Le but de ce Code Golf est de créer un programme qui trie une liste de chaînes (par ordre croissant), sans utiliser de méthode de tri intégrée (comme Array.Sort()en .NET, sort()en PHP, ...). Notez que cette restriction exclut l'utilisation d'une méthode intégrée qui trie un tableau en ordre décroissant, puis en inversant le tableau.

Quelques détails:

• Votre programme doit demander une entrée, et cette entrée est une liste de chaînes contenant uniquement des caractères alphabétiques en minuscules ASCII a-z, séparés par des virgules sans espaces. Par exemple:

  code,sorting,hello,golf
  

• La sortie doit être la liste donnée de chaînes, mais triée par ordre croissant, toujours séparée par des virgules sans espaces. Par exemple:

  code,golf,hello,sorting
  

GolfScript, 26 25 octets

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

Implémentation simple de Bubble Sort.

Essayez-le en ligne dans Web GolfScript .

Comment ça fonctionne

","/     # 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 caractères

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

k (16 caractères)

Ne respecte probablement pas vraiment l'esprit du problème. En k, il n'y a pas d' opérateur de tri intégré . <xrenvoie une liste d'index des éléments en x dans l'ordre trié.

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

SED, 135

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

Basé sur mon entrée de tri précédente

Ruby, 99 caractères ( type 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*?,

Cela bat à peine mon implémentation de type bulle:

Ruby, 110 104 101 caractères ( genre Bubble )

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

Cela fait des list.lengthitérations, car le pire des cas prend des list.length - 1itérations et une autre n'a pas vraiment d'importance, et enregistre 2 caractères.

Juste pour le plaisir, une version Quicksort:

Ruby, 113 caractères ( 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

Au moins, c'est ... en quelque sorte efficace.

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 octets

En une ligne (88 octets):

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

(il triera une liste en faisant simplement list.permutations.fil...)

En tant que programme (122 octets):

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

Une version plus longue si vous voulez qu'elle soit lue depuis stdin.

Cette itération sur toutes les permutations de la liste donnée jusqu'à ce qu'elle tombe sur une liste triée. Ce n'est pas rapide car il faut environ 12 secondes pour trier une liste de 10 éléments et bien plus d'une minute pour une liste de 11 éléments.

Les éléments [Modifier] doivent être uniques ou <peuvent être remplacés par <=. Aussi, désolé pour 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 violon .

je cherche un moyen d'éliminer b.

PHP 83 octets

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

Une implémentation O (n ³ ) d'un tri de sélection. C'est le Ócaractère 211; une virgule inversée.

Exemple d'utilisation:

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

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

Python 3 (80 caractères)

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

Voici une variation de l'instruction while qui est de longueur égale:

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

Mathematica 66 56

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

Quelques autres solutions sans le symbole intégré Ordering:

Bogosort: 84 74

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

Tri par bulles: 93 83

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

Une autre solution aussi inefficace que le bogosort: 82 72

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

Python 3.5+, 73 octets

Cela s'inspire de la réponse de Steven Rumbalski mais utilise la compréhension de liste au lieu d'une boucle while; le nombre d'itérations provient de la liste copiée, lc'est pourquoi cela nécessite des généralisations de décompression supplémentaires et Python 3.5

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

R

Tri des bulles: 122 118 caractères

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 caractères

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"

Cela n'a jamais eu de chance de gagner, mais j'ai décidé de la partager parce que j'aimais la logique même si c'est un bordel :) L'idée derrière, c'est de convertir chaque mot en un entier (fait en utilisant la fonction ord ), on enregistre le nombre comme clé dans un hachage et la chaîne comme valeur, puis nous itérons de plus en plus à travers tous les entiers (1..10 ** 100 dans ce cas) et de cette façon nous obtenons nos chaînes triées.

AVERTISSEMENT : n'exécutez pas ce code sur votre ordinateur, car il parcourt des trillions + d'entiers. Si vous voulez le tester, vous pouvez abaisser la limite de plage supérieure et saisir des chaînes non longues. Si, pour une raison quelconque, cela est contraire aux règles, veuillez me le faire savoir et je supprimerai l'entrée!

JS: 107 caractères - 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)

J'ai regardé la réponse de @ tryToGetProgrammingStraight et j'ai essayé de l'améliorer, mais j'ai fini par l'implémenter légèrement différemment.

Java, 134 octets

Une méthode qui implémente 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 octets

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

Non golfé:

//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 caractères / 30 octets (non compétitif)

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

Try it here (Firefox only).

Utilisation du tri par sélection!

Explication

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

Supprime et pousse de manière récursive le minimum de l'entrée vers un autre tableau.

Ceylan (Bogosort), 119

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

Essayez-le en ligne!

J'ai trouvé la permutationsméthode et je me suis donc retrouvé avec Bogosort (une variante non aléatoire).

Formaté et commenté:

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

Sans le formatage et l'analyse, il ne fait que 90 octets:

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

Essayez-le en ligne!

Perl 5 , 77 octets

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

Essayez-le en ligne!

Tri de bulles simple.

ruby -plaF, , 70 octets

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

O (n), si vous prétendez que le redimensionnement et le compactage d'un tableau sont gratuits (ce n'est vraiment pas gratuit).

Nous créons un tableau imbriqué profondément et inégalement oen plaçant une chaîne avec les octets b ₁ , b ₂ ... b _n dans le tableau à la position o [b ₁ ] [b ₂ ] ... [b _n ]. Le résultat ressemble à[,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,["a,",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, [,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, ["abc,"], ["abd,"], ["abe,"]], ["ac,"], ["ad,"]],, ["c,"]]

Ensuite, nous l'aplatissons et le sortons.

Réutiliser ma propre réponse sur Trier une liste entière

Tcl , 211 octets

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

Essayez-le en ligne!