Se ordini una stringa in genere otterrai qualcosa del tipo:

         ':Iaaceeefggghiiiiklllllmnnooooprrssstttttuuyyyy

_{Sì, questa è stata la prima frase ordinata.}

Come si può vedere, ci sono un sacco di caratteri ripetuti, aa, eee, ttttt, 9 posti e così via.

Se aggiungiamo 128al valore ASCII del primo duplicato, 256al secondo, 384al terzo e così via, riordiniamo di nuovo e produciamo la nuova stringa (modulo 128 per recuperare gli stessi caratteri) otteniamo la stringa:

 ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt    

_{(Nota il singolo spazio iniziale e i 4 spazi finali).}

La stringa è "in sequenza ordinata" <space>':I....uy, <space>aeg....uy, <space>egi....ty, <space>iloty, <space>lt, <space>, <space>, <space>, <space>.

Potrebbe essere più semplice visualizzarlo se utilizziamo una stringa con cifre al suo interno. La stringa 111222334sarà quando "ordinato" essere: 123412312.

Sfida:

Non sorprende, la sfida è scrivere un codice che ordina una stringa in base alla descrizione sopra.

Si può presumere che la stringa di input conterrà solo caratteri ASCII stampabili nell'intervallo 32-126 (spazio alla tilde).

Casi test:

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

Questo è code-golf , quindi il codice più breve in ogni lingua contata in byte vincerà ^ref .

Pyth, 5 byte

s.T.g

Suite di test

Molto semplice: raggruppa e ordina, trasponi, concatena.

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.

Gelatina , 3 byte

ĠZị

Provalo online!

Come funziona

Oh ragazzo, questa sfida è stata quasi fatta per Jelly.

Il gruppo atom ( Ġ) accetta un array ¹ come input e raggruppa indici che corrispondono a elementi identici dell'array. L'array di gruppi di indici viene ordinato con gli elementi corrispondenti come chiavi, che è esattamente l'ordine richiesto per questa sfida.

Successivamente, l' atomo zip ( Z) traspone le righe e le colonne della matrice di indici (sfilacciata) generata. Ciò consiste semplicemente nella lettura delle colonne della matrice, nel saltare elementi che non sono presenti in quella colonna. Di conseguenza, otteniamo il primo indice del carattere con il punto di codice più basso, seguito dal primo indice del carattere con il secondo punto di codice più basso, ... seguito dal secondo indice del carattere con il punto di codice più basso, ecc.

Infine, unindex atom ( ị) recupera gli elementi dell'array di input in tutti i suoi indici nell'ordine generato. Il risultato è una matrice di caratteri 2D, che Jelly si appiattisce prima di stamparla.

¹ _{Jelly non ha un tipo di stringa , solo matrici di caratteri.}

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

2 byte salvati grazie a FlipTack

7 byte salvati perché il terremoto ha colto il mio stupido errore

2 byte salvati grazie a xnor

10 byte salvati grazie a Dennis

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

Spiegazione

Iniziamo convertendo la nostra stringa in un elenco usando uno splat e memorizzando tale elenco in una variabile a. Quindi, sebbene la nostra anon sia la lista vuota, esaminiamo ogni membro unico ain ordine, stampandolo e rimuovendo una copia di quel personaggio dall'elenco.

Ogni iterazione stampa quindi stampa una copia di ogni personaggio presente in a.

Haskell, 44 byte

import Data.List
concat.transpose.group.sort

Esempio di utilizzo:

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

Ordina, raggruppa caratteri uguali in un elenco di stringhe (ad es. "aabbc"-> ["aa","bb","c"]), trasponi e appiattisci in un'unica stringa, di nuovo.

Python 2 , 75 byte

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

Provalo online!

Dyalog APL , 21 caratteri = 39 byte

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

t[... ] indice t (da definire a breve) con ...

 0~⍨ zeri rimossi da

 ∊ gli arruolati (appiattiti)

 ⍉ trasposta

 (⊢⌸t)[... con ;] chiave * t , indicizzato per riga da ...

  ⍋ gli indici che sarebbero ordinati

  ∪ le lettere uniche di

  t← t , che ha il valore di

  ⍞ input di testo richiesto

ProvaAPL online!

*  ^{⊢⌸tcrea una tabella in cui le righe (riempite con zeri per una tabella rettangolare) elencano gli indici di ciascuna lettera univoca in t .}

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

Backup fino a 98 byte, necessario per inizializzare j per rendere riutilizzabile f (n)

Fino a 96 byte usando put al posto di strlen B-)

È strano che ho dovuto tornare a strlen ma mi sono liberato del ciclo for (; i ++;) quindi ora è sceso a 91 byte. Apparentemente la pagina man di put legge;

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

... Sono stato fortunato a lavorare in primo luogo

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

codice test ...

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

Ecco alcuni casi di test, ora è il momento di giocare a golf

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

Mathematica, 68 60 59 byte

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

Accetta una stringa. Emette una stringa.

Se l'elenco dei caratteri era consentito (46 byte):

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

Versione usando Sort(40 byte):

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

Questa versione non può essere la mia risposta perché Sortnon può essere utilizzata qui; Sortordina per ordine canonico, non per codice carattere.

Python 2, 77 76 byte

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

Prende una stringa tra virgolette come input da stdin.

Provalo online!

JavaScript (ES6), 79 byte

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>

Funziona estraendo il set di caratteri univoci, ordinandolo, rimuovendolo dalla stringa originale e calcolando ricorsivamente il tipo di resto della stringa. Soluzione a 81 byte che ho trovato interessante:

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

J , 16 15 byte

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

Questo è un verbo che accetta e restituisce una stringa. Provalo online!

Miles ha risparmiato un byte, grazie!

Spiegazione

Niente di troppo elegante qui: ordina principalmente per ordine di occorrenza, secondariamente per valore di carattere.

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

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

Modifica: Sfortunatamente, Mathematica nonsort è in base a codici di caratteri, ma in ordine alfabetico, in cui le lettere maiuscole seguono immediatamente le lettere minuscole (ovvero sono ordinate perHi There{ , e, e, h, H, i, r, T} ).

Questo funziona usando i modelli:

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

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

Provalo online! - BF

Numberwang , 262 226 byte

8400000087111111442111911170004000400000071114002241202271214020914070419027114170270034427171114400000091111112711170000007000400040000007111400224120227121402091407041902711417027004219190071420091171411111170007000771111117

Provalo online! - NO

Ho messo entrambi qui perché sono codici identici.

PHP, 83 byte

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

Sfortunatamente non puoi avere unsetun ternario, quindi devo usare il fastidiosamente lungo array_filter.
Usa come:

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 byte

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

Provalo online

Questo è molto inefficiente. Il link di prova cambia ili>>7 ini>>5 e imposta il limite di ricorsione su 10000. Presuppone che gli input abbiano solo valori ASCII fino a 126.

Utilizza il trucco div-mod per scorrere tra due loop: conteggi minimi i/128nel loop esterno e valori ASCII i%128nel loop interno. Include un personaggioc con il valore ASCII specificato se il numero di volte che appare nella stringa è almeno il suo conteggio minimo.

Il codice utilizza un trucco per simulare l'assegnazione in c=chr(i%128)modo che possa essere referenziata nell'espressione (s.count(c)>i>>7)*c. Python lambdanon consente l'assegnazione perché accetta solo espressioni. Conversione in adef programma completo o è ancora una perdita netta qui.

Al contrario, la funzione spinge in avanti il ​​valore chr(i%128)alla successiva chiamata ricorsiva come input opzionale. Questo è disattivato di uno perché iè stato incrementato, ma non importa fino a quando la stringa non contiene caratteri speciali '\x7f'(potremmo anche aumentare da 128 a 256). L'iniziale c=''è innocua.

V , 37 36 byte

Grazie @DJMcMayhem per il byte!

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

Provalo online!

Non sono sicuro che alla fine mi piaccia il regex, ma in òqualche modo avevo bisogno di fare la pausa.

Spiegare

Í./&ò                    #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 byte

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

Sono stato un po 'sorpreso di scoprire che non esiste un modo integrato per raggruppare elementi simili in un elenco. Questo è ciò che fa il bit della mappa di squish.

JavaScript (ES6), 77 75 byte

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

Stabile ordina la stringa lexicographically ordinati per n ^° occorrenza

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}