È molto difficile ricordare la mia password, quindi ho trovato un modo per generare una password.

Il modo in cui generi la mia password proviene da una parola o una frase, seguendo questi passaggi:

1. Inizia da sinistra a destra

2. Trova il conteggio di ogni lettera

3. Metti la lettera con il suo conteggio in un ordine

   • Le lettere con ripetizione più alta saranno alla fine

   • Le lettere con la stessa ripetizione verranno ordinate in ordine alfabetico

4. I numeri e le lettere speciali verranno ignorati, compresi gli spazi bianchi (ad es. 9, 4, @, (, *, ecc. Vengono ignorati)

5. Le lettere di gruppo ignorano il caso. Nell'output, utilizzare il caso dell'ultima occorrenza nell'input

6. Il conteggio della lettera può essere qualsiasi numero, ad esempio 5H17M345K
7. Se l'input è costituito da tutti i numeri o lettere speciali, l'output sarà una stringa vuota, ad esempio Input "12 $ * 34 ^!" quindi emettere ""
8. quando l'ordine per la stessa occorrenza in ordine alfabetico, il caso non ha importanza, ad es. 1a1B1c

Esempio:

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

Un altro esempio:

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

Nota: le lettere con 1 ripetizione sono all'inizio in ordine alfabetico, quindi le lettere con più ripetizioni

Questo è code-golf , vince il codice più corto.

Japt v2.0a0 -P, 14 byte

f\l üv ñÊ®ÌiZÊ

Provalo

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 byte

Salvato 1 byte grazie a Kevin Cruijssen

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

Provalo online! o come una suite di test

Spiegazione

á                  # 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 # (compilatore interattivo Visual C #) , 105 byte

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

Provalo online!

Grazie a dana per averlo portato a 105 byte da 138 byte.

Perl 6 , 66 63 byte

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

Provalo online!

Spiegazione

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

\P{L}

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

-25 byte e una piccola correzione di bug grazie a @Neil .
-2 byte grazie a @Neil e @Shaggy insieme.

Provalo online o verifica tutti i casi di test .

Spiegazione:

Rimuovi tutto tranne le lettere maiuscole e minuscole:
cioè Kitkat Tango 123!→KitkatTango

\P{L}

Ordina le singole lettere senza distinzione tra maiuscole e minuscole ( grazie a @MartinEnder per questo ):
cioè KitkatTango→aagiKknottT

O$`.
$l$0

Cattura ogni pezzo di case-insensitive ripetute lettere adiacenti:
cioè aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Anteporre la lunghezza di ogni partita, e mantenere solo l'ultima lettera di ogni pezzo:
vale a dire [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Ordina i numeri e i gruppi di lettere in base ai numeri:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

Dopodiché il risultato viene emesso implicitamente.

Wolfram Language (Mathematica) , 102 96 93 87 byte

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

Provalo 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.

Pyth, 27 24 22 byte

ssrD0m,lded.gr0k@+Gr1G

Provalo online qui .

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

Modifica: golfato 3 byte ordinando per carattere prima del gruppo, versione precedente: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Modifica 2: ha eliminato altri 2 byte formattando l'output prima di qualsiasi ordine, versione precedente: sm+ldedlD.gr0krD0f}r0TGQ

Modifica 3: golfato da un altro byte modificando il filtro, grazie a @FryAmTheEggman. Inoltre, è stato necessario correggere un bug quando OP ha chiarito che una singola lettera può apparire più di 9 volte, il che ha aggiunto un byte su: o (Versione precedente:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Extended) , ^{SBCS da} 28 byte

Funzione prefisso tacito anonimo.

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

Provalo online!

'\PL' non alfabetici
⎕R PCRE R eplaced con
'' stringhe vuote

(... ) applica la seguente funzione tacita:

 ⌊ con le lettere minuscole come chiavi,
 ... ⌸ applica la seguente funzione tacita a ciascuna chiave e al suo corrispondente set di valori, vale a dire
 ⊢ l'argomento:

  (... ) applicare la seguente funzione tacita
  ⍤ per
  ⊢ l'elenco dei valori:

   ⊢/ l'ultimo valore

   ... , anteporre a quanto segue:

    ⍕ la stringificazione
    ⍤ del
    ≢ conteggio

   ⊂ racchiudi (per trattare l'elenco dei caratteri come singola stringa)

 ∊ ε nlist (Appiattisci)
 ⍤ la
 ∧ versione ordinato-ascendenti di questo

Perl 5, 74 68 66 byte

-6 byte cambiando -pin -ne usando sayinvece di $_=join"", -2 byte grazie ad Abigail usando \pLinvece di[a-z]

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

TIO

59 byte, nel caso in cui non vi siano più di 9 occorrenze per ciascun carattere

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

Python 2 , 116 byte

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

Provalo online!

Python 3 , 105 byte

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

Provalo online!

-1 grazie ad ArBo .

Haskell , 114/113 105 byte

^{-9 byte grazie a Laikoni (usando list-comprensione e (||)invece di filtercon eleme accorciare lengthper sbarazzarsi di brutto 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

Provalo online!

Rosso , 220 196 206 byte

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]

Provalo online!

Grazie a Shaggy per aver trovato un bug.

Gelatina , 15 byte

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

Un programma completo che stampa la password come specificato (come Link monadico produce un elenco di liste contenenti ciascuna un numero intero e un carattere).

Provalo online!

Buccia , 15 byte

Nessun problema con le importazioni quando si utilizza Cartoccio, pertanto si possono utilizzare le varie funzioni a portata di mano, come groupOn, sortOn, toLowerecc:

ṁ§:osL→ÖLSġÖ_f√

Provalo online o provali tutti!

Spiegazione

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

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

Provalo online!

• parseInt(numberAsString, radix)proverà ad analizzare il numero intero all'inizio della stringa. Ad esempio, parseInt('120px', 10)genererà 120. Quando l'analisi non è riuscita, restituisce NaNinvece. Colleghiamo un '0'all'inizio di ogni personaggio in modo che ritorni0 per tutti i caratteri non numerici alfa. E possiamo ordinare le stesse lettere insieme e carattere non alfa all'inizio con questo algoritmo.
• Dopo sorte join, "Hello world!123"sarebbe diventato " !123deHllloorw". Una corrispondenza contro/([a-z])\1*/ig ignorerà qualsiasi carattere non alfa e dividerà la stringa in blocchi con le stesse lettere. `.
• map convertire "aaa" a "3a"come richiesto nella domanda.
• Il secondo ordinamento utilizza la stessa funzione del primo. Grazie al sistema numerico, "3b"sarebbe inferiore rispetto "12a"alla base 36 proprio come ci aspettiamo: confronta prima i conteggi (n div 36 ) e confronta la lettera in seguito ( n mod 36).
• Finalmente joininsieme.

JavaScript (Node.js) , 146 byte

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

Provalo online!

Java 10, 223 209 301 byte

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 byte come correzione per input con più di 9 di una singola lettera. Vedrò se riesco a ridurlo con un approccio diverso.

Provalo online.

Spiegazione:

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 byte

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

Provalo online!

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

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

Provalo online!

Anche @KevinCruijssen ha rimosso alcuni spazi.

Carbone , 30 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

Ｆ⌈Ｅβ№↧θι

Scorri l'alfabeto minuscolo e trova il conteggio dei caratteri più alto nell'input in minuscolo. Passa sopra l'intervallo implicito. (Il loop in realtà va da 0a, n-1quindi devo incrementare la variabile loop ad ogni utilizzo.)

Ｆβ

Passa di nuovo sopra l'alfabeto minuscolo.

¿⁼№↧θκ⊕ι

Se il conteggio della lettera corrente è uguale al valore del loop esterno ...

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

Concatena il conteggio corrente con l'ultima occorrenza della lettera corrente e stampa implicitamente.

Gelatina , 14 byte

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

Provalo online!

Programma completo.

NodeJS, 299 byte, -6 byte grazie a @tsh

Non così bella ma funziona!

(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 o Chrome), 294 byte, -1 byte grazie a @tsh

Con il nuovo .flatmetodo, posso salvare 10 byte:

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

Prova questo online: https://repl.it/repls/ConcernedHorribleHypothesis

R , 131 129 byte

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

Provalo online!

Julia 1.0 , 158 byte

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

Versione originale non golfata con la stessa logica:

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

Provalo online!

Perl 6, 86 82 byte

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