Se você classificar uma string, normalmente obterá algo como:

         ':Iaaceeefggghiiiiklllllmnnooooprrssstttttuuyyyy

_{Sim, essa foi a primeira frase classificada.}

Como você pode ver, há um monte de caracteres repetidos, aa, eee, ttttt, 9 espaços e assim por diante.

Se adicionarmos 128ao valor ASCII da primeira duplicata, 256da segunda e 384da terceira e assim por diante, classificá-la novamente e emitir a nova string (módulo 128 para recuperar os mesmos caracteres), obteremos a string:

 ':Iacefghiklmnoprstuy aegilnorstuy egilosty iloty lt    

_{(Observe o espaço à esquerda e os 4 espaços à direita).}

A string é "sequencialmente ordenados" <space>':I....uy, <space>aeg....uy, <space>egi....ty, <space>iloty, <space>lt, <space>, <space>, <space>, <space>.

Talvez seja mais fácil visualizar isso se usarmos uma string com dígitos. A corda 111222334vai quando "ordenada" ser: 123412312.

Desafio:

Para nenhuma surpresa, o desafio é escrever um código que classifique uma string de acordo com a descrição acima.

Você pode assumir que a sequência de entrada conterá apenas caracteres ASCII imprimíveis no intervalo 32-126 (espaço para til).

Casos de teste:

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

Isso é código-golfe , então o código mais curto em cada idioma contado em bytes ganhará ^ref .

Pitão, 5 bytes

s.T.g

Suíte de teste

Muito simples: agrupe e classifique, transponha, concatene.

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 bytes

ĠZị

Experimente online!

Como funciona

Oh garoto, esse desafio foi quase feito para Jelly.

O grupo atom ( Ġ) pega uma matriz ¹ como entrada e agrupa índices que correspondem a elementos idênticos da matriz. A matriz de grupos de índices é classificada com os elementos correspondentes como chaves, que é precisamente a ordem que exigimos para esse desafio.

Em seguida, o zip atom ( Z) transpõe linhas e colunas da matriz de índices gerada (irregular). Isso consiste simplesmente em ler as colunas da matriz, pulando elementos que não estão presentes nessa coluna. Como resultado, obtemos o primeiro índice do caractere com o ponto de código mais baixo, seguido pelo primeiro índice do caractere com o segundo ponto de código mais baixo,… seguido pelo segundo índice do caractere com o ponto de código mais baixo, etc.

Finalmente, o átomo não indexado ( ị) recupera os elementos da matriz de entrada em todos os seus índices na ordem gerada. O resultado é uma matriz de caracteres 2D, que a Jelly nivela antes de imprimi-la.

¹ _{Jelly não tem um tipo de string , apenas matrizes de caracteres.}

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

2 bytes salvos graças ao FlipTack

7 bytes salvos porque o flornquake pegou meu erro burro

2 bytes salvos graças ao xnor

10 bytes salvos graças a Dennis

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

Explicação

Começamos convertendo nossa string em uma lista usando um splat e armazenando essa lista em uma variável a. Então, enquanto nossa alista não estiver vazia, passamos por cada membro único aem ordem classificada, imprima-o e remova uma cópia desse caractere da lista.

Cada iteração impressa imprime uma cópia de cada caractere presente em a.

Haskell, 44 bytes

import Data.List
concat.transpose.group.sort

Exemplo de uso:

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

Classifique, agrupe caracteres iguais a uma lista de strings (por exemplo, "aabbc"-> ["aa","bb","c"]), transponha e achatar em uma única string novamente.

Python 2 , 75 bytes

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

Experimente online!

Dyalog APL , 21 caracteres = 39 bytes

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

t[... ] índice t (a ser definido em breve) com ...

 0~⍨ zeros removidos de

 ∊ o alistado (achatado)

 ⍉ transposto

 (⊢⌸t)[... ;] digitado * t , indexado por linha por ...

  ⍋ os índices que classificariam

  ∪ as letras únicas de

  t← t , que tem o valor de

  ⍞ entrada de texto solicitada

TryAPL online!

*  ^{⊢⌸tcria uma tabela onde as linhas (preenchidas com zeros para uma tabela retangular) listam os índices de cada letra única em t .}

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

Faça backup de 98 bytes, necessário para inicializar j para tornar f (n) reutilizável

Até 96 bytes usando coloca no lugar de strlen B-)

É estranho que eu tenha voltado ao strlen, mas me livrei do loop for (; i ++;), então agora reduzimos para 91 bytes. Aparentemente, a página de manual do put lê;

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

... tive sorte de estar trabalhando em primeiro lugar

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

código de teste ...

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

Aqui estão alguns casos de teste, agora é hora de resolver isso

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

Mathematica, 68 60 59 bytes

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

Aceita uma String. Produz uma String.

Se a lista de caracteres fosse permitida (46 bytes):

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

Versão usando Sort(40 bytes):

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

Esta versão não pode ser minha resposta porque Sortnão pode ser usada aqui; Sortclassifica por ordem canônica, não por código de caractere.

Python 2, 77 76 bytes

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

Utiliza uma string entre aspas como entrada de stdin.

Experimente online!

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>

Funciona extraindo o conjunto de caracteres exclusivos, classificando-o, removendo-os da string original e calculando recursivamente o tipo do restante da string. Solução de 81 bytes que achei interessante:

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

J , 16 15 bytes

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

Este é um verbo que pega e retorna uma string. Experimente online!

Miles economizou um byte, obrigado!

Explicação

Nada muito chique aqui: classifique principalmente por ordem de ocorrência, secundariamente por valor de caractere.

/:+/@(={:)\;"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, não concorrente

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

Edit: Infelizmente, o Mathematica nãosort é por códigos de caracteres, mas por ordem alfabética, onde maiúsculas seguem imediatamente em minúsculas (ou seja, são classificadas como ).Hi There{ , e, e, h, H, i, r, T}

Isso funciona usando padrões:

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

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

Experimente online! - BF

Numberwang , 262 226 bytes

8400000087111111442111911170004000400000071114002241202271214020914070419027114170270034427171114400000091111112711170000007000400040000007111400224120227121402091407041902711417027004219190071420091171411111170007000771111117

Experimente online! - NO

Coloquei os dois aqui porque são códigos idênticos.

PHP, 83 bytes

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

Infelizmente você não pode ter unsetum ternário, então eu preciso usar o tempo irritantemente longo array_filter.
Use como:

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

Experimente online

Isso é muito ineficiente. O link de teste altera i>>7para i>>5e define o limite de recursão para 10000. Supõe que as entradas tenham apenas valores ASCII até 126.

Usa o truque div-mod para iterar através de dois loops: contagem mínima i/128no loop externo e valores ASCIIi%128 no loop interno. Inclui um caractere ccom o valor ASCII especificado se o número de vezes que ele aparecer na sequência for pelo menos a sua contagem mínima.

O código usa um truque para simular a atribuição, c=chr(i%128)para que possa ser referenciada na expressão (s.count(c)>i>>7)*c. Pythonlambda s não permitem atribuição porque eles apenas recebem expressões. A conversão para um defprograma completo ainda é uma perda líquida aqui.

Em vez disso, a função envia o valor chr(i%128)para a próxima chamada recursiva como uma entrada opcional. Isso é desativado em um porque ifoi incrementado, mas não importa, desde que a sequência não contenha caracteres especiais '\x7f'(também podemos aumentar de 128 para 256). A inicial c=''é inofensiva.

V , 37 36 bytes

Obrigado @DJMcMayhem pelo byte!

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

Experimente online!

Não tenho certeza se gosto da regex no final, mas precisava fazer a òpausa de alguma forma.

Explicar

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

Fiquei um pouco surpreso ao descobrir que não há uma maneira integrada de agrupar elementos semelhantes em uma lista. É isso que o bit do mapa de squish faz.

JavaScript (ES6), 77 75 bytes

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

Stable classifica a sequência lexicograficamente classificada pela ^nª ocorrência

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»[*]}

Explicação:

• { }: Um lambda que leva um argumento - por exemplo 21211.
• .comb: Dividir o argumento de entrada em uma lista de caracteres - por exemplo (2,1,2,1,1).
• .classify(~*): Agrupe os caracteres usando a comparação de cadeias como condição de agrupamento, retornando um hash não ordenado - por exemplo { 2=>[2,2], 1=>[1,1,1] }.
• {*}: Retorna uma lista de todos os valores do Hash - por exemplo [2,2], [1,1,1].
• .sort: Classifique - por exemplo [1,1,1], [2,2].
• »[*]: Remova os contêineres de itens nos quais as matrizes foram agrupadas devido ao hash, para que não sejam consideradas como um único item na etapa a seguir - por exemplo (1,1,1), (2,2).
• roundrobin |: Zip das sub-listas até que todos estão esgotados - por exemplo (1,2), (1,2), (1).
• flat: Achatar o resultado - por exemplo 1, 2, 1, 2, 1.
• [~]: Concatene para obter uma sequência novamente - por exemplo 12121.

(O crédito pela roundrobinabordagem vai para a resposta de Sean .)

05AB1E , 15 bytes

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

Experimente online! ou como um conjunto de testes

Explicação

{                # 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 dos 15 bytes destinam-se a entender a maneira do 05AB1E de lidar com seqüências de caracteres de tamanho diferente.

FSharp, 194 190 170 140 133 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

Usar Seq em vez de Matriz economiza alguns bytes

Definindo um nome mais curto e usando outros mapas para evitar um (fun ->)bloqueio

Acontece que o F # pode mapear um caractere para um in, portanto, remover o nome abreviado de System.Text.Encoding.ASCII e adicionar outro mapa economiza 20 bytes!

Retornar um array de caracteres em vez de uma string me salva 30 bytes!

Eu não preciso mais ter certeza de que é uma string, me economiza 7 bytes

JavaScript (ES6), 114 bytes

Separado com nova linha para maior clareza, não faz parte da contagem de bytes:

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)

Uma função anônima, retorna uma sequência de caracteres. Suporta até 10 ^ 9 repetições de qualquer caractere, o que deve ser suficiente.

Retina , 24 bytes

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

Experimente online!

Ruby, 59 + 1 = 60 bytes

Adiciona um byte para o -nsinalizador. Porto da solução de dicionário @PatrickRoberts.

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