Создать пароль

26

Очень трудно запомнить мой пароль, поэтому я нашел способ сгенерировать пароль.

Я генерирую свой пароль из слова или предложения, выполнив следующие действия:

  1. Начните слева направо

  2. Найти количество каждой буквы

  3. Положите письмо с его счетом в порядке

    • Письма с более высоким повторением будут в конце

    • Письма с одинаковым повторением будут упорядочены в алфавитном порядке

  4. Числа и специальные буквы будут игнорироваться, включая пробелы (например, 9, 4, @, (, * и т. Д. Игнорируются)

  5. Групповые буквы игнорируют регистр. В выходных данных используйте регистр последнего вхождения во входных данных.

  6. Количество букв может быть любым числом, например, 5H17M345K
  7. Если на входе указаны все цифры или специальные буквы, то на выходе будет пустая строка, например, «12 $ * 34 ^!» затем выведите ""
  8. когда порядок для того же самого случая в алфавитном порядке не имеет значения, например, 1a1B1c

Пример:

Input: Kitkat Tango
(2k / 1i / 3T / 2a / 1n / 1g / 1o)
Output: 1g1i1n1o2a2k3T

Другой пример:

Input: Database Partitions Task
(1D / 5a / 4T / 1b / 3s / 1e / 1P / 1r / 2i / 1o / 1n / 3s / 1k)
Output: 1b1D1e1k1n1o1P1r2i3s4T5a

Примечание: буквы с 1 повторением в начале располагаются в алфавитном порядке, затем буквы с большим количеством повторений

Это , выигрывает самый короткий код.

asmgx
источник
16
Может ли письмо появляться более 9 раз?
лохматый
3
@manatwork: Но это неясно (обратите внимание, их ответ не предполагал, что буквы появляются менее 10 раз), он просто пытается ослабить ограничения на ввод.
მოიმო
4
Обязательно добавьте эти пояснения в фактическое тело вопроса, чтобы ответчикам не приходилось искать комментарии
Джо Кинг,
2
Комментарии не делают спецификацию. Вам нужно обновить задачу, чтобы 1.добавить как минимум 1 контрольный пример, включающий более 9 вхождений одной или нескольких букв, 2.указать, что вывод должен быть строкой (хотя я настоятельно рекомендую не быть таким строгим; он ничего не добавляет к задаче ), 3.укажите, что мы должны обрабатывать вводы, не содержащие букв, и уточните, 4.нужно ли обрабатывать пустую строку в качестве ввода.
лохматый
1
После того, как вы это сделаете, вам нужно будет протестировать все существующие решения и сообщить им, нужно ли им вносить какие-либо изменения. Я уже нашел целый ряд решений, которые терпят неудачу на данный момент 1. Кроме того, в будущем вы можете рассмотреть возможность использования нашей Песочницы, чтобы попытаться устранить подобные проблемы, прежде чем отправлять вызов.
лохматый

Ответы:

7

Japt v2.0a0 -P, 14 байт

f\l üv ñÊ®ÌiZÊ

Попытайся

f\l üv ñÊ®ÌiZÊ     :Implicit input of string
                   > e.g., "Kitkat Tango"

f                  :Split to an array of characters
 \l                :  Matching RegEx /[a-z]/gi
                   > ["K","i","t","k","a","t","T","a","n","g","o"]

    ü              :Sort & group (Preserves original order within each group)
     v             :  By lowercase
                   > [["a","a"],["g"],["i"],["K","k"],["n"],["o"],["t","t","T"]]

       ñ           :Sort
        Ê          :  By length
                   > [["g"],["i"],["n"],["o"],["a","a"],["K","k"],["t","t","T"]]

         ®         :Map each Z
          Ì        :  Last element of Z
                   >   ["g","i","n","o","a","k","T"]
           i       :  Prepend
            ZÊ     :    Length of Z
                   >   ["1g","1i","1n","1o","2a","2k","3T"]

                   :Implicitly join & output
                   > "1g1i1n1o2a2k3T"
мохнатый
источник
10

05AB1E , 19 17 16 байтов

Сохранено 1 байт благодаря Кевину Круйссену

áΣl}.γl}éεgyθJ}J

Попробуйте онлайн! или как тестовый набор

объяснение

á                  # keep only letters in input
 Σl}               # sort by lower-case
    .γl}           # group by lower-case
        é          # sort by length (stable)
         ε    }    # map each to
          g        # its length
             J     # joined with
           yθ      # the last letter
               J   # join to string
Emigna
источник
Вы можете сохранить байт, изменив (пару с) на «(concat / merge), так что один из двух Js (объединений) может быть удален.
Кевин Круйссен
@KevinCruijssen: Вау. Теперь я чувствую себя глупо :) Почему я просто не пошевелился J? Изменить: На самом деле, мне нужно было их как пара в 19-байтовой версии, и я не думал менять ее, когда я сделал 17: P
Emigna
В Jзависимости от ответа на этот вопрос,
Shaggy
7

Perl 6 , 66 63 байта

{[~] map {+$_~.tail},sort {+$_,.lc},m:g/<:L>/.classify(&lc){*}}

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

объяснение

{                                                             }  # Anon block
                                    m:g/<:L>/  # Match all letters
                                             .classify(&lc)  # Group by lowercase
                                                           {*}  # Get hash values
                     sort {+$_,.lc},  # Sort by array length and lowercase
     map {         },  # Map to
          +$_~.tail  # Concat array length and last letter
 [~]  # Join
nwellnhof
источник
6

Сетчатка , 67 66 41 39 байт

\P{L}

O$`.
$l$0
ir`\1*(.)
$.0$1
N`\d+.

-25 байт и небольшое исправление ошибки благодаря @Neil .
-2 байта благодаря @Neil и @Shaggy вместе.

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

Удалите все, кроме заглавных и строчных букв:
т.е. Kitkat Tango 123!KitkatTango

\P{L}

Сортировать отдельные буквы без учета регистра ( спасибо @MartinEnder за это ):
т.е. KitkatTangoaagiKknottT

O$`.
$l$0

Захват каждый кусок не чувствительны к регистру повторяется соседние буквы:
т.е. aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

PREPEND длину каждого матча, и только держать последнюю букву каждого фрагмента:
то есть [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Сортировать цифры и буквенные группы по номерам:
2a1g1i2k1n1o3T1g1i1n1o2a2k3T

N`\d+.

После чего результат выводится неявно.

Кевин Круйссен
источник
Вы уверены, что это ошибка? Разве это не просто лексикографическая сортировка? ( "aA" < "aa")
Лохматый
1
@ Шэгги Я не уверен, что может. Потому что \wи .в O`\w.использовались, чтобы указать, что мы сортируем пары символов. Не уверен, сможем ли мы отсортировать каждую пару символов, но сортируем только по первому символу. Но, ну, хорошо, предложение Мартина отсортировать каждый символ на основе замещения (который является строчным вариантом совпадения) работает как шарм. :)
Кевин Круйссен
1
Это можно сделать в 41 байт или я что-то упустил?
Нил
2
@ Shaggy На самом деле чтение дальше, \P{L}может работать, что экономит 2 байта.
Нил
4

Wolfram Language (Mathematica) , 102 96 93 87 байт

""<>Map@ToString/@Sort[(r=Reverse)/@Tally[r@#/." "->Nothing,Equal@@ToLowerCase@{##}&]]&

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

Tally[r@#/." "->Nothing,Equal@@ToLowerCase@{##}&]      Start with a char list
        #/." "->Nothing                                Remove spaces
      r@                                               Reverse the result
Tally[                 ,Equal@@ToLowerCase@{##}&]
                                             Make a list of letters and multiplicities,
                                             where two letters are considered the same if
                                             their lowercase values are equal. Then:

""<>Map@ToString/@Sort[(r=Reverse)/@ ... ]&
                       (r=Reverse)           Reverse each {letter, freq} to {freq,letter}.
                                             Then the standard Wolfram order function sorts
                                               lower frequencies first, with ties broken by
                                               by letters earlier in the alphabet,
                  Sort[                  ]     exactly what we want.

    Map@ToString/@                           @ has higher precedence than /@, so
                                               this effectively does Map[Map[ToString]].
""<>                                         StringJoin the nested list into a single string.
lirtosiast
источник
4

Pyth, 27 24 22 байта

ssrD0m,lded.gr0k@+Gr1G

Попробуйте это онлайн здесь .

ssrD0m,lded.gr0k@+Gr1GQ   Implicit: Q=eval(input()), G=lowercase alphabet
                          Trailing Q inferred
                   r1G    Uppercase alphabet
                 +G       Concatenate with lowercase alphabet
                @     Q   Keep those characters in Q which are also in the above
           .g             Group the remaining characters, as k, using:
             r0k             Convert k to lowercase
                              (Grouping preserves relative order)
     m                    Map the sorted groups, as d, using:
       ld                   Length of d
      ,                     Pair the above with...
         ed                 ... last element of d
   D                      Sort the above...
  r 0                     ... by their lowercase values
ss                        Flatten, then concatenate the result of the above into a string, implicit print

Редактировать: Гольф 3 байта, упорядочив по символам перед группой, предыдущая версия: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Редактировать 2: Отыграть еще 2 байта, отформатировав вывод перед любым заказом, предыдущая версия: sm+ldedlD.gr0krD0f}r0TGQ

Редактировать 3: Отключить еще один байт, изменив фильтр, благодаря @FryAmTheEggman. Также пришлось исправить ошибку, когда OP уточнил, что одна буква может появляться более 9 раз, что снова добавляло байт: o (Предыдущая версия:srD0m+lded.gr0kf}r0TGQ

Sok
источник
@FryAmTheEggman отличный звонок, спасибо!
Сок
4

APL (Dyalog Extended) , 28 байтов SBCS

Функция анонимного молчаливого префикса.

(∊⍤∧⌊(⊂⍕⍤≢,⊢/)⍤⊢⌸⊢)'\PL'R''

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

'\PL' не-буквы
⎕R PCRE R заменены на
''  пустыми строками

(...)  Применить следующую молчаливую функцию:

 со строчными буквами в качестве клавиш
 …  примените нижеприведенную молчаливую функцию к каждой клавише и соответствующему набору значений, а именно
 к аргументу

  () Применить следующую молчаливую функцию
   к
    списку значений:

   ⊢/ последнее значение

   … , Добавьте к этому следующее:

     stringification
     из
     подсчета

    заключить (обрабатывать список символов как одну строку)

ε NLIST (Flatten)  сортируются по возрастанию-версия , что

Адам
источник
1
@ Shaggy Спасибо. Исправлено в +1 байт.
Адам
3

Perl 5, 74 68 66 байт

-6 байт изменения -pв -nи используя sayвместо $_=join"", -2 байт благодаря Абигайль , используя \pLвместо[a-z]

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{$a-$b||lc$a cmp lc$b}values%h

TIO

59 байт, если не более 9 символов каждого символа

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{lc$a cmp lc$b}values%h
Науэль Фуйе
источник
@ Abigail, спасибо, во второй программе это был промах после обновления
Науэль Фуйе
3

Python 2 , 116 байт

def f(s):a=s.lower();return''.join(`n`+s[a.rfind(c)] for n,c in sorted((a.count(c),c)for c in set(a)if c.isalpha()))

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

TFeld
источник
Выход для Database Partitions Taskне равен1b1D1e1k1n1o1P1r2i3s4T5a
mdahmoune
@mdahmoune спасибо, должно быть исправлено.
TFeld
In the output, use the case of the last occurrence in the inputвам нужно rfindвместо findэтого. ...] forможет стать, ...]forчтобы компенсировать это, хотя.
АрБо
3

Haskell , 114/113 105 байт

-9 байт благодаря Лайкони (используя список-понимание и (||)вместо того , чтобы filterс elem& сократить , lengthчтобы избавиться от уродливой zip)!

f s=id=<<[show(h r)++[last r]|l<-[1..h s],a<-['A'..'Z'],r<-[[x|x<-s,x==a||x==[a..]!!32]],h r==l]
h=length

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

ბიმო
источник
107 байт: попробуйте онлайн!
Лайкони
1
105: Попробуйте онлайн!
Лайкони
@Laikoni: сейчас короче чем с импортом, очень приятно !!
მოიმო
3

Красный , 220 196 206 байт

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]trim/all form sort/skip collect[foreach c sort
unique reverse rejoin parse s[collect[any[keep[a]| skip]]][i: 0
foreach d s[if(c% 32)=(d% 32)[i: i + 1]]keep i keep c]]2]

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

Спасибо Shaggy за то, что нашли ошибку.

Гален Иванов
источник
1
@ Shaggy Спасибо за указание на это, я постараюсь это исправить.
Гален Иванов
2

Желе , 15 байт

fØẠµŒlĠLÞịµL,Ṫ)

Полная программа, печатающая пароль, как указано (как монадическая ссылка, она выдает список списков, каждый из которых содержит целое число и символ).

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

Джонатан Аллан
источник
2

шелуха , 15 байт

Нет проблем с импортом при использовании Husk, поэтому мы можем использовать различные удобные функции, такие как groupOn , sortOnи toLowerт.д:

ṁ§:osL→ÖLSġÖ_f√

Попробуйте онлайн или попробуйте все!

объяснение

ṁ§:(sL)→ÖLSġÖ_f√  -- example input: "Kitkat Tango"
              f√  -- `filter isAlpha`: "KitkatTango"
          S  _    -- apply _ to .. then ..
            Ö     -- | sortOn: `sortOn toLower`
           ġ      -- | groupOn: `groupOn toLower`
                  -- .. compose: `groupOn toLower . sortOn toLower`
                  -- `sortOn toLower` (stable): "aagiKknottT"
                  -- `groupOn toLower`: ["aa","g","i","Kk","n","o","ttT"]
        ÖL        -- `sortOn length` (stable): ["g","i","n","o","aa","Kk","ttT"]
ṁ                 -- map and flatten (`concatMap`)
 §                -- | fork argument ..
       →          -- | | `last`: ['g','i','n','o','a','k','T']
   (sL)           -- | | `show . length`: ["1","1","1","1","2","2","3"]
  :               -- | .. and `snoc`: ["1g","1i","1n","1o","2a","2k","3T"]
                  -- : "1g1i1n1o2a2k3T"
ბიმო
источник
2

JavaScript (Node.js) , 127 байт

s=>[...s].sort(o=(x,y)=>p(0+x,36)-p(0+y,36),p=parseInt).join``.match(/([a-z])\1*/ig).map(x=>(l=x.length)+x[l-1]).sort(o).join``

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

  • parseInt(numberAsString, radix)попытается проанализировать целое число в начале строки. Например, parseInt('120px', 10)выдаст 120. При сбое синтаксического анализа возвращаетсяNaN . Мы подключаем'0' к началу каждого символа, чтобы он вернулся0 для любых не цифр-букв. По этому алгоритму мы можем сортировать одинаковые буквы вместе и не-буквенный символ в начале.
  • После того, как sortи join, "Hello world!123"стало бы" !123deHllloorw" . Сопоставление с /([a-z])\1*/igигнорирует любой не-альфа-символ и разбивает строку на куски с одинаковыми буквами. `.
  • map конвертировать "aaa" в"3a" соответствии с требованиями в вопросе.
  • Второй вид использует ту же функцию, что и первый. Благодаря системе счисления, "3b"будет меньше, чем"12a" в базе 36, как мы и ожидаем: сначала сравнивается число (n div 36 ), а потом сравнивается буква (n mod 36 ).
  • Наконец-то joinих вместе.

JavaScript (Node.js) , 146 байт

f=(s,...a)=>(s=s.replace(/[^a-z]/ig,''))?f(s.replace(RegExp(s[c=0],'ig'),x=>(l=++c+x,'')),...a,l):a.sort((x,y)=>p(x,36)-p(y,36),p=parseInt).join``

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

ТТГ
источник
Почему бы не представить более короткое решение в качестве основного решения? Кроме того, он может быть на 2 байта короче, поскольку он не является рекурсивным.
лохматый
@ Shaggy Ах, совсем забыл удалить f=. Первый раньше был короче. Но он получает на 4 байта больше, поскольку OP спросил, что вывод может быть пустой строкой. И я просто держал их там ...
TSH
1
@ Shaggy Хорошо, просто узнай, что второй может быть еще короче. И я поместил это как первое.
TSH
2

Java 10, 223 209 301 байт

s->{int i=32,t;String M[]=new String[i],r,R="";for(var c:s)M[c%32]+=c>64&c<91|c>96&c<123?c:R;for(;i-->0;M[i]=(t=r.length()-4)>0?t+r.split(R)[t+3]:R)r=M[i]+R;java.util.Arrays.sort(M);for(var p:M)R+=p;return R;}

+92 байта в качестве исправления для входных данных, содержащих более 9 символов одной буквы. Посмотрим, смогу ли я снова это исправить с помощью другого подхода.

Попробуйте онлайн.

Объяснение:

s->{                        // Method with character-array parameter and String return-type
  int i=32,                 //  Index-integer, starting at 32
      t;                    //  Temp-integer, uninitialized
  String M[]=new String[i], //  Create a String-array of size 32, filled with null by default
         R="",              //  Result-String, starting empty
         r;                 //  Temp-String, uninitialized
  for(var c:s)              //  Loop over the characters of the input-array:
    M[c%32]+=               //   Append the string at index code-point of `c` modulo-32 with:
     c>64&c<91|c>96&c<123?  //    If the character is a letter:
      c                     //     Append the character
     :                      //    Else:
      R;                    //     Append an empty String
  for(;i-->0                //  Loop `i` in the range (32, 0]:
      ;                     //    After every iteration:
       M[i]=                //     Replace the String at index `i` with:
        (t=r.length()-4)    //      Set `t` to the length of String `r` minus 4
                            //      (the minus 4 is for the prepended "null")
         >0?                //      If this length minus 4 is larger than 0:
          t                 //       Set the String to this length minus 4
          +r.split(R)[t+3]  //       Appended with the last character of `r` as String
         :                  //      Else:
          R)                //       Make the String at index `i` empty
    r=M[i]                  //   Set `r` to the `i`'th String
          +R;               //  Converted to String
                            // (null becomes "null", to prevent NullPointerException-errors)
  java.util.Arrays.sort(M,  //  Now sort the array of Strings on:
   (a,b)->                  //   For each pair of two Strings:
     new Byte(              //    Convert the first String to a number
      (0+a).replaceAll("\\D",""))
                            //    after we've added a leading 0 and removed all non-digits
    .compareTo(             //   And compare it to:
     new Byte(              //    The second String converted to a number
      (0+b).replaceAll("\\D",""))));
                            //    after we've added a leading 0 and remove all non-digits
  for(var p:M)              //  Loop over the Strings of the array:
    R+=p;                   //   And append each to the result-String `R`
  return R;}                //  And finally return the result-String `R`
Кевин Круйссен
источник
1
@Shaggy Dang .. исправлено по цене 92 байта ..>. <Посмотрим, смогу ли я снова
сыграть в
Ой! Прости за это!
лохматый
2

Swift 4.2.1 / Xcode 10.1 , 1054 1050 1048 370 368 364 байта

s.map{String($0)}.filter{$0.rangeOfCharacter(from:.letters) != nil}.reversed().reduce(into:[String:Int]()){d,s in if let l=[s.uppercased(),s.lowercased()].first(where:{d[$0] != nil}){d[l]=d[l]!+1}else{d[s]=1}}.sorted{let c=$0.value-$1.value;return c==0 ?$0.key.compare($1.key,options:.caseInsensitive) == .orderedAscending:c<0}.map{"\($0.value)\($0.key)"}.joined()

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

@KevinCruijssen также удалил некоторые пробелы.

Роман Подымов
источник
Привет, добро пожаловать в PPCG! Я не знаю, Свифт, но, кажется, вы забыли удалить некоторые пробелы, и вы также можете играть в гольф falseот 0>1и trueдо 1>0. Попробуйте онлайн 1027 байт . Вероятно, можно сыграть еще много, как и у if let v=$0.key.escaped(asASCII:0>1).lowercased().unicodeScalars.first?.value{return v<$1.key.value}else{return 0>1}вас, но я оставлю это кому-то, кто действительно знает Swift.
Кевин Круйссен
1
Также, если вы еще этого не видели: советы по игре в гольф на <все языки> и советы по игре в гольф в Swift могут быть интересными для чтения. Снова добро пожаловать, и приятного пребывания! :)
Кевин Круйссен
Привет @KevinCruijssen. Спасибо за советы, я удалил trueи falseиз моего ответа.
Роман Подымов
1
Хорошо, вы довольно много играли в гольф с ваших начальных 1000+ байтов. :) Я вижу еще 6 пробелов, которые могут быть удалены после / до всех =-присвоений: попробуйте онлайн 364 байта . Приятного пребывания! :)
Кевин Круйссен
1

Древесный уголь , 30 байт

F⌈Eβ№↧θιFβ¿⁼№↧θκ⊕ι⁺⊕ι§Φθ⁼↧λκ±¹

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

F⌈Eβ№↧θι

Пробежитесь по строчному алфавиту и найдите наибольшее количество символов в строчных буквах. Цикл по неявному диапазону. (Цикл фактически переходит от 0к, n-1поэтому я должен увеличивать переменную цикла при каждом использовании.)

Fβ

Снова переберите строчный алфавит.

¿⁼№↧θκ⊕ι

Если счет текущей буквы равен значению внешнего цикла ...

⁺⊕ι§Φθ⁼↧λκ±¹

Объедините текущий счет с последним вхождением текущей буквы и неявно напечатайте.

Нил
источник
1

NodeJS, 299 байт, -6 байт благодаря @tsh

Не так красиво, но это работает!

(x,l={},g=p=>p.charCodeAt(),q=p=>p.toLowerCase())=>Object.entries([...x[R='replace'](/[^a-z]/gi,'')].reduce((m,n)=>(r=q(n),l[r]=g(n)>96?1:0,{...m,[r]:-~m[r]}),{})).sort((a,b)=>a[1]^b[1]?a[1]-b[1]:g(q(a[0]))-g(q(b[0]))).map(([m,n])=>[n,m]).join``[R](/,/g,'')[R](/[a-z]/g,v=>l[v]?q(v):v.toUpperCase())

Javascript (ES8) (Firefox или Chrome), 294 байта, -1 байт благодаря @tsh

С новым .flatметодом я могу сохранить 10 байтов:

(x,l={},g=p=>p.charCodeAt(),q=p=>p.toLowerCase())=>Object.entries([...x[R='replace'](/[^a-z]/gi,'')].reduce((m,n)=>(r=q(n),l[r]=g(n)>96?1:0,{...m,[r]:-~m[r]}),{})).sort((a,b)=>a[1]^b[1]?a[1]-b[1]:g(q(a[0]))-g(q(b[0]))).map(([m,n])=>[n,m]).flat().join``[R](/[a-z]/g,v=>l[v]?q(v):v.toUpperCase())

Попробуйте это онлайн: https://repl.it/repls/ConcernedHorribleHypothesis

Чау Гианг
источник
Привет и добро пожаловать в PPCG. Было бы неплохо, если бы вы предоставили способ проверить свою заявку, например, ссылку на онлайн-переводчика.
Джонатан Фрех
@JonathanFrech Я только что добавил тестовые примеры, спасибо!
Чау Гианг
.replaceх 3 раза -> [R='replace]и [R]х 2 раза
TSH
.charCodeAt(0)-> .charCodeAt()( 0по умолчанию)
TSH
@tsh Большое спасибо за все ваши хорошие советы, я только что обновил свой ответ!
Чау Гианг
1

Юлия 1,0 , 158 байт

¬t=(c=Dict();C=Dict();for i=eachmatch(r"\w",t);l=i.match;k=lowercase(l);c[k]=get(c,k,0)+1;C[k]=l;end;*(["$v$(C[k])" for (v,k)=sort([(v,k) for (k,v)=c])]...))

Оригинальная негольфированная версия с той же логикой:

function password(text)
    letter_counts = Dict()
    cases = Dict()

    for i in eachmatch(r"\w", text)
        letter = i.match[1]
        letter_key = lowercase(letter)
        letter_counts[letter_key] = get(letter_counts, letter_key, 0) + 1
        cases[letter_key] = letter
    end

    sorted_counts = sort([(value, key) for (key, value) in letter_counts])

    return string(["$v$(cases[k])" for (v,k) in sorted_counts]...)
end

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

niczky12
источник
0

Perl 6, 86 82 байта

{[~] flat map *[0,2],sort map {+$^b,$^a,$b[*-1]},kv classify &lc,.comb: /<alpha>/}
bb94
источник