É muito difícil lembrar minha senha, então criei uma maneira de gerar uma senha.

A maneira como eu gero minha senha é de uma palavra ou frase, seguindo estas etapas:

1. Comece da esquerda para a direita

2. Encontre a contagem de cada letra

3. Coloque a letra com sua contagem em um pedido

   • Cartas com maior repetição serão no final

   • Letras com a mesma repetição serão ordenadas alfabeticamente

4. Números e letras especiais serão ignorados, incluindo espaços em branco (por exemplo, 9, 4, @, (, *, etc. são ignorados)

5. Agrupe letras ignorando maiúsculas e minúsculas. Na saída, use o caso da última ocorrência na entrada

6. A contagem da letra pode ser qualquer número, por exemplo, 5H17M345K
7. Se a entrada for todos os números ou letras especiais, a saída será uma sequência vazia, por exemplo, Entrada "12 $ * 34 ^!" então imprima ""
8. quando a ordem para a mesma ocorrência em ordem alfabética não importa, por exemplo, 1a1B1c

Exemplo:

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

Outro exemplo:

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

Nota: as letras com 1 repetição estão no início ordenadas alfabeticamente e as letras com mais repetições

Este é o código-golfe , o código mais curto vence.

Japt v2.0a0 -P, 14 bytes

f\l üv ñÊ®ÌiZÊ

Tente

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 bytes

Guardado 1 byte graças a Kevin Cruijssen

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

Experimente online! ou como um conjunto de testes

Explicação

á                  # 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 # (compilador interativo do Visual C #) , 105 bytes

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

Experimente online!

Agradecemos à dana por reduzi-lo para 105 bytes de 138 bytes.

Perl 6 , 66 63 bytes

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

Experimente online!

Explicação

{                                                             }  # 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

Retina , 67 66 41 39 bytes

\P{L}

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

-25 bytes e uma pequena correção de bug, graças ao @Neil .
-2 bytes graças a @Neil e @Shaggy juntos.

Experimente online ou verifique todos os casos de teste .

Explicação:

Remova tudo, exceto letras maiúsculas e minúsculas:
ou seja, Kitkat Tango 123!→KitkatTango

\P{L}

Ordene as letras individuais que não diferenciam maiúsculas de minúsculas ( obrigado a @MartinEnder por isso ):
ie KitkatTango→aagiKknottT

O$`.
$l$0

Capturar cada pedaço de caso-insensível repetido cartas adjacentes:
ou seja aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Preceder o comprimento de todos os jogos, e manter apenas a última letra de cada pedaço:
ou seja, [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Classifique os grupos de números e letras com base nos números:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

Após o qual o resultado é gerado implicitamente.

Wolfram Language (Mathematica) , 102 96 93 87 bytes

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

Experimente online!

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.

Pitão, 27 24 22 bytes

ssrD0m,lded.gr0k@+Gr1G

Experimente online aqui .

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

Edit: Golfed 3 bytes, ordenando por caractere antes do grupo, versão anterior: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edit 2: Golfed off 2 bytes formatando a saída antes de qualquer pedido, versão anterior: sm+ldedlD.gr0krD0f}r0TGQ

Edição 3: Obteve mais um byte ao alterar o filtro, graças a @FryAmTheEggman. Também foi necessário corrigir um erro quando o OP esclareceu que uma única letra pode aparecer mais de 9 vezes, adicionando um byte em: o (Versão anterior:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Extended) , ^{SBCS de} 28 bytes

Função de prefixo tácito anônimo.

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

Experimente online!

'\PL' não-letras
⎕R PCRE R substituídas por
'' cadeias vazias

(… ) Aplique a seguinte função tácita:

 ⌊ com as minúsculas como chaves,
 … ⌸ aplique a função tácita abaixo a cada chave e seu conjunto de valores correspondente, a saber,
 ⊢ o argumento:

  (… ) Aplique a seguinte função tácita
  ⍤ à
  ⊢ lista de valores:

   ⊢/ o último valor

   … , Acrescente o seguinte a isso:

    ⍕ a estrificação
    ⍤ da
    ≢ contagem

   ⊂ delimitar (para tratar a lista de caracteres como sequência única)

 ∊ ε nlist (flatten)
 ⍤ a
 ∧ versão classificadas-crescente de que

Perl 5, 74 68 66 bytes

-6 bytes mudando -ppara -ne usando em sayvez de $_=join"", -2 bytes graças a Abigail usando em \pLvez de[a-z]

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

TIO

59 bytes, caso não haja mais de 9 ocorrências de cada caractere

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

Python 2 , 116 bytes

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

Experimente online!

Python 3 , 105 bytes

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

Experimente online!

-1 graças ao ArBo .

Haskell , 114/113 105 bytes

^{-9 bytes graças a Laikoni (usando a compreensão de lista e em (||)vez de filtercom elem& shorten lengthpara se livrar de feio 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

Experimente online!

Vermelhos , 220 196 206 bytes

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]

Experimente online!

Obrigado a Shaggy por encontrar um bug.

Gelatina , 15 bytes

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

Um programa completo que imprime a senha conforme especificado (como um link monádico, gera uma lista de listas, cada uma contendo um número inteiro e um caractere).

Experimente online!

Casca , 15 bytes

Sem problemas com importações ao usar Husk, portanto, podemos fazer uso das várias funções úteis, como groupOn, sortOn, toLoweretc:

ṁ§:osL→ÖLSġÖ_f√

Experimente online ou tente todos!

Explicação

ṁ§:(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 bytes

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

Experimente online!

• parseInt(numberAsString, radix)tentará analisar o número inteiro no início da string. Por exemplo, parseInt('120px', 10)produzirá 120. Quando a análise falhou, ela retornou NaN. Conectamos um '0'ao início de cada caractere para que ele retorne 0para qualquer caractere alfa não numérico. E podemos ordenar as mesmas letras e caracteres não alfa desde o início por esse algoritmo.
• Depois sorte join, "Hello world!123"se tornaria " !123deHllloorw". Uma correspondência contra /([a-z])\1*/igignorará qualquer caractere não alfa e dividirá a sequência em partes com as mesmas letras. `.
• mapconverter "aaa"para "3a"conforme necessário na pergunta.
• O segundo tipo usa a mesma função que o primeiro. Graças ao sistema numérico, "3b"seria menor do que "12a"na base 36, exatamente como esperamos: Compara as contagens primeiro ( n div 36) e depois a letra ( n mod 36).
• Finalmente joineles juntos.

JavaScript (Node.js) , 146 bytes

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

Experimente online!

Java 10, 223 209 301 bytes

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 bytes como uma correção para entradas com mais de 9 letras de uma única letra. Verificarei se eu posso diminuir isso novamente com uma abordagem diferente.

Experimente online.

Explicação:

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`

Scala , 103 bytes

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

Experimente online!

Swift 4.2.1 / Xcode 10.1 , 1054 1050 1048 370 368 364 bytes

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

Experimente online!

@KevinCruijssen também removeu alguns espaços.

Carvão , 30 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

Ｆ⌈Ｅβ№↧θι

Percorra o alfabeto em minúsculas e encontre a maior contagem de caracteres na entrada em minúsculas. Loop sobre o intervalo implícito. (Na verdade, o loop passa de 0para, n-1então eu tenho que incrementar a variável do loop a cada uso.)

Ｆβ

Faça um loop sobre o alfabeto minúsculo novamente.

¿⁼№↧θκ⊕ι

Se a contagem da letra atual for igual ao valor do loop externo ...

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

Concatene a contagem atual com a última ocorrência da letra atual e imprima implicitamente.

Gelatina , 14 bytes

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

Experimente online!

Programa completo.

NodeJS, 299 bytes, -6 bytes obrigado a @tsh

Não é tão bonito, mas funciona!

(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 ou Chrome), 294 bytes, -1 byte obrigado a @tsh

Com o novo .flatmétodo, eu posso salvar 10 bytes:

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

Tente isso online: https://repl.it/repls/ConcernedHorribleHypothesis

R , 131 129 bytes

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

Experimente online!

Julia 1.0 , 158 bytes

¬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])]...))

Versão original não destruída com a mesma lógica:

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

Experimente online!

Perl 6, 86 82 bytes

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