एक स्ट्रिंग को क्रमबद्ध करें, की तरह

Question

यदि आप एक तार को छाँटते हैं तो आपको आमतौर पर कुछ मिलेगा:

         ':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:।

चुनौती:

कोई आश्चर्य की बात नहीं है, चुनौती एक कोड लिखना है जो उपरोक्त विवरण के अनुसार एक स्ट्रिंग को सॉर्ट करता है।

आप यह मान सकते हैं कि इनपुट स्ट्रिंग में 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(),()()()()

---

यह कोड-गोल्फ है , इसलिए बाइट्स में गिने जाने वाली प्रत्येक भाषा में सबसे छोटा कोड ^{रेफरी} जीत जाएगा ।

Comments

शीर्षक थोड़ा भ्रामक है, जिसके परिणामस्वरूप मैं यह सोच रहा हूं और वर्णन को अनदेखा कर रहा हूं : tio.run/nexus/05ab1e#@1@td2jh4ZVe//… अच्छी चुनौती अन्यथा, मैं संक्षेप में बताए गए विस्तार पर काम करूंगा।

— मैजिक ऑक्टोपस Urn

क्या हम एक स्ट्रिंग के बजाय वर्णों की सूची का उत्पादन कर सकते हैं?

— गेहूं जादूगर

यदि आप एक स्ट्रिंग इनपुट कर सकते हैं, तो आउटपुट एक स्ट्रिंग भी होना चाहिए। यदि वर्णों की एक सूची आपकी भाषा में इनपुट और आउटपुट स्ट्रिंग्स के सामान्य तरीके हैं तो यह ठीक है। आप उदाहरण के लिए {'S', 'g', 'i', 'n', 'r', 't'}पायथन में आउटपुट नहीं कर सकते हैं , क्योंकि यह "सामान्य" तरीका है "String"।

— स्टीवी ग्रिफिन

मैं ऊपर अपनी टिप्पणी सही करूंगा: एक स्ट्रिंग पात्रों की एक सूची है , इसलिए पात्रों की एक सूची को आउटपुट स्वीकार किया जाता है। हालांकि, स्ट्रिंग्स की एक सूची स्वीकार नहीं की जाती है। इसका मतलब है, अगर आपकी सूची में एक तत्व में दूसरा चरित्र जोड़ना संभव है तो इसे स्वीकार नहीं किया जाता है। एक उदाहरण के रूप में: {'a','b'}मतलाब में स्वीकार नहीं किया जाता है क्योंकि आप इस तरह के प्रत्येक चरित्र में एक चरित्र जोड़ सकते हैं {'aa','b'}:। आपका इनपुट और आउटपुट एक ही प्रारूप पर होना चाहिए।

— स्टीवी ग्रिफिन

@StewieGriffin जब आप कहते हैं कि ऊपर वर्णित विवरण के अनुसार हल किया गया है। क्या आपको लगता है कि मेरे सॉर्ट एल्गोरिथ्म को ASCII मानों को संशोधित करने की प्रक्रिया का पालन करना चाहिए या इसे केवल उस एल्गोरिदम के समान आउटपुट का उत्पादन करना होगा?

— जॉर्ज रीथ

Answer 1

अजगर, 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.

Comments

Pyth के पास नया J बनने के लिए सब कुछ है, यह भयानक है

— shabunc

@shabunc यदि आप नया J देखना चाहते हैं, तो github.com/DennisMitchell/jelly को देखें

— isaacg

Answer 2

जेली , 3 बाइट्स

ĠZị

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ओह लड़के, यह चुनौती सभी के लिए थी, लेकिन जेली के लिए बनाई गई थी।

समूह परमाणु ( Ġ) एक सरणी लेता है ¹ इनपुट और समूहों के सूचकांक कि सरणी के समान तत्वों के अनुरूप के रूप में। सूचकांक समूहों की सारणी को कुंजी के रूप में संबंधित तत्वों के साथ क्रमबद्ध किया गया है, जो कि इस चुनौती के लिए आवश्यक आदेश है।

अगला, ज़िप परमाणु (Z ) सूचकांकों के उत्पन्न (रैग्ड) मैट्रिक्स की पंक्तियों और स्तंभों को स्थानांतरित करता है। इसमें बस मैट्रिक्स के कॉलम को पढ़ना होता है, उस कॉलम में मौजूद तत्वों को स्किप न करना। परिणामस्वरूप, हमें सबसे कम कोड बिंदु वाले चरित्र का पहला सूचकांक प्राप्त होता है, इसके बाद चरित्र का पहला सूचकांक दूसरे निम्नतम कोड बिंदु के साथ होता है, ... इसके बाद सबसे कम कोड बिंदु वाले चरित्र का दूसरा सूचकांक होता है, आदि।

अंत में, एकतरफा परमाणु ( ị) उत्पन्न क्रम में अपने सभी सूचकांकों में इनपुट सरणी के तत्वों को पुनः प्राप्त करता है। परिणाम एक 2 डी चरित्र सरणी है, जिसे जेली इसे मुद्रित करने से पहले समतल करती है।

---

¹ _{जेली में एक स्ट्रिंग प्रकार नहीं है , बस वर्णों की सरणियाँ हैं।}

Comments

"ओह बॉय, यह चुनौती जेली के लिए ही बनी थी।" -> 3 बाइट उत्तर

— geisterfurz007

जैसा कि मैंने कहा, लगभग जेली के लिए बनाया गया है। :)

— डेनिस

Answer 3

पायथन 3, 109 105 104 103 99 93 90 88 81 79 69 बाइट्स

2 बाइट्स FlipTack की बदौलत बच गईं

7 बाइट्स बच गए क्योंकि फ्लॉर्नकेक ने मेरी गूंगा त्रुटि पकड़ी

2 बाइट्स xnor के लिए धन्यवाद बचा लिया

10 बाइट्स ने डेनिस को धन्यवाद दिया

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

व्याख्या

हम एक स्ट्रिंग का उपयोग करके अपनी स्ट्रिंग को सूची में परिवर्तित करके शुरू करते हैं और उस सूची को एक चर में संग्रहीत करते हैं a। तब जबकि हमारी aखाली सूची नहीं है, हम प्रत्येक अद्वितीय सदस्य के माध्यम से जाते हैंa क्रमबद्ध क्रम में , इसे प्रिंट करें और सूची से उस चरित्र की एक प्रति निकालें।

प्रत्येक पुनरावृत्ति प्रिंट इस प्रकार उपस्थित प्रत्येक वर्ण की एक प्रति प्रिंट करता है a।

Comments

@StewieGriffin setएक अनसुलझा सेट है।

— 22

@StewieGriffin मुद्रित होने पर वे छांटे जाते हैं, लेकिन उनके ASCII मूल्यों द्वारा नहीं। ऐसा अक्सर प्रतीत होता है कि वे हैं, लेकिन मेरा मानना ​​है कि वे किसी प्रकार के हैश के आधार पर छांटे गए हैं।

— गेहूं जादूगर

आप fकुछ बाइट्स को बचाने के लिए एक सूची के बजाय एक स्ट्रिंग बना सकते हैं ।

— 3

यदि आप लेते हैं a=list(input()), तो आप कर सकते हैं a.remove(c), जो एक शुद्ध बचत है।

— xnor

पायथन 3 में जाने से बाइट्स में बहुत बचत होगी। tio.run/nexus/…

— डेनिस

Answer 4

हास्केल, 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"]), फिर से एक स्ट्रिंग में स्थानांतरित करें और समतल करें।

Answer 5

पायथन 2 , 75 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

पता नहीं कि यह मान्य है लेकिन lambda s:`[sorted((1e9+s[:i].count(c),c)for i,c in enumerate(s))]`[18::21]अधिकतम लंबाई के साथ तार के लिए काम करता है 9e9।

— xnor

@xnor आप दो बाइट्स को बचाने के लिए []और बदल सकते हैं । 1817lambda s:`sorted((1e9+s[:i].count(c),c)for i,c in enumerate(s))`[17::21]

— गेहूं जादूगर

@xnor बहुत कम से कम, यह एक वैध 32-बिट पायथन गोल्फ होना चाहिए। मैंने इससे छुटकारा पाने की कोशिश की zip, लेकिन मुझे नहीं लगता कि जोड़ना 1e9मेरे लिए कभी हुआ होगा ... धन्यवाद!

— डेनिस

@HeatWizard अच्छी नज़र। धन्यवाद!

— डेनिस

यदि स्ट्रिंग में बैकस्लैश है तो यह विफल हो जाता है।

— लिन

Answer 6

Dyalog APL , 21 वर्ण = 39 बाइट्स

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

t[... ] इंडेक्स टी (शीघ्र ही परिभाषित होने के साथ) ...

 0~⍨ शून्य हटा दिया गया

 ∊ सूचीबद्ध (चपटा)

 ⍉ स्थानांतरित

 (⊢⌸t)[... ;] बंद * टी , पंक्ति द्वारा अनुक्रमित ...

  ⍋ सूचकांकों जो सॉर्ट करेंगे

  ∪ के अद्वितीय पत्र

  t← t , जिसका मान है

  ⍞ पाठ इनपुट से संकेत दिया

TryAPL ऑनलाइन!

---

*  ^{⊢⌸tएक तालिका बनाता है जहाँ पंक्तियाँ (आयताकार तालिका के लिए शून्य के साथ गद्देदार) टी में प्रत्येक अद्वितीय अक्षरों के सूचकांकों को सूचीबद्ध करती हैं ।}

Comments

कौन से ग्लिफ़ अधिक महंगे हैं?

— ren

@wptreanor ⌸एक बाइट प्रति चार के बजाय UTF-8 होने का कारण बनता है।

— आदम

Answer 7

सी, 109 106 105 104 102 100 97 98 96 91 बाइट्स

98 बाइट्स तक वापस, f (n) को पुन: प्रयोज्य बनाने के लिए j को इनिशियलाइज़ करने की आवश्यकता है

स्ट्रेल B- के स्थान पर पुट का उपयोग करके नीचे 96 बाइट्स तक)

यह अजीब है कि मुझे वापस स्ट्रेल करना पड़ा, लेकिन मुझे इसके लिए छुटकारा मिल गया ((; 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

Comments

पहले परीक्षण मामले में अनुगामी रिक्त स्थान छोड़ दिए गए हैं?

— स्टिव ग्रिफिन

मेरे पास पहले परीक्षण मामले में तीन अनुगामी स्थान हैं ... ऐसा इसलिए है क्योंकि मैंने इनपुट स्ट्रिंग पर अनुगामी स्थान को शामिल नहीं किया ;-)

— क्लेब्लांक

Answer 8

मैथेमेटिका, 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वर्ण क्रम से नहीं, विहित आदेश द्वारा सॉर्ट करें।

Comments

मुझे पता नहीं है कि यह गणित ठीक है, पर यह ठीक हो सकता है, लेकिन क्या आपने यह टिप्पणी पढ़ी है ?

— स्टीवी ग्रिफिन

@StewieGriffin वेल्ड, नोप। मैं इसे ठीक कर सकता हूं, लेकिन क्या यह उन भाषाओं को अनुचित लाभ नहीं देता जिनके पास स्ट्रिंग बनाम चार [] अंतर नहीं है? संबंधित मेटा चर्चा

— जंगहवान मिन

अच्छी बात। मैंने एक सुधार किया, मूल के नीचे टिप्पणी देखें। मेला? मुझे यकीन नहीं है कि यह आपके उत्तर को वैध बनाता है या नहीं।

— स्टीवी ग्रिफिन

@StewieGriffin Mathematica में वर्णों और तारों के बीच अंतर नहीं है। यहां तक ​​कि Charactersकमांड तकनीकी रूप से लंबाई -1 स्ट्रिंग्स की सूची का उत्पादन करता है।

— जुंगहवान मिन

@StewieGriffin मुझे लगता है कि यह भी प्रासंगिक है । मुझे लगता है कि किसी भी उचित प्रारूप में इनपुट की अनुमति देना बेहतर है, यह एक स्ट्रिंग, लंबाई 1 स्ट्रिंग्स की सूची, वर्णों की सरणी, बाइट्स की सरणी आदि हो

— ngenisis

Answer 9

पायथन 2, 77 76 बाइट्स

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

स्टड से इनपुट के रूप में एक उद्धृत स्ट्रिंग लेता है।

इसे ऑनलाइन आज़माएं!

Comments

मुझे लगता है कि इसकी अनुमति नहीं है क्योंकि कार्यों को फिर से प्रयोग करने योग्य होना चाहिए । आप इसे एक कार्यक्रम बना सकते हैं।

— xnor

मैं वास्तव में इस विधि को पसंद करता हूं, जो एक फ़ंक्शन के साथ सॉर्ट करता है जो म्यूट करता है। टुपल्स का घोंसला भी चालाक है।

— xnor

@xnor धन्यवाद, निश्चित।

— flornquake

Answer 10

जावास्क्रिप्ट (ईएस 6), 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"))

Answer 11

जे , 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.

Comments

मुझे लगता है कि आप कोष्ठकों के बाहर एक बाइट ले जाने के योग को बचा सकते हैं `+ / @ (= {:) :)

— मील

@ मीलों ओह हाँ, क्योंकि एक ट्रेन में अनंत रैंक है। अच्छा धन्यवाद!

— जर्बर्ब

Answer 12

गणितज्ञ, 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)

Comments

One minor thing: Rule (->) should be RuleDelayed (:>) (no change in byte count) because both sides of Rule has variables. Rule can cause conflicts with pre-existing definitions. For instance: a=3;5/.{a_->a} returns 3, not 5. (a_->a evaluates to a_->3 -- if you use a_:>a, it stays that way and a=3;5/.{a_:>a} returns 5).

— JungHwan Min

I marked your answer non-competing because it does not do what the question specifies (sort by character code, not in canonical order).

— JungHwan Min

@JungHwanMin fixed to RuleDelayed. thanks.

— spacemit

Answer 13

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.

Answer 14

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

Answer 15

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.

Answer 16

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

Comments

Íî (or :%s/\n//g) is shorter than VGgJ

— DJMcMayhem

Answer 17

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.

Comments

I get "This Seq has already been iterated" unless I rename a to @a (+2 bytes). Also, grep *eq$_, can be written grep $_, (-3 bytes) since a string is a valid smart-matcher.

— smls

{[~] flat roundrobin |.comb.classify(~*){*}.sort»[*]} -- This variation is only 54 bytes.

— smls

@smis I don't see that error. Maybe we're using different versions? I'm on rakudo-star-2016.10. Anyway, your solution puts mine to shame, you should post it as a separate answer.

— Sean

I'm using a bleeding-edge Rakudo compiled from the main branch of the git repo this week. Anyway, I posted the classify-based solution as a separate answer now.

— smls

Answer 18

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>

Comments

1+~~ is the same as -~.

— Neil

@Neil Awesome thanks -2 bytes

— George Reith

Answer 19

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.)

Answer 20

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.

Answer 21

FSharp, 194 190 170 140 133 bytes

let f=Seq.map
let(@)=(>>)
f [e-mail] id@f([e-mail]((*)128@(+)))@[e-mail]@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

Answer 22

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``)

Comments

The same bytecount as my Matlab code, and the exact same approach. Haven't attempted to golf mine yet though. I'll probably upvote later if you add an explanation :-) (I've made a principle out of not upvoting answers without explanations, even when I understand it) :-)

— Stewie Griffin

Answer 23

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.

Answer 24

Retina, 24 bytes

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

Try it online!

Answer 25

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}