パスワードを思い出すのは非常に難しいので、パスワードを生成する方法を思いつきました。

パスワードを生成する方法は、次の手順に従って単語または文から行います。

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つある文字は、アルファベット順で先頭に配置され、次に担当者が多い文字

これはcode-golfで、最短のコードが勝ちます。

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＃Interactive Compiler）、105バイト

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

オンラインでお試しください！

138バイトから105バイトにダウンさせてくれたdanaに感謝します。

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のマイナーなバグ修正。@Neilと@Shaggyの
おかげで-2バイト。

オンラインそれを試してみたり、すべてのテストケースを確認してください。

説明：

大文字と小文字を除くすべてを削除します。
つまり、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のおかげで、フィルターを変更することで別のバイトを拾い上げました。また、1文字が9回以上表示される可能性があることをOPが明らかにした場合、バグを修正する必要がありました。srD0m+lded.gr0kf}r0TGQ

APL（Dyalog Extended）、28 バイト^SBCS

匿名の暗黙の接頭辞関数。

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

オンラインでお試しください！

'\PL' 空の文字列で置き換えられた 非文字
⎕R PCRE R
''

(… ) 次の暗黙関数を適用します。

 ⌊ 小文字をキーとして、
 … ⌸ 各キーとそれに対応する値のセット、つまり
 ⊢ 引数に以下の暗黙関数を適用します。

  (… ) 次の暗黙関数
  ⍤ を
  ⊢ 値のリストに適用します。

   ⊢/ 最後の値

   … , それに次を追加します。

    ⍕ 集計 の文字列
    ⍤ 化
    ≢

   ⊂ 囲む（文字リストを単一の文字列として扱うため）

 ∊ ε NLIST（平坦化） ことのソート、昇順バージョン
 ⍤
 ∧

Perl 5の、74の 68 66バイト

-6変化バイト-pに-n及び使用sayの代わりに$_=join"", 使用してアビゲイルおかげバイト-2 \pLの代わりに[a-z]

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

TIO

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]

オンラインでお試しください！

バグを見つけてくれたShaggyに感謝します。

ゼリー、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'各文字の先頭にanを接続して、0数字以外のアルファ文字が返されるようにします。そして、このアルゴリズムによって、同じ文字とアルファベット以外の文字を最初に並べ替えることができます。
• 後sortとjoin、"Hello world!123"なります" !123deHllloorw"。に対する一致/([a-z])\1*/igは、非アルファ文字を無視し、文字列を同じ文字のチャンクに分割します。`。
• map質問で必要に応じて変換"aaa"し"3a"ます。
• 2番目のソートでは、最初のソートと同じ機能が使用されます。数値システムのおかげで、予想どおり36を"3b"下回り"12a"ます。最初にカウント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バイトは、1文字が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>/}