Якщо ви сортуєте рядок, ви отримаєте щось на зразок:

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

Спробуйте в Інтернеті!

Як це працює

О, хлопче, цей виклик був майже для Джеллі.

Група атом ( Ġ) приймає масив ¹ в якості вхідних і груп індексів , які відповідають ідентичним елементів масиву. Масив індексних груп сортується з відповідними елементами у вигляді ключів, саме такий порядок нам потрібен для цього завдання.

Далі, атом zip ( Z) переміщує рядки та стовпці згенерованої (нерівної) матриці індексів. Це просто складається з читання стовпців матриці, пропускання елементів, яких немає в цьому стовпці. У результаті ми отримуємо перший індекс символу з найнижчою кодовою точкою, за ним перший індекс символу з другою найнижчою кодовою точкою, ... далі другий індекс символу з найнижчою кодовою точкою тощо.

Нарешті, атом unindex ( ị) отримує елементи вхідного масиву за всіма його індексами в створеному порядку. Результат - двовимірний масив символів, який Jelly вирівнюється перед друком.

¹ _{Jelly не має рядкового типу, просто масиви символів.}

Пітон 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)

Пояснення

Ми починаємо з перетворення нашого рядка в список за допомогою splat і зберігання цього списку у змінній 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]

Спробуйте в Інтернеті!

Діалог APL , 21 знак = 39 байт

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

t[... ] індекс t (буде визначено незабаром) з ...

 0~⍨ нулі, вилучені з

 ∊ занесений (сплющений)

 ⍉ перенесені

 (⊢⌸t)[... ;] введено клавішу * t , індексовано рядки ...

  ⍋ показники, які б сортували

  ∪ унікальні букви о

  t← t , що має значення

  ⍞ запропоновано ввести текст

СпробуйтеAPL онлайн!

*  ^{⊢⌸tстворює таблицю, де рядки (оббиті нулями прямокутної таблиці) перераховують всі унікальні індекси букв у t .}

C, 109 106 105 104 102 100 97 98 96 91 Байт

Резервне копіювання до 98 байт, необхідних для ініціалізації j, щоб зробити f (n) повторним використанням

Вниз до 96 байтів, використовуючи кладки замість strlen B-)

Дивно, що мені довелося повернутися до strlen, але я позбувся циклу for (; i ++;), тому тепер він знижується на 91 байт. Мабуть, сторінка man для ставок читає;

"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

Математика, 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сортує за канонічним порядком, а не за кодом символів.

Пітон 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>

Працює шляхом вилучення набору унікальних символів, їх сортування, видалення з початкового рядка та рекурсивного обчислення виду решти рядка. 81 байт рішення, яке мені здалося цікавим:

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

J , 16 15 байт

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

Це дієслово, яке бере і повертає один рядок. Спробуйте в Інтернеті!

Майлз врятував байт, дякую!

Пояснення

Тут нічого надто фантазійного: сортуйте в основному за порядком появи, вдруге за знаком char.

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

Математика, 55 байт, неконкурентна

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

Edit: На жаль, системи 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 байт

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

Спробуйте в Інтернеті! - БФ

Numberwang , 262 226 байт

8400000087111111442111911170004000400000071114002241202271214020914070419027114170270034427171114400000091111112711170000007000400040000007111400224120227121402091407041902711417027004219190071420091171411111170007000771111117

Спробуйте в Інтернеті! - СЗ

Я поклав їх обох сюди, оскільки вони ідентичні коду.

PHP, 83 байти

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

На жаль, ви не можете мати unsetу потрійному, тому мені потрібно використовувати прикро довго array_filter.
Використовуйте як:

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 байт

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

Спробуйте в Інтернеті

Це дуже неефективно. Тест-посилання змінює i>>7наi>>5 та встановлює межу рекурсії на 10000. Припускає, що входи мають лише значення ASCII до 126.

Використовує фокус div-mod для повторення двох циклів: мінімальне число i/128у зовнішньому циклі та значення ASCII i%128у внутрішньому циклі. Включає персонажc із заданим значенням ASCII, якщо кількість разів воно з'являється в рядку, принаймні, його мінімальна кількість.

Код використовує трюк для імітації призначення, c=chr(i%128)щоб на нього можна було посилатись у виразі (s.count(c)>i>>7)*c. Python lambdas не дозволяють призначити, оскільки вони приймають лише вирази. Перехід до аdef повну або повну програму все ще є чистою втратою.

Натомість функція висуває значення chr(i%128)на наступний рекурсивний виклик як необов'язковий вхід. Це вимкнено одним, тому iщо було збільшено, але це не має значення, поки рядок не містить спеціального символу '\x7f'(ми також могли б підняти 128 до 256). Початковий c=''нешкідливий.

V , 37 36 байт

Дякую @DJMcMayhem за байт!

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

Спробуйте в Інтернеті!

Не впевнений, що мені подобається регулярний вираз, але мені потрібно було òякось зробити перерву.

Поясніть

Í./&ò                    #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 байт

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

Я трохи здивувався, виявивши, що немає вбудованого способу групування подібних елементів у списку. Ось що робить біт кабачкової карти.

JavaScript (ES6), 77 75 байт

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

Стабільний сортує лексикографічно відсортований рядок за n- ^ою появою

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 байти

{[~] flat roundrobin |.comb.classify(~*){*}.sort»[*]}

Пояснення:

• { }: Лямбда, яка бере один аргумент - наприклад 21211.
• .comb: Розбийте аргумент введення на список символів - напр (2,1,2,1,1).
• .classify(~*): Групуйте символів, використовуючи порівняння рядків як умову групування, повертаючи не упорядкований хеш - наприклад { 2=>[2,2], 1=>[1,1,1] }.
• {*}: Повернення списку всіх значень хеша - наприклад [2,2], [1,1,1] .
• .sort: Сортування - наприклад [1,1,1], [2,2].
• »[*]: Стрійте контейнери для елементів, в які були загорнуті масиви, оскільки вони знаходяться в хеші, щоб вони не розглядалися як окремий елемент на наступному кроці - наприклад (1,1,1), (2,2).
• roundrobin |: Розміщуйте підсписи, поки всі не будуть вичерпані - наприклад (1,2), (1,2), (1).
• flat: Вирівняти результат - напр 1, 2, 1, 2, 1.
• [~]: Об’єднайте його, щоб отримати рядок знову - наприклад 12121 .

(Заслуга за roundrobinпідхід відповідає відповіді Шона .)

05AB1E , 15 байт

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

Спробуйте в Інтернеті! або як тестовий набір

Пояснення

{                # 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 з 15 байтів призначені для обходу способу 05AB1E з обробкою блискавок різної довжини.

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}