Bir dizeyi sıralarsanız, genellikle şöyle bir şey elde edersiniz:

         ':Iaaceeefggghiiiiklllllmnnooooprrssstttttuuyyyy

_{Evet, sıralanan ilk cümleydi.}

Gördüğünüz gibi, tekrarlanan karakterlerin bir yeri vardır, aa, eee, ttttt, 9 boşluklar vb.

128İlk kopyadaki ASCII değerine 256, ikinci, 384üçüncü ve benzeri değerlere eklersek , tekrar sıralayın ve yeni dizge çıktısını alın (aynı karakterleri geri almak için modül 128):

 ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt    

_{(Tek baştaki boşluğa ve 4 sondaki boşluğa dikkat edin).}

Dize "sıralı olarak sıralanmış" dır <space>':I....uy, <space>aeg....uy, <space>egi....ty, <space>iloty, <space>lt, <space>, <space>, <space>, <space>.

İçinde rakam olan bir dize kullanırsak, bunu görselleştirmek daha kolay olabilir. Dize 111222334"kriteri" ne zaman olacak: 123412312.

Meydan okuma:

Hiç şüphe yok ki, meydan okuma yukarıdaki açıklamaya göre bir dizge sıralayan bir kod yazmaktır.

Giriş dizesinin yalnızca yazdırılabilir ASCII karakterlerini 32-126 (tilde boşluk) aralığında içereceğini varsayabilirsiniz.

Test durumları:

**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(),()()()()

Bu kod-golf'dür , bu nedenle bayt sayılan her dilde en kısa kod ^ref kazanacaktır .

Pyth, 5 bayt

s.T.g

Test odası

Çok basit: Gruplandırın ve sıralayın, dönüştürün, birleştirin.

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.

Jöle , 3 bayt

ĠZị

Çevrimiçi deneyin!

Nasıl çalışır

Ah evlat, bu meydan okuma tamamen Jelly için yapıldı.

Grup atomu ( Ġ) bir dizi alır ¹ dizinin aynı elemanlar karşılık gelen giriş ve gruplar endeksleri olarak. Dizin gruplarının dizisi, karşılık gelen öğelerle birlikte anahtarlar olarak sıralanır; bu tam da bu meydan okuma için gereken sıradır.

Daha sonra, zip atomu ( Z) oluşturulan (düzensiz) indeks matrisinin satırlarını ve sütunlarını iletir. Bu sadece matrisin sütunlarını okumaktan, o sütunda bulunmayan elemanları atlamaktan ibarettir. Sonuç olarak, en düşük kod noktasına sahip karakterin ilk dizinini, ardından en düşük ikinci kod koduna sahip karakterin ilk dizinini, ardından en düşük kod noktasına sahip karakterin ikinci dizinini vb. Alırız.

Son olarak, unindex atomu ( ị) giriş dizisinin elemanlarını oluşturulan sırayla tüm indekslerinde alır. Sonuç, Jelly, yazdırmadan önce düzleşen bir 2D karakter dizisidir.

¹ _{Jelly bir karakter dizisine sahip değildir , sadece karakter dizileridir.}

Python 3, 109 105 104 103 99 93 90 88 81 79 69 bayt

FlipTack sayesinde 2 bayt kaydedildi

7 bayt kaydedildi çünkü flornquake aptal hatamı yakaladı

Xnor sayesinde 2 bayt kaydedildi

Dennis sayesinde 10 bayt kurtarıldı

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

açıklama

Dizgimizi bir uyarıyla kullanarak bir listeye dönüştürerek ve bu listeyi değişkene kaydederek başlarız a. O zaman aboş liste olmasa da, her benzersiz üyeden geçiyoruz.a sırayla geçeriz, yazdırır ve bu karakterin bir kopyasını listeden çıkarırız.

Her yineleme yazdırır, böylece içinde bulunan her karakterin bir kopyasını yazdırır a.

Haskell, 44 bayt

import Data.List
concat.transpose.group.sort

Kullanım örneği:

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

Sıralayın, eşit karakterleri bir dizeler listesine (örneğin "aabbc"-> ["aa","bb","c"]) göre gruplayın, yeniden dönüştürün ve tek bir dizeye yassılaştırın.

Python 2,75 bayt

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

Çevrimiçi deneyin!

Dyalog APL , 21 karakter = 39 bayt

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

t[... ] index t (kısaca tanımlanacak) ile ...

 0~⍨ sıfırdan kaldırıldı

 ∊ listelenen (düzleştirilmiş)

 ⍉ aktarılmamıştır

 (⊢⌸t)[... ;] anahtarlı * t , satır indeksli ...

  ⍋ sıralayabilecek endeksler

  ∪ eşsiz harfleri

  t← değeri olan t

  ⍞ istenen metin girişi

TryAPL çevrimiçi!

*  ^{⊢⌸tSatırların (dikdörtgen bir tablo için sıfırlarla doldurulmuş) her t harfinin indeksini t olarak listeleyeceği bir tablo oluşturur .}

C, 109 106 105 104 102 100 97 98 96 91 Bayt

F (n) yeniden kullanılabilir yapmak için j'yi başlatmak için gereken 98 Bayta kadar yedek

Strlen yerine koyanlar kullanarak 96 Bayt'a kadar B-)

Strlen'a geri dönmek zorundaydım ama for (; i ++;) döngüsünden kurtuldum, bu yüzden şimdi 91 Byte'a düştü. Görünüşe göre koyar için man sayfa okur;

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

... ilk etapta çalıştığı için şanslıydım

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

test kodu ...

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("");    
}

İşte birkaç test vakası, şimdi golf oynama zamanı

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

Mathematica, 68 60 59 bayt

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

Dize kabul eder. Bir Dize çıktılar.

Karakter listesine izin verilirse (46 bayt):

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

Sürüm kullanma Sort(40 bayt):

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

Bu sürüm benim cevabım Sortolamaz çünkü burada kullanılamaz; Sortkarakter koduna göre değil, sıraya göre sıralar.

Python 2, 77 76 bayt

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

Stdin'den girdi olarak alıntı bir dize alır.

Çevrimiçi deneyin!

JavaScript (ES6), 79 bytes

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>

Works by extracting the set of unique characters, sorting it, removing them from the original string, and recursively calculating the sort of the rest of the string. 81 byte solution that I found interesting:

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

J, 16 15 bytes

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

This is a verb that takes and returns one string. Try it online!

Miles saved a byte, thanks!

Explanation

Nothing too fancy here: sort primarily by order of occurrence, secondarily by char value.

/:+/@(={:)\;"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 bytes, non-competing

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

Edit: Unfortunately, Mathematica's sort is not by character codes, but by alphabetical order, where uppercase immediatly follows lowercase (ie Hi There is sorted to { , e, e, h, H, i, r, T}).

This works using patterns:

//.{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 bytes

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

Try it online! - BF

Numberwang, 262 226 bytes

8400000087111111442111911170004000400000071114002241202271214020914070419027114170270034427171114400000091111112711170000007000400040000007111400224120227121402091407041902711417027004219190071420091171411111170007000771111117

Try it online! - NW

I put both of these here because they are identical code.

PHP, 83 bytes

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

Unfortunately you can't have unset in a ternary so I need to use the annoyingly long array_filter.
Use like:

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:"

Python 2, 70 bytes

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

Try it online

This is very inefficient. The test link changes the i>>7 to i>>5 and sets the recursion limit to 10000. Assumes the inputs only has ASCII values up to 126.

Uses the div-mod trick to iterate through two loops: minimum counts i/128 in the outer loop and ASCII values i%128 in the inner loop. Includes a character c with the given ASCII value if the number of times it appears in the string is at least its minimum count.

The code uses a trick to simulate the assignment c=chr(i%128) so that it can be referenced in the expression (s.count(c)>i>>7)*c. Python lambdas do not allow assignment because they only take expressions. Converting to a def or full program is still a net loss here.

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}