记住密码非常困难，因此我想出了一种生成密码的方法。

按照以下步骤，我是通过单词或句子生成密码的：

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，14 -P个字节

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字节

感谢Kevin Cruijssen节省了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

C＃（Visual C＃交互式编译器），105字节

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

在线尝试！

感谢dana将其从138个字节减少到105个字节。

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

ir`\1*(.)

预先准备每场比赛的长度，并只保留每一个块的最后一个字母：
即[ aa，g，i，Kk，n，o，ttT]→2a1g1i2k1n1o3T

$.0$1

根据数字对数字和字母组进行排序：
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

之后，将隐式输出结果。

Wolfram语言（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扩展），28 字节^SBCS

匿名默认前缀功能。

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

在线尝试！

'\PL' 非字母
⎕R PCRE R替换为
'' 空字符串

(… ) 应用以下默认功能：

 ⌊ 以小写字母为键，
 … ⌸ 对每个键及其对应的一组值（即
 ⊢ 自变量）应用以下默认函数：

  (… ) 将以下默认函数
  ⍤ 应用于
  ⊢ 值列表：

   ⊢/ 最后的值

   ……在此之前, 加上以下内容：

    ⍕ 该字符串化
    ⍤ 的
    ≢ 帐簿

   ⊂ 括起来（将字符列表视为单个字符串）

 ∊ ϵ nlist（展平）
 ⍤ 该列表
 ∧ 的升序版本

Perl 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字节

^{感谢Laikoni -9个字节（使用list-comprehension而(||)不是filterwith elem＆shortlength摆脱丑陋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]

在线尝试！

感谢Shaggy发现错误。

果冻，15 字节

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

完整的程序会按指定的顺序打印密码（作为Monadic Link，它将产生一个列表列表，每个列表包含一个整数和一个字符）。

在线尝试！

外壳，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。我们将an连接'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`

Scala，103个字节

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

在线尝试！

迅速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>/}