이 코드 골프의 목표는 내장 정렬 방법 (예 : Array.Sort().NET, sort()PHP 등 ) 을 사용하지 않고 문자열 목록을 오름차순으로 정렬하는 프로그램을 만드는 것 입니다. 이 제한 사항은 배열을 내림차순으로 정렬 한 다음 배열을 뒤집는 내장 방법을 사용하지 않습니다.

일부 세부 사항 :

• 프로그램은 입력을 요구해야하며이 입력은 a-z공백없이 쉼표로 구분 된 ASCII 소문자 알파벳 문자 만 포함하는 문자열 목록입니다 . 예를 들면 다음과 같습니다.

  code,sorting,hello,golf
  

• 출력은 주어진 문자열 목록이어야하지만 오름차순으로 정렬되며 여전히 공백없이 쉼표로 구분됩니다. 예를 들면 다음과 같습니다.

  code,golf,hello,sorting
  

GolfScript, 26 25 바이트

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

Bubble Sort의 간단한 구현.

웹 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에는 내장 정렬 연산자 가 없습니다 . <xx의 항목 색인 목록을 정렬 된 순서로 반환합니다.

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

SED, 135

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

이전 정렬 항목을 기반으로

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

이것은 거품 정렬 구현을 거의 능가하지 않습니다.

루비 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

스칼라, 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 개의 요소 목록에 대해 1 분이 걸리므로 빠르지 않습니다.

[편집] 항목은 고유해야하거나 <으로 대체 할 수 있습니다 <=. 또한, 네크로에게 죄송합니다.

자바 스크립트 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

파이썬 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},","]

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=',')

아르 자형

버블 정렬 : (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=",")

펄, 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)

@tryingToGetProgrammingStraight의 답변을보고 개선하려고했지만 약간 다르게 구현했습니다.

자바, 134 바이트

그놈 정렬을 구현하는 메소드입니다.

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

기본적으로 입력에서 다른 배열로 최소값을 반복적으로 제거하고 푸시합니다.

실론 (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[];

온라인으로 사용해보십시오!

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

온라인으로 사용해보십시오!