หากคุณเรียงลำดับสตริงคุณมักจะได้รับสิ่งที่ชอบ:

         ':Iaaceeefggghiiiiklllllmnnooooprrssstttttuuyyyy

_{ใช่นั่นเป็นประโยคแรกที่เรียง}

ที่คุณสามารถดูมีจำนวนมากของตัวละครซ้ำ, aa, eee, ttttt, 9 ช่องว่างและอื่น ๆ

ถ้าเราเพิ่ม128ค่า ASCII ของรายการที่ซ้ำกันครั้งแรก256ที่สอง384ที่สามและอื่น ๆ เรียงลำดับอีกครั้งและส่งออกสตริงใหม่ (โมดูลัส 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เป็น:

ท้าทาย:

ไม่แปลกใจเลยว่าความท้าทายคือการเขียนโค้ดที่เรียงสตริงตามคำอธิบายข้างต้น

คุณสามารถสันนิษฐานได้ว่าสตริงอินพุตจะมีเฉพาะอักขระ ASCII ที่พิมพ์ได้ในช่วง 32-126 (เว้นวรรคถึงตัวหนอน)

กรณีทดสอบ:

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

นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดในแต่ละภาษานับไบต์จะชนะโทษ

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ị

ลองออนไลน์!

มันทำงานอย่างไร

โอ้เด็กผู้ชายความท้าทายนี้เกิดขึ้น แต่ทำเพื่อเยลลี่

กลุ่มอะตอม ( Ġ) ใช้เวลาอาร์เรย์¹เป็น input และกลุ่มดัชนีที่สอดคล้องกับองค์ประกอบที่เหมือนกันของอาร์เรย์ อาเรย์ของกลุ่มดัชนีถูกจัดเรียงด้วยองค์ประกอบที่สอดคล้องกันเป็นคีย์ซึ่งเป็นลำดับที่เราต้องการสำหรับความท้าทายนี้อย่างแม่นยำ

จากนั้นอะตอมซิป ( Z) จะสลับแถวและคอลัมน์ของเมทริกซ์ที่สร้างขึ้น (มอมแมม) ของดัชนี สิ่งนี้ประกอบด้วยการอ่านคอลัมน์ของเมทริกซ์โดยการข้ามองค์ประกอบที่ไม่มีอยู่ในคอลัมน์นั้น เป็นผลให้เราได้รับดัชนีแรกของตัวละครที่มีจุดรหัสต่ำสุดตามด้วยดัชนีแรกของตัวละครที่มีจุดรหัสต่ำสุดที่สอง ... ตามด้วยดัชนีที่สองของตัวละครที่มีจุดรหัสต่ำสุด ฯลฯ

ในที่สุดอะตอมunindex ( ị) จะดึงองค์ประกอบของอาร์เรย์อินพุตที่ดัชนีทั้งหมดในลำดับที่สร้างขึ้น ผลลัพธ์ที่ได้คืออาร์เรย์อักขระ 2D ซึ่ง Jelly จะแบนก่อนพิมพ์

¹ _{Jelly ไม่มีประเภทสตริงเพียงแค่อาร์เรย์ของอักขระ}

Python 3, 109 105 104 103 99 93 90 88 81 79 69 ไบต์

บันทึกได้ 2 ไบต์ด้วย FlipTack

บันทึก 7 ไบต์เพราะ flornquake ตรวจพบข้อผิดพลาดที่เป็นใบ้ของฉัน

บันทึก 2 ไบต์ด้วย xnor

บันทึก 10 ไบต์ด้วยเดนนิส

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

คำอธิบาย

aเราเริ่มต้นด้วยการแปลงสตริงของเราไปยังรายการโดยใช้เครื่องหมายและการจัดเก็บรายชื่อในตัวแปร จากนั้นในขณะที่เราaไม่ได้เป็นรายการว่างเปล่าเราก็ผ่านสมาชิกที่ไม่ซ้ำกันของแต่ละคนaในการเรียงลำดับพิมพ์และลบสำเนาของตัวละครนั้นออกจากรายการ

aแต่ละพิมพ์ซ้ำจึงพิมพ์สำเนาของตัวละครแต่ละตัวในปัจจุบัน

Haskell, 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"]) ย้ายและทำให้แบนเป็นสตริงเดียวอีกครั้ง

Python 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~⍨ ศูนย์ถูกลบออกจาก

 ∊ เกณฑ์ (แบน)

 ⍉ ขนย้าย

 (⊢⌸t)[... ;] คีย์ * เสื้อแถวจัดทำดัชนีโดย ...

  ⍋ ดัชนีที่จะเรียงลำดับ

  ∪ ตัวอักษรที่ไม่ซ้ำกันของ

  t← tซึ่งมีค่าเป็น

  ⍞ ป้อนข้อความที่พร้อมท์

ลองใช้ออนไลน์!

*  ^{⊢⌸tสร้างตารางที่แถว (เบาะด้วยศูนย์สำหรับตารางสี่เหลี่ยม) รายการดัชนีแต่ละตัวอักษรที่ไม่ซ้ำกันในที}

C, 109 106 105 104 102 100 97 98 96 91 ไบต์

สำรองข้อมูลสูงสุด 98 ไบต์จำเป็นต้องเริ่มต้น j เพื่อทำให้ f (n) สามารถใช้งานได้อีกครั้ง

ลง 96 ไบต์โดยใช้ put แทน strlen B-)

มันแปลกมากที่ฉันต้องย้อนกลับไปที่สแตรนด์ แต่ฉันกำจัด for (; i ++;) loop ดังนั้นตอนนี้มันลดเหลือ 91 Bytes เห็นได้ชัดว่าหน้าคนสำหรับทำให้อ่าน;

"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

Mathematica, 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จัดเรียงตามคำสั่งแบบบัญญัติไม่ใช่ตามรหัสตัวอักษร

Python 2, 77 76 ไบต์

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

รับสตริงที่ยกมาเป็นอินพุตจาก stdin

ลองออนไลน์!

JavaScript (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>

ทำงานโดยแยกชุดอักขระที่ไม่ซ้ำกันจัดเรียงถอดออกจากสตริงเดิมและคำนวณการเรียงลำดับของส่วนที่เหลือของ recursively ซ้ำ 81 byte solution ที่ฉันสนใจ:

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

J , 16 15 ไบต์

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

นี่คือคำกริยาที่ใช้และส่งคืนหนึ่งสตริง ลองออนไลน์!

ไมล์บันทึกเป็นไบต์ขอบคุณ!

คำอธิบาย

ไม่มีอะไรแฟนซีเกินไปที่นี่: จัดเรียงตามลำดับเหตุการณ์ที่เกิดขึ้นเป็นอันดับที่สองตามค่าถ่าน

/:+/@(={:)\;"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})<>""&

แก้ไข: แต่น่าเสียดายที่ Mathematica ของsortเป็นไม่ได้โดยรหัสอักขระ แต่โดยลำดับตัวอักษรที่พิมพ์ใหญ่พิมพ์เล็กทันทีดังต่อไปนี้ (เช่น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 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}