Rất khó để nhớ mật khẩu của tôi, vì vậy tôi đã nghĩ ra cách tạo mật khẩu.

Cách tôi tạo mật khẩu của mình là từ một từ hoặc một câu, làm theo các bước sau:

1. Bắt đầu từ trái sang phải

2. Tìm số lượng của mỗi chữ cái

3. Đặt thư với số lượng của nó theo thứ tự

   • Thư có độ lặp lại cao hơn sẽ ở cuối

   • Các chữ cái có cùng độ lặp lại sẽ được sắp xếp theo thứ tự abc

4. Các số và chữ cái đặc biệt sẽ bị bỏ qua bao gồm khoảng trắng (ví dụ: 9, 4, @, (, *, v.v.) bị bỏ qua)

5. Nhóm chữ bỏ qua trường hợp. Trong đầu ra, sử dụng trường hợp xảy ra lần cuối trong đầu vào

6. Số lượng của chữ cái có thể là bất kỳ số nào, ví dụ 5H17M345K
7. Nếu đầu vào là tất cả các số hoặc chữ cái đặc biệt thì đầu ra sẽ là chuỗi rỗng, ví dụ: Đầu vào "12 $ * 34 ^!" sau đó xuất ""
8. khi thứ tự cho cùng một trường hợp theo thứ tự chữ cái không quan trọng, ví dụ 1a1B1c

Thí dụ:

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

Một vi dụ khac:

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

Lưu ý: các chữ cái có 1 lặp lại được bắt đầu theo thứ tự bảng chữ cái sau đó các chữ cái có nhiều đại diện hơn

Đây là code-golf , mã ngắn nhất sẽ thắng.

Japt v2.0a0 -P, 14 byte

f\l üv ñÊ®ÌiZÊ

Thử nó

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

Đã lưu 1 byte nhờ Kevin Cruijssen

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

á                  # 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 # (Trình biên dịch tương tác 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())

Hãy thử trực tuyến!

Cảm ơn dana đã đưa nó xuống 105 byte từ 138 byte.

Perl 6 , 66 63 byte

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

Hãy thử trực tuyến!

Giải trình

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

Võng mạc , 67 66 41 39 byte

\P{L}

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

-25 byte và sửa lỗi nhỏ nhờ @Neil .
-2 byte nhờ @Neil và @Shaggy cùng nhau.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Xóa mọi thứ trừ chữ in hoa và chữ thường:
tức là Kitkat Tango 123!→KitkatTango

\P{L}

Sắp xếp các chữ cái không phân biệt chữ hoa chữ thường ( cảm ơn @MartinEnder cho việc này ):
tức là KitkatTango→aagiKknottT

O$`.
$l$0

Nắm bắt mọi đoạn của case-insensitive lặp đi lặp lại chữ cái liền kề:
tức aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Thêm vào trước theo chiều dài của mỗi trận đấu, và chỉ giữ lại lá thư cuối cùng của mỗi đoạn:
tức là [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Sắp xếp các số và nhóm chữ cái dựa trên các số:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

Sau đó, kết quả là đầu ra ngầm.

Ngôn ngữ Wolfram (Mathicala) , 102 96 93 87 byte

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

Hãy thử trực tuyến!

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.

Bình thường, 27 24 22 byte

ssrD0m,lded.gr0k@+Gr1G

Dùng thử trực tuyến tại đây .

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

Chỉnh sửa: Đã đánh 3 byte bằng cách sắp xếp theo ký tự trước nhóm, phiên bản trước: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Chỉnh sửa 2: Đánh bại 2 byte khác bằng cách định dạng đầu ra trước khi đặt hàng, phiên bản trước: sm+ldedlD.gr0krD0f}r0TGQ

Chỉnh sửa 3: Đánh bại một byte khác bằng cách thay đổi bộ lọc, nhờ @FryAmTheEggman. Cũng phải sửa một lỗi khi OP làm rõ rằng một chữ cái có thể xuất hiện hơn 9 lần, điều này đã thêm một byte trở lại: o (Phiên bản trước:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog mở rộng) , 28 byte ^SBCS

Chức năng tiền tố ẩn danh.

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

Hãy thử trực tuyến!

'\PL'
⎕R PCRE R  không chữ được đặt với
''  các chuỗi trống

(Giáo dục)  áp dụng các chức năng ngầm như sau:

 ⌊ với chữ thường như phím,
 ... ⌸ áp dụng dưới đây chức năng ngầm cho mỗi phím và bộ tương ứng của các giá trị, cụ thể là
 ⊢  các đối số:

  (... ) áp dụng các chức năng ngầm sau
  ⍤ để
  ⊢  danh sách các giá trị:

   ⊢/ giá trị cuối cùng

   ... , thêm vào trước sau đó:

    ⍕ sự sắp xếp
    ⍤ của
    ≢ kiểm đếm

   ⊂ kèm theo (để coi danh sách ký tự là một chuỗi)

 ∊ ε nlist (flatten)
 ⍤ các
 ∧ phiên bản được sắp xếp tăng dần-đó

Perl 5, 74 68 66 byte

-6 byte thay đổi -pthành -nvà sử dụng saythay vì $_=join"", -2 byte nhờ Abigail sử dụng \pLthay vì[a-z]

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

TIO

59 byte, trong trường hợp không có quá 9 lần xuất hiện của mỗi ký tự

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

-1 cảm ơn ArBo .

Haskell , 114/113 105 byte

^{-9 byte nhờ Laikoni (sử dụng khả năng hiểu danh sách và (||)thay vì filtervới elem& rút ngắn lengthđể thoát khỏi sự xấu xí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

Hãy thử trực tuyến!

Màu đỏ , 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]

Hãy thử trực tuyến!

Cảm ơn Shaggy đã tìm ra một lỗi.

Thạch , 15 byte

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

Một chương trình đầy đủ in mật khẩu theo quy định (dưới dạng Liên kết đơn, nó mang lại một danh sách các danh sách chứa mỗi số nguyên và một ký tự).

Hãy thử trực tuyến!

Chồng , 15 byte

Không có vấn đề với hàng nhập khẩu khi sử dụng vỏ trấu, do đó chúng ta có thể tận dụng các chức năng tiện dụng khác nhau như groupOn, sortOn, toLowervv:

ṁ§:osL→ÖLSġÖ_f√

Dùng thử trực tuyến hoặc thử tất cả!

Giải trình

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

Hãy thử trực tuyến!

• parseInt(numberAsString, radix)sẽ cố phân tích số nguyên ở đầu chuỗi. Ví dụ, parseInt('120px', 10)sẽ xuất 120. Khi phân tích cú pháp thất bại, nó sẽ trả về NaN. Chúng tôi kết nối một '0'đến đầu của mỗi nhân vật để nó sẽ trở lại0 cho bất kỳ ký tự không phải là số alpha nào. Và chúng ta có thể sắp xếp các chữ cái giống nhau và ký tự không alpha đến đầu bằng thuật toán này.
• Sau sortvà join, "Hello world!123"sẽ trở thành " !123deHllloorw". Kết hợp ngược lại /([a-z])\1*/igsẽ bỏ qua bất kỳ ký tự không phải alpha nào và chia chuỗi thành các đoạn có cùng chữ cái. `.
• mapchuyển đổi "aaa"sang"3a" theo yêu cầu trong câu hỏi.
• Loại thứ hai sử dụng chức năng tương tự như thứ nhất. Nhờ hệ thống số, "3b"sẽ ít hơn "12a"trong cơ sở 36 như chúng ta mong đợi: Nó so sánh số đếm trước ( n div 36) và so sánh chữ cái sau ( n mod 36).
• Cuối cùng joinhọ bên nhau.

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

Hãy thử trực tuyến!

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 như là một sửa chữa cho các đầu vào có nhiều hơn 9 chữ cái .. Sẽ xem liệu tôi có thể đưa nó xuống một lần nữa bằng một cách tiếp cận khác không.

Hãy thử trực tuyến.

Giải trình:

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

@KevinCruijssen cũng xóa một số khoảng trắng.

Than , 30 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

Ｆ⌈Ｅβ№↧θι

Chạy qua bảng chữ cái chữ thường và tìm số ký tự cao nhất trong đầu vào chữ thường. Vòng qua phạm vi ngầm. (Vòng lặp thực sự đi từ 0đến n-1vì vậy tôi phải tăng biến vòng lặp cho mỗi lần sử dụng.)

Ｆβ

Lặp lại bảng chữ cái viết thường một lần nữa.

¿⁼№↧θκ⊕ι

Nếu số lượng của chữ cái hiện tại bằng với giá trị vòng lặp bên ngoài ...

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

Nối số đếm hiện tại với lần xuất hiện cuối cùng của chữ cái hiện tại và in ngầm.

Thạch , 14 byte

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

Hãy thử trực tuyến!

Chương trình đầy đủ.

NodeJS, 299 byte, -6 byte cảm ơn @tsh

Không quá đẹp nhưng nó hoạt động!

(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 hoặc Chrome), 294 byte, -1 byte cảm ơn @tsh

Với .flatphương thức mới , tôi có thể lưu 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())

Hãy thử trực tuyến này: https://repl.it/repls/ConcernedHor awesomeHypothesis

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

Hãy thử trực tuyến!

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

Phiên bản không có bản gốc với cùng logic:

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

Hãy thử trực tuyến!

Perl 6, 86 82 byte

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