Es ist sehr schwer, sich mein Passwort zu merken, deshalb habe ich mir eine Möglichkeit ausgedacht, ein Passwort zu generieren.

So generiere ich mein Passwort aus einem Wort oder einem Satz:

1. Beginnen Sie von links nach rechts

2. Ermitteln Sie die Anzahl der einzelnen Buchstaben

3. Bringe den Buchstaben mit seiner Zählung in eine Reihenfolge

   • Briefe mit höherer Wiederholung werden am Ende sein

   • Buchstaben mit der gleichen Wiederholung werden alphabetisch sortiert

4. Zahlen und Sonderzeichen einschließlich Leerzeichen werden ignoriert (z. B. 9, 4, @, (, * usw. werden ignoriert)

5. Gruppenbuchstaben ignorieren Groß- und Kleinschreibung. Verwenden Sie in der Ausgabe den Fall des letzten Vorkommens in der Eingabe

6. Die Anzahl der Buchstaben kann eine beliebige Zahl sein, z. B. 5H17M345K
7. Wenn es sich bei der Eingabe um alle Zahlen oder Sonderzeichen handelt, ist die Ausgabe eine leere Zeichenfolge, z. B. Eingabe "12 $ * 34 ^!" dann "" ausgeben
8. wenn die Reihenfolge für dasselbe Vorkommen in alphabetischer Reihenfolge keine Rolle spielt, z. B. 1a1B1c

Beispiel:

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

Ein anderes Beispiel:

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

Hinweis: Die Buchstaben mit 1 Wiederholung sind am Anfang alphabetisch geordnet, danach die Buchstaben mit mehr Wiederholungen

Dies ist Code-Golf , der kürzeste Code gewinnt.

Japt v2.0a0 -P, 14 Bytes

f\l üv ñÊ®ÌiZÊ

Versuch es

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

Dank Kevin Cruijssen 1 Byte gespeichert

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

Probieren Sie es online! oder als Testsuite

Erläuterung

á                  # 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 Byte

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

Probieren Sie es online!

Danke an dana, die es von 138 Bytes auf 105 Bytes reduziert hat.

Perl 6 , 66 63 Bytes

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

Probieren Sie es online!

Erläuterung

{                                                             }  # 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 und ein kleiner Bugfix dank @Neil .
-2 Bytes dank @Neil und @Shaggy zusammen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Entfernen Sie alles außer Groß- und Kleinbuchstaben:
dh Kitkat Tango 123!→KitkatTango

\P{L}

Sortieren Sie die einzelnen Buchstaben ohne Berücksichtigung der Groß- / Kleinschreibung ( danke an @MartinEnder dafür ):
dh KitkatTango→aagiKknottT

O$`.
$l$0

Erfassen Sie jedes Stück von Groß- und Kleinschreibung wiederholten benachbarte Buchstaben:
dh aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Prepend die Länge jedes Spiel, und halten nur den letzten Buchstaben eines jeden Brocken:
dh [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Sortieren Sie die Zahlen- und Buchstabengruppen nach den Zahlen:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

Danach wird das Ergebnis implizit ausgegeben.

Wolfram Language (Mathematica) , 102 96 93 87 Bytes

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

Probieren Sie es 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 Bytes

ssrD0m,lded.gr0k@+Gr1G

Probieren Sie es hier online aus .

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

Bearbeiten: 3 Bytes nach Zeichen vor Gruppe sortiert, Vorgängerversion: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edit 2: Weitere 2 Bytes durch Formatieren der Ausgabe vor einer Bestellung entfernt, vorherige Version: sm+ldedlD.gr0krD0f}r0TGQ

Edit 3: Durch Ändern des Filters dank @FryAmTheEggman ein weiteres Byte herausgefiltert. Außerdem musste ein Fehler behoben werden, als OP klarstellte, dass ein einzelner Buchstabe mehr als neunmal vorkommen kann, wodurch ein Byte wieder hinzugefügt wurde am: o (Vorgängerversion:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Extended) , 28 Byte ^SBCS

Anonyme implizite Präfixfunktion.

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

Probieren Sie es online!

'\PL' Nicht-Buchstaben
⎕R PCRE R eplaced mit
'' leeren Saiten

(… ) Wenden folgende stillschweigende Funktion an:

 ⌊ Mit dem Kleinbuchstaben als Schlüssel
 … ⌸ wenden Sie die folgende implizite Funktion auf jeden Schlüssel und die entsprechende Menge von Werten an, nämlich
 ⊢ das Argument:

  (… ) Wenden Sie die folgende implizite Funktion
  ⍤ auf
  ⊢ die Werteliste an:

   ⊢/ der letzte Wert

   … , Dem Folgendes voranstellen:

    ⍕ die stringification
    ⍤ von
    ≢ Tally

   ⊂ einschließen (um die Zeichenliste als einzelne Zeichenfolge zu behandeln)

 ∊ ϵ nliste (verflache)
 ⍤ die
 ∧ aufsteigend sortierte Version davon

Perl 5, 74 68 66 Bytes

-6 Bytes ändern sich -pzu -nund verwenden saystatt $_=join"", -2 Bytes dank Abigail verwenden \pLstatt[a-z]

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

TIO

59 Bytes, falls nicht mehr als 9 Zeichen vorkommen

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

Probieren Sie es 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)])

Probieren Sie es online!

-1 danke an ArBo .

Haskell , 114/113, 105 Bytes

^{-9 Bytes dank Laikoni (mit Listenverständnis und (||)statt filtermit elem& kürzen length, um hässlich loszuwerden 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

Probieren Sie es online!

Rot , 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]

Probieren Sie es online!

Vielen Dank an Shaggy für das Auffinden eines Fehlers.

Gelee , 15 Bytes

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

Ein vollständiges Programm, das das angegebene Passwort druckt (als monadischer Link gibt es eine Liste von Listen aus, die jeweils eine Ganzzahl und ein Zeichen enthalten).

Probieren Sie es online!

Schale , 15 Bytes

Keine Probleme mit der Einfuhr , wenn Husk verwenden, deshalb können wir den Einsatz der verschiedenen praktischen Funktionen wie machen groupOn, sortOn, toLoweretc:

ṁ§:osL→ÖLSġÖ_f√

Probieren Sie es online aus oder probieren Sie sie alle aus!

Erläuterung

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

Probieren Sie es online!

• parseInt(numberAsString, radix)versucht, eine Ganzzahl am Anfang der Zeichenfolge zu analysieren. Beispielsweise parseInt('120px', 10)wird 120 ausgegeben. Wenn das Parsen fehlgeschlagen ist, wird NaNstattdessen zurückgegeben. Wir verbinden ein '0'mit dem Anfang jedes Zeichens, damit es 0für alle nicht numerisch-alphanumerischen Zeichen zurückgegeben wird. Und wir können durch diesen Algorithmus dieselben Buchstaben und Nicht-Alpha-Zeichen an den Anfang sortieren.
• Nach sortund join, "Hello world!123"würde " !123deHllloorw". Bei einem Abgleich mit /([a-z])\1*/igwird jedes Nicht-Alpha-Zeichen ignoriert und die Zeichenfolge in Abschnitte mit denselben Buchstaben aufgeteilt. `.
• mapkonvertieren "aaa"nach "3a"wie in der frage erforderlich.
• Die zweite Sortierung verwendet dieselbe Funktion wie die erste. Dank des Zahlensystems "3b"wäre es weniger als "12a"in Basis 36, so wie wir es erwarten: Es wird zuerst die Anzahl verglichen ( n div 36) und später der Buchstabe verglichen (n mod 36 ).
• Endlich joinsie zusammen.

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

Probieren Sie es 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 als Fehlerbehebung für Eingaben mit mehr als 9 Buchstaben. Mal sehen, ob ich das mit einem anderen Ansatz wieder reduzieren kann.

Probieren Sie es online aus.

Erläuterung:

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

Probieren Sie es 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()

Probieren Sie es online!

@ KevinCruijssen entfernt auch einige Leerzeichen.

Kohle , 30 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

Ｆ⌈Ｅβ№↧θι

Durchsuche das Kleinbuchstaben und finde die höchste Zeichenanzahl in der Eingabe in Kleinbuchstaben. Schleife über den impliziten Bereich. (Die Schleife geht tatsächlich von 0nach, n-1so dass ich die Schleifenvariable bei jeder Verwendung erhöhen muss.)

Ｆβ

Bewegen Sie sich erneut über das Kleinbuchstaben.

¿⁼№↧θκ⊕ι

Wenn die Anzahl der aktuellen Buchstaben gleich dem Wert der äußeren Schleife ist ...

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

Verketten Sie die aktuelle Anzahl mit dem letzten Vorkommen des aktuellen Buchstabens und drucken Sie implizit.

Gelee , 14 Bytes

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

Probieren Sie es online!

Volles Programm.

NodeJS, 299 Bytes, -6 Bytes, danke an @tsh

Nicht so schön, aber es funktioniert!

(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 oder Chrome), 294 Byte, -1 Byte danke an @tsh

Mit der neuen .flatMethode kann ich 10 Bytes sparen:

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

Versuchen Sie dies 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='')

Probieren Sie es 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])]...))

Original ungolfed version mit der gleichen logik:

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

Probieren Sie es online!

Perl 6, 86 82 Bytes

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