Sangat sulit untuk mengingat kata sandi saya, jadi saya menemukan cara untuk membuat kata sandi.

Cara saya membuat kata sandi berasal dari kata atau kalimat, mengikuti langkah-langkah ini:

1. Mulai dari kiri ke kanan

2. Temukan hitungan setiap huruf

3. Masukkan surat dengan jumlah di urutan

   • Surat dengan pengulangan yang lebih tinggi pada akhirnya

   • Surat dengan pengulangan yang sama akan dipesan sesuai abjad

4. Angka dan huruf khusus akan diabaikan termasuk spasi putih (mis. 9, 4, @, (, *, dll. Diabaikan)

5. Huruf grup mengabaikan case. Dalam output, gunakan kasus kemunculan terakhir dalam input

6. Hitungan surat bisa berupa angka apa saja, misalnya 5H17M345K
7. Jika input semua angka atau huruf khusus maka output akan menjadi string kosong mis. Input "12 $ * 34 ^!" lalu output ""
8. ketika pesanan untuk kejadian yang sama sesuai abjad tidak masalah misalnya 1a1B1c

Contoh:

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

Contoh lain:

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

Catatan: huruf-huruf dengan 1 repeat berada di urutan awal menurut abjad kemudian huruf-huruf dengan lebih banyak repetisi

Ini kode-golf , kode terpendek yang menang.

Japt v2.0a0 -P, 14 byte

f\l üv ñÊ®ÌiZÊ

Cobalah

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

Disimpan 1 byte berkat Kevin Cruijssen

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

Cobalah online! atau sebagai Test Suite

Penjelasan

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

Cobalah online!

Terima kasih kepada dana untuk membawanya ke 105 byte dari 138 byte.

Perl 6 , 66 63 byte

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

Cobalah online!

Penjelasan

{                                                             }  # 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 dan perbaikan bug kecil berkat @Neil .
-2 byte berkat @ Neil dan @Shaggy bersama-sama.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

Hapus semuanya kecuali huruf besar dan kecil:
ie Kitkat Tango 123!→KitkatTango

\P{L}

Mengurutkan huruf individual tidak peka huruf besar-kecil ( berkat @MartinEnder untuk ini ):
yaitu KitkatTango→aagiKknottT

O$`.
$l$0

Menangkap setiap sepotong case-sensitive berulang huruf yang berdekatan:
yaitu aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Tambahkan panjang setiap pertandingan, dan hanya menyimpan surat terakhir dari setiap potongan:
yaitu [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Sortir angka dan grup surat berdasarkan angka:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

Setelah itu hasilnya adalah output secara implisit.

Bahasa Wolfram (Mathematica) , 102 96 93 87 byte

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

Cobalah 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

Cobalah online di sini .

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

Sunting: Golf 3 byte dengan memesan menurut karakter sebelum grup, versi sebelumnya: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Sunting 2: Memotong 2 byte lainnya dengan memformat output sebelum pemesanan apa pun, versi sebelumnya: sm+ldedlD.gr0krD0f}r0TGQ

Sunting 3: Memotong byte lain dengan mengubah filter, terima kasih kepada @FryAmTheEggman. Juga harus memperbaiki bug ketika OP mengklarifikasi bahwa satu huruf dapat muncul lebih dari 9 kali, yang menambahkan byte kembali pada: o (Versi sebelumnya:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Extended) , 28 byte ^SBCS

Fungsi awalan diam-diam anonim.

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

Cobalah online!

'\PL' non-huruf
⎕R PCRE R di- eplaced dengan
'' string kosong

(... ) terapkan fungsi diam-diam berikut:

 ⌊ dengan huruf kecil sebagai kunci,
 ... ⌸ menerapkan fungsi diam-diam di bawah ini untuk setiap tombol dan sekumpulan nilai yang terkait, yaitu
 ⊢ argumen:

  (... ) terapkan fungsi diam-diam berikut
  ⍤ ke
  ⊢ daftar nilai:

   ⊢/ nilai terakhir

   ... , tambahkan yang berikut ini:

    ⍕ yang stringification
    ⍤ dari
    ≢ penghitungan

   ⊂ terlampir (untuk memperlakukan daftar karakter sebagai string tunggal)

 ∊ ϵ daftar (ratakan)
 ⍤ versi yang
 ∧ diurutkan-naik itu

Perl 5, 74 68 66 byte

-6 byte berubah -pmenjadi -ndan menggunakan saybukan $_=join"", -2 byte berkat Abigail menggunakan \pLbukan[a-z]

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

TIO

59 byte, jika tidak ada lebih dari 9 kemunculan setiap karakter

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

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

Cobalah online!

-1 terima kasih kepada ArBo .

Haskell , 114/113 105 byte

^{-9 byte terima kasih kepada Laikoni (menggunakan daftar-pemahaman dan (||)bukannya filterdengan elem& memendek lengthuntuk menyingkirkan yang jelek 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

Cobalah online!

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

Cobalah online!

Terima kasih kepada Shaggy karena menemukan bug.

Jelly , 15 byte

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

Program lengkap yang mencetak kata sandi seperti yang ditentukan (sebagai Tautan monadik, ia menghasilkan daftar daftar yang masing-masing berisi bilangan bulat dan karakter).

Cobalah online!

Sekam , 15 byte

Tidak ada masalah dengan impor saat menggunakan sekam, oleh karena itu kita dapat menggunakan berbagai fungsi berguna seperti groupOn, sortOn, toLowerdll:

ṁ§:osL→ÖLSġÖ_f√

Cobalah online atau coba semuanya!

Penjelasan

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

Cobalah online!

• parseInt(numberAsString, radix)akan mencoba mengurai integer di awal string. Sebagai contoh, parseInt('120px', 10)akan menghasilkan 120. Ketika parsing gagal, itu kembali NaNsebagai gantinya. Kami menyambungkan '0'ke awal setiap karakter sehingga akan kembali 0untuk karakter alfa non numerik. Dan kita dapat mengurutkan huruf yang sama bersama-sama dan karakter non-alfa ke awal dengan algoritma ini.
• Setelah sortdan join, "Hello world!123"akan menjadi " !123deHllloorw". Pencocokan terhadap /([a-z])\1*/igakan mengabaikan karakter non-alfa dan membagi string menjadi potongan-potongan dengan huruf yang sama. `.
• mapdikonversi "aaa"menjadi "3a"seperti yang diminta dalam pertanyaan.
• Jenis kedua menggunakan fungsi yang sama seperti yang pertama. Berkat sistem bilangan, "3b"akan lebih sedikit dari "12a"pada basis 36 seperti yang kami harapkan: Ini membandingkan jumlah pertama ( n div 36), dan membandingkan surat kemudian ( n mod 36).
• Akhirnya joinmereka bersama.

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

Cobalah 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 sebagai perbaikan untuk input dengan lebih dari 9 huruf tunggal .. Akan lihat apakah saya dapat menurunkannya lagi dengan pendekatan yang berbeda.

Cobalah online.

Penjelasan:

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

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

Cobalah online!

@KevinCruijssen juga menghapus beberapa spasi.

Arang , 30 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

Ｆ⌈Ｅβ№↧θι

Jalankan melalui alfabet huruf kecil dan temukan jumlah karakter tertinggi dalam input huruf kecil. Ulangi rentang implisit. (Loop benar-benar pergi dari 0ke n-1jadi saya harus kenaikan variabel loop pada setiap penggunaan.)

Ｆβ

Ulangi lagi huruf kecil.

¿⁼№↧θκ⊕ι

Jika jumlah huruf saat ini sama dengan nilai loop luar ...

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

Gabungkan hitungan saat ini dengan kemunculan huruf terakhir saat ini dan cetak secara implisit.

Jelly , 14 byte

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

Cobalah online!

Program lengkap.

NodeJS, 299 byte, -6 byte terima kasih kepada @tsh

Tidak begitu cantik tapi berhasil!

(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 atau Chrome), 294 byte, -1 byte terima kasih kepada @tsh

Dengan .flatmetode baru , saya dapat menyimpan 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())

Coba ini secara 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='')

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

Versi ungolfed asli dengan logika yang sama:

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

Cobalah online!

Perl 6, 86 82 byte

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