Дуже важко запам'ятати свій пароль, тому я придумав спосіб генерування пароля.

Я буду генерувати свій пароль від слова чи пропозиції, виконуючи наступні кроки:

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 повтором спочатку упорядковуються в алфавітному порядку, а потім літери з більшою кількістю повторень

Це код-гольф , виграє найкоротший код.

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"

05AB1E , 19 17 16 байт

Збережено 1 байт завдяки Kevin Cruijssen

áΣ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

C # (Visual C # Interactive Compiler) , 105 байт

x=>x.Where(char.IsLetter).GroupBy(a=>a%32).OrderBy(a=>(a.Count(),a.Key)).Select(a=>a.Count()+""+a.Last())

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

Завдяки Dana, що знизив його до 105 байт із 138 байт.

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

Сітківка , 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 для цього ):
тобто KitkatTango→aagiKknottT

O$`.
$l$0

Захоплення кожен шматок НЕ чутливі до регістру повторюється сусідні букви:
тобто aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

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

$.0$1

Сортуйте числа та групи літер на основі чисел:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

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

Мова Вольфрама (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.

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

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

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

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

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

'\PL' небукви
⎕R PCRE R, заміщені на
''  порожніми рядками

(… ) Застосувати таку негласну функцію:

 ⌊ за допомогою малих літер як кнопок,
 …⌸  застосувати нижчу функцію мовчання до кожної клавіші та відповідного набору значень, а саме
 ⊢ аргументу:

  (… ) Застосувати таку негласну функцію
  ⍤  до
  ⊢ списку значень:

   ⊢/ останнє значення

   …,  Додайте до цього:

    ⍕ stringification
    ⍤ з
    ≢  підрахунку

   ⊂ додавати (трактувати список символів як один рядок)

 ∊ ε NLIST (Flatten)  упорядковано по зростанню-версія , що
 ⍤
 ∧

Перл 5, 74 68 66 байт

-6 байт, що змінюються -pна -nта використовують sayзамість $_=join"", -2 байтів завдяки використанню Abigail \pLзамість[a-z]

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

ТІО

59 байт, якщо в кожному символі не більше 9 випадків

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

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

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

Python 3 , 105 байт

s=input()
t=s.upper()
for n,c in sorted((t.count(i),i)for i in{*t}if'@'<i<'['):print(n,end=s[t.rfind(c)])

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

-1 спасибі ArBo .

Haskell , 114/113 105 байт

^{-9 байт завдяки Laikoni (використовуючи розуміння списків, а (||)не 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

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

Червоний , 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]

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

Дякуємо Шаггі за те, що знайшли помилку.

Желе , 15 байт

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

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

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

Лушпиння , 15 байт

Ніякі проблеми з імпортом при використанні лушпиння, тому ми не можемо використовувати різні зручні функції , такі як 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"

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

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

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`

Скала , 103 байти

_.filter(_.isLetter).groupBy(_%32).values.map(l=>l.size+""+l.last).toSeq.sortBy(_.toLowerCase).mkString

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

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 також видалив пробіли.

Вугілля деревне , 30 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Пояснення:

Ｆ⌈Ｅβ№↧θι

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

Ｆβ

Знову переведіть алфавіт із малих літер.

¿⁼№↧θκ⊕ι

Якщо кількість поточної літери дорівнює значенню зовнішньої петлі ...

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

Об'єднайте поточний підрахунок з останньою появою поточного листа та неявно друкуйте.

Желе , 14 байт

fØẠŒuL,ṪƊƙ$ŒuÞ

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

Повна програма.

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

R , 131 129 байт

cat(paste0(N<-by(X<-utf8ToInt(gsub('[^a-z]','',scan(,''),T)),G<-X%%32,length),L<-intToUtf8(by(X,G,tail,1),T))[order(N,L)],sep='')

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

Джулія 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

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

Perl 6, 86 82 байт

{[~] flat map *[0,2],sort map {+$^b,$^a,$b[*-1]},kv classify &lc,.comb: /<alpha>/}