문자열을 정렬하면 일반적으로 다음과 같은 결과가 나타납니다.

         ':Iaaceeefggghiiiiklllllmnnooooprrssstttttuuyyyy

_{네, 첫 번째 문장이 정렬되었습니다.}

당신이 볼 수 있듯이, 반복되는 문자의 많은이 있습니다, aa, eee, ttttt, 9 개 공간 등등.

128첫 번째 복제본, 256두 번째, 384세 번째 등 의 ASCII 값에 더하면 다시 정렬하고 새 문자열 (동일한 문자를 다시 가져 오는 계수 128)을 출력하면 문자열이 나타납니다.

 ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt    

_{(단일 선행 공간과 4 개의 후행 공백에 유의하십시오).}

문자열은 "순차적으로 분류되어"있다 <space>':I....uy, <space>aeg....uy, <space>egi....ty, <space>iloty, <space>lt, <space>, <space>, <space>, <space>.

숫자가 포함 된 문자열을 사용하면이를 시각화하는 것이 더 쉬울 수 있습니다. 문자열은 111222334"분류"하면됩니다 123412312.

도전:

당연히 도전은 위의 설명에 따라 문자열을 정렬하는 코드를 작성하는 것입니다.

입력 문자열에 32-126 (공백에서 공백) 범위의 인쇄 가능한 ASCII 문자 만 포함한다고 가정 할 수 있습니다.

테스트 사례 :

**Test cases:**
 *:Tacest*es*s*

If you sort a string you'll typically get something like:
 ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt    

Hello, World!
 !,HWdelorlol

#MATLAB, 114 bytes
 #,14ABLMTbesty 1A

f=@(s)[mod(sort(cell2mat(cellfun(@(c)c+128*(0:nnz(c)-1),mat2cell(sort(s),1,histc(s,unique(s))),'un',0))),128),''];
'()*+,-0128:;=@[]acdefhilmnoqrstuz'(),0128@acefilmnorstu'(),12celmnostu'(),12celnstu(),clnst(),cls(),cs(),()()()()

이것은 code-golf 이므로 바이트 단위 로 계산 된 각 언어 에서 가장 짧은 코드는 ^ref이 됩니다.

Pyth, 5 바이트

s.T.g

테스트 스위트

매우 간단합니다 : 그룹화 및 분류, 전치, 연결.

s.T.g
s.T.gkQ    Implicit variables
   .gkQ    Group the input input lists of elements whose values match when the
           identity function is applied, sorted by the output value.
 .T        Transpose, skipping empty values. This puts all first characters into
           a list, then all second, etc.
s          Concatenate.

젤리 , 3 바이트

ĠZị

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

작동 원리

오 소년,이 도전은 젤리를위한 것이 었습니다.

그룹 원자는 ( Ġ) 배열 얻어 ¹ 어레이의 동일한 요소에 대응하는 입력 그룹을 지표로서. 인덱스 그룹의 배열은 해당 요소를 키로 정렬하여 정확하게이 문제에 필요한 순서입니다.

다음으로, Zip 아톰 ( Z)은 생성 된 (정지 된) 인덱스 매트릭스의 행과 열을 바꿉니다. 이것은 단순히 행렬의 열을 읽고 해당 열에없는 요소를 건너 뛰는 것으로 구성됩니다. 결과적으로 코드 포인트가 가장 낮은 문자의 첫 번째 인덱스, 코드 포인트가 가장 낮은 두 번째 문자의…, 코드 포인트가 가장 낮은 문자의 두 번째 인덱스 등이 나타납니다.

마지막으로 unindex atom ( ị)은 생성 된 순서대로 모든 색인에서 입력 배열의 요소를 검색합니다. 결과적으로 2D 문자 배열이 생성되어 젤리가 인쇄하기 전에 평평하게됩니다.

¹ _{Jelly에는 문자열 유형 이 없으며 문자 배열 만 있습니다.}

파이썬 3 109 105 104 103 99 93 90 88 81 79 69 바이트

FlipTack 덕분에 2 바이트 절약

flornquake가 바보 오류를 발견하여 7 바이트가 저장되었습니다.

xnor 덕분에 2 바이트 절약

Dennis 덕분에 10 바이트 절약

a=[*input()]
while a:
    for c in sorted({*a}):print(end=c);a.remove(c)

설명

먼저 splat을 사용하여 문자열을 목록으로 변환하고 해당 목록을 변수에 저장합니다 a. 그런 다음 우리 a가 빈 목록이 아닌 동안 우리 는 각각의 고유 한 구성원을 a정렬 된 순서대로 살펴보고 인쇄하고 목록에서 해당 문자의 사본을 제거합니다.

따라서 각 반복 인쇄는에있는 각 문자의 사본 하나를 인쇄합니다 a.

하스켈, 44 바이트

import Data.List
concat.transpose.group.sort

사용 예 :

Prelude Data.List> concat.transpose.group.sort $ "If you sort a string you'll typically get something like:"
" ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt    "

같은 문자를 문자열 목록 (예 : "aabbc"-> ["aa","bb","c"])으로 정렬하고 그룹화 하고 단일 문자열로 다시 편 평화합니다.

파이썬 2 , 75 바이트

lambda s:`zip(*sorted((s[:i].count(c),c)for i,c in enumerate(s)))[1]`[2::5]

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

Dyalog APL , 21 자 = 39 바이트

t[0~⍨∊⍉(⊢⌸t)[⍋∪t←⍞;]]

t[... 다음과 함께 ] 색인 t (곧 정의)

 0~⍨ 에서 제거 된 0

 ∊ 입대 (편 평화)

 ⍉ 전치

 (⊢⌸t)[... ;] 키순 * t , 행 인덱스 ...

  ⍋ 정렬 할 인덱스

  ∪ 의 독특한 편지

  t← t 의 값을 갖는

  ⍞ 프롬프트 텍스트 입력

TryAPL 온라인!

*  ^{⊢⌸t행 (직사각형 테이블의 경우 0으로 채워짐)이 각 고유 문자의 인덱스를 t 로 나열하는 테이블을 만듭니다 .}

C, 109 106 105 104 102 100 97 98 96 91 바이트

f (n)을 재사용 할 수 있도록 j를 초기화하는 데 필요한 최대 98 바이트

strlen B-) 대신 풋을 사용하여 최저 96 바이트

내가 strlen하기 위해 되돌아가는 것이 이상하지만 for (; i ++;) 루프를 제거하여 91 바이트로 줄었습니다. 분명히 풋 페이지는 읽습니다.

"RETURNS
   If successful, the result is a nonnegative integer; otherwise, the result is `EOF'."

... 처음부터 일하는 것이 운이 좋았습니다.

char*c,i,j;f(m){for(j=strlen(m);j;++i)for(c=m;*c;c++)if(*c==i){*c=7,putchar(i),j--;break;}}

테스트 코드 ...

main(c,v)char**v;
{
    char test[] = "If you sort a string you'll typically get something like: ";
    char test2[] = "Hello, World!";

    f(test);puts("");    
    f(test2);puts("");    
}

다음은 몇 가지 테스트 사례입니다. 이제 골프를 밟을 차례입니다.

C:\eng\golf>a.exe
 ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt
 !,HWdelorlo

매스 매 티카, 68 60 59 바이트

Split[Characters@#~SortBy~ToCharacterCode]~Flatten~{2}<>""&

문자열을 받아들입니다. 문자열을 출력합니다.

문자 목록이 허용 된 경우 (46 바이트) :

Split[#~SortBy~ToCharacterCode]~Flatten~{2,1}&

Sort(40 바이트)를 사용하는 버전 :

Split@Sort@Characters@#~Flatten~{2}<>""&

이 버전은 Sort여기서 사용할 수 없기 때문에 내 대답이 될 수 없습니다. Sort문자 코드가 아닌 정식 순서로 정렬합니다.

파이썬 2, 77 76 바이트

d={}
def f(c):d[c]=r=d.get(c,c),;return r
print`sorted(input(),key=f)`[2::5]

stdin에서 인용 된 문자열을 입력으로받습니다.

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

자바 스크립트 (ES6), 79 바이트

f=s=>s&&(a=[...new Set(s)]).sort().join``+f(a.reduce((s,e)=>s.replace(e,``),s))

<input oninput=o.textContent=f(this.value)><pre id=o>

고유 한 문자 집합을 추출하고, 정렬하고, 원래 문자열에서 제거하고, 나머지 문자열의 정렬을 재귀 적으로 계산하여 작동합니다. 내가 찾은 81 바이트 솔루션 :

f=s=>s&&(s=[...s].sort().join``).replace(r=/(.)(\1*)/g,"$1")+f(s.replace(r,"$2"))

J , 16 15 바이트

/:+/@(={:)\;"0]

하나의 문자열을 가져 와서 반환하는 동사입니다. 온라인으로 사용해보십시오!

마일은 1 바이트를 절약했습니다. 감사합니다!

설명

여기서 너무 멋진 것은 없습니다 : 주로 발생 순서에 따라, 두 번째로 char 값으로 정렬하십시오.

/:+/@(={:)\;"0]  Input is y.
          \      Map over prefixes:
  +/              Sum
    @(   )        of
      =           bit-array of equality
       {:         with last element.
                 This gives an array of integers whose i'th element is k
                 if index i is the k'th occurrence of y[i].
           ;     Pair this array
            "0   element-wise
              ]  with y
/:               and sort y using it as key.

Mathematica, 55 바이트, 비경쟁

(Sort@Characters@#//.{a___,b_,b_,c___}:>{a,b,c,b})<>""&

편집 : 불행하게도, 매스 매 티카의가 sort있다 하지 문자 코드에 의해하지만, 대문자가 immediatly 소문자를 다음 알파벳 순서에 의해 (즉 Hi There에 정렬됩니다 { , e, e, h, H, i, r, T}).

이것은 패턴을 사용하여 작동합니다.

//.{a___,b_,b_,c___}:>{a,b,c,b}
    a___       c___              (Three _) a zero or more members, named a and c
         b_,b_                   exactly one member, repeated twice (since they have the same name)
                    :>           Delayed Rule (replace left hand side with right hand side.)
                                 Delayed Rule evaluate on each substitution, avoiding conflicts with predefined variables
                      {a,b,c,b}  put one of the b-named member after all other sequences
//.                              repeat until no change (aka Replace Repeated)

Brainf * CK , 458 226 바이트

,[>>>>>>,]<<<<<<[[-<<<+<<<]>>>[>>>[>>>>>>]<<<[>>--[<->--]<-<[>->+<[>]>[<+>-]<<[<]>-]>>.[[-]<]<<<[[>>>>>>+<<<<<<-]<<<]>>>>>>]>>>[>>>[>>>>>>]<<<[>>--[<->--]<-<[>->+<[>]>[<+>-]<<[<]>-]>>[-<+<+>>]<[->>+<<]<[<<<<<<]>>>]>>>]]<<<<<<]

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

Numberwang , 262 226 바이트

8400000087111111442111911170004000400000071114002241202271214020914070419027114170270034427171114400000091111112711170000007000400040000007111400224120227121402091407041902711417027004219190071420091171411111170007000771111117

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

둘 다 동일한 코드이기 때문에 두 가지를 모두 여기에 넣었습니다.

PHP, 83 바이트

for($s=count_chars($argv[1]);$s=array_filter($s);$c%=128)echo$s[++$c]--?chr($c):'';

불행히도 당신은 unset삼항식을 가질 수 없으므로 성가신 긴을 사용해야합니다 array_filter.
다음과 같이 사용하십시오.

php -r "for($s=count_chars($argv[1]);$s=array_filter($s);$c%=128)echo$s[++$c]--?chr($c):'';" "If you sort a string you'll typically get something like:"

파이썬 2, 70 바이트

f=lambda s,i=0,c='':s[i>>7:]and(s.count(c)>i>>7)*c+f(s,i+1,chr(i%128))

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

이것은 매우 비효율적입니다. 테스트 링크는 변경 i>>7에를i>>5 10000의 재귀 한도에만 최대 126 ASCII 값을 갖는 입력을 가정 설정한다.

div-mod 트릭을 사용 i/128하여 외부 루프의 최소 개수 와 i%128내부 루프의 ASCII 값의 두 루프를 반복 합니다. c문자열에 나타나는 횟수가 최소 개수 이상인 경우 지정된 ASCII 값을 가진 문자 를 포함합니다 .

코드는 트릭을 사용하여 대입을 시뮬레이션 c=chr(i%128)하여 식에서 참조 할 수 있도록합니다 (s.count(c)>i>>7)*c. 파이썬 lambda은 표현식 만 가져 오기 때문에 할당을 허용하지 않습니다. 로 변환def여기서 전체 또는 전체 프로그램으로 것은 여전히 ​​순 손실입니다.

Instead, the function pushes forward the value chr(i%128) to the next recursive call as an optional input. This is off by one because i has been incremented, but doesn't matter as long as the string doesn't contain special character '\x7f' (we could also raise 128 to 256). The initial c='' is harmless.

V, 37 36 bytes

Thanks @DJMcMayhem for the byte!

Í./&ò
dd:sor
Íî
òͨ.©¨±«©±À!¨.«©/±³²

Try it online!

Not sure I like the regex at the end, but I needed to make the ò break somehow.

Explain

Í./&ò                    #All chars on their own line
dd:sor                   #Delete empty line, sort chars
Íî                       #Join all lines together s/\n//
òͨ.©¨±«©±À!¨.«©/±³² #until breaking s/\v(.)(\1+)\1@!(.+)/\3\2\1

Perl 6, 68 bytes

{my \a=.comb.sort;[~] flat roundrobin |a.squish.map({grep *eq$_,a})}

I was a little surprised to find that there's no built-in way to group like elements in a list. That's what the squish-map bit does.

JavaScript (ES6), 77 75 bytes

s=>(a=[],x={},[...s].sort().map(c=>a[x[c]=n=-~x[c]]=(a[n]||'')+c),a).join``

Stable sorts the lexicographically sorted string by n^th occurence

F=s=>(a=[],x={},[...s].sort().map(c=>a[x[c]=n=-~x[c]]=(a[n]||'')+c),a).join``

const update = () => {
  console.clear();
  console.log(F(input.value));
};
input.oninput = update;
update();

#input {
  width: 100%;
  box-sizing: border-box;
}

<input id="input" type="text" value="         ':Iaaceeefggghiiiiklllllmnnooooprrssstttttuuyyyy" length=99/>
<div id="output"></div>

Perl 6, 54 bytes

{[~] flat roundrobin |.comb.classify(~*){*}.sort»[*]}

Explanation:

• { }: A lambda that takes one argument -- e.g. 21211.
• .comb: Split the input argument into a list of characters -- e.g. (2,1,2,1,1).
• .classify(~*): Group the characters using string comparison as the grouping condition, returning an unordered Hash -- e.g. { 2=>[2,2], 1=>[1,1,1] }.
• {*}: Return a list of all values of the Hash -- e.g. [2,2], [1,1,1].
• .sort: Sort it -- e.g. [1,1,1], [2,2].
• »[*]: Strip the item containers the arrays were wrapped in due to being in the hash, so that they won't be considered as a single item in the following step -- e.g. (1,1,1), (2,2).
• roundrobin |: Zip the sub-lists until all are exhausted -- e.g. (1,2), (1,2), (1).
• flat: Flatten the result -- e.g. 1, 2, 1, 2, 1.
• [~]: Concatenate it to get a string again -- e.g. 12121.

(Credit for the roundrobin approach goes to Sean's answer.)

05AB1E, 15 bytes

{.¡"ä"©¹g׫øJ®K

Try it online! or as a Test suite

Explanation

{                # sort input
 .¡              # group by equal elements
   "ä"©          # push "ä" and store a copy in the register
       ¹g×       # repeat the "ä" input-nr times
          «      # concatenate the result to each string in the grouped input
           ø     # zip
            J    # join to string
             ®K  # remove all instances of "ä" in the string

10 of the 15 bytes are for getting around 05AB1E's way of handling zipping strings of different length.

FSharp, 194 190 170 140 133 bytes

let f=Seq.map
let(@)=(>>)
f int@Seq.groupBy id@f(snd@Seq.mapi((*)128@(+)))@Seq.concat@Seq.sort@f((%)@(|>)128@byte)@Array.ofSeq@f char

Using Seq instead of Array saves a couple of bytes

Defining a shorter name, and using another maps to avoid a (fun ->) block

It turns out F# can map a char to an in, so removing the shortened name of System.Text.Encoding.ASCII, and adding in another map saves me 20 bytes!

Returning a char array instead of a string, saves me 30 bytes!

I no longer need to make sure it's a string, saves me 7 bytes

JavaScript (ES6), 114 bytes

Separated with newline for clarity, not part of byte count:

s=>[...s].map(a=>(m[a]=-~m[a])*128+a.charCodeAt(),m={})
.sort((a,b)=>a-b).map(a=>String.fromCharCode(a%128)).join``

Demo

`**Test cases:**
 *:Tacest*es*s*

If you sort a string you'll typically get something like:
 ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt    

Hello, World!
 !,HWdelorlol

#MATLAB, 114 bytes
 #,14ABLMTbesty 1A

f=@(s)[mod(sort(cell2mat(cellfun(@(c)c+128*(0:nnz(c)-1),mat2cell(sort(s),1,histc(s,unique(s))),'un',0))),128),''];
'()*+,-0128:;=@[]acdefhilmnoqrstuz'(),0128@acefilmnorstu'(),12celmnostu'(),12celnstu(),clnst(),cls(),cs(),()()()()`.split`\n\n`.map(s=>(p=s.split`\n`,console.log(`${p[0]}\n\n${r=f(p[0])}\n\nmatch: ${r==p[1]}`)),
f=s=>[...s].map(a=>(m[a]=-~m[a])*128+a.charCodeAt(),m={}).sort((a,b)=>a-b).map(a=>String.fromCharCode(a%128)).join``)

Clojure, 79 bytes

#(for[V[(group-by(fn[s]s)%)]i(range 1e9)k(sort(keys V))c[(get(V k)i)]:when c]c)

An anonymous function, returns a sequence of characters. Supports up-to 10^9 repetitions of any characters, which should be plenty.

Retina, 24 bytes

O`.
O$#`(.)(?=(\1)*)
$#2

Try it online!

Ruby, 59+1 = 60 bytes

Adds one byte for the -n flag. Port of @PatrickRoberts' dictionary solution.

d={};print *$_.chars.sort_by{|c|d[c]||=0;c.ord+128*d[c]+=1}