มันยากมากที่จะจำรหัสผ่านของฉันดังนั้นฉันจึงหาวิธีสร้างรหัสผ่านขึ้นมา

วิธีที่ฉันสร้างรหัสผ่านของฉันมาจากคำหรือประโยคโดยทำตามขั้นตอนเหล่านี้:

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 -P, 14 ไบต์

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 ไบต์

บันทึกแล้ว 1 ไบต์ขอบคุณKevin Cruijssen

áΣ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 คอมไพเลอร์) , 105 ไบต์

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

ลองออนไลน์!

ขอบคุณ dana ที่นำมันลงไปที่ 105 ไบต์จาก 138 ไบต์

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ด้วยกัน

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

ลบทุกอย่างยกเว้นตัวอักษรพิมพ์ใหญ่และเล็ก:
ie Kitkat Tango 123!→KitkatTango

\P{L}

จัดเรียงตัวอักษรตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ ( ขอบคุณ@MartinEnderสำหรับสิ่งนี้ ):
ie KitkatTango→aagiKknottT

O$`.
$l$0

จับก้อนกรณีตายทุกตัวอักษรที่อยู่ติดกันซ้ำ:
เช่นaagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

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

แก้ไข: Golfed 3 bytes โดยเรียงตามตัวละครก่อนกลุ่มรุ่นก่อนหน้า: sm+ldedo,lNr0eN.gr0kf}r0TGQ

แก้ไข 2: ตีกอล์ฟอีก 2 ไบต์โดยจัดรูปแบบเอาต์พุตก่อนสั่งซื้อเวอร์ชันก่อนหน้า: sm+ldedlD.gr0krD0f}r0TGQ

แก้ไข 3: Golfed off byte อื่นโดยการเปลี่ยนตัวกรองขอบคุณ @FryAmTheEggman ยังต้องแก้ไขข้อผิดพลาดเมื่อ OP ชี้แจงว่าตัวอักษรเดียวสามารถปรากฏได้มากกว่า 9 ครั้งซึ่งเพิ่มไบต์กลับบน: o (รุ่นก่อนหน้า:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Extended) , 28 ไบต์^SBCS

ฟังก์ชันนำหน้าเงียบโดยไม่ระบุชื่อ

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

ลองออนไลน์!

'\PL' ไม่ใช่
⎕R PCRE R eplaced ด้วย
'' สตริงว่าง

(... ) ใช้ฟังก์ชัน tacit ต่อไปนี้:

 ⌊ ด้วยตัวพิมพ์เล็กเป็นคีย์
 ... ⌸ ใช้ฟังก์ชัน tacit ด้านล่างกับแต่ละคีย์และชุดของค่าที่สอดคล้องกันนั่นคือ
 ⊢ อาร์กิวเมนต์:

  (… ) ใช้ฟังก์ชัน tacit ต่อไปนี้
  ⍤ กับ
  ⊢ รายการค่า:

   ⊢/ ค่าสุดท้าย

   … , เพิ่มรายละเอียดต่อไปนี้:

    ⍕ stringification
    ⍤ ของ
    ≢ การนับ

   ⊂ ใส่ (เพื่อรักษารายชื่อตัวละครเป็นสตริงเดี่ยว)

 ∊ ε 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

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 (ใช้ list-comprehension และ(||)แทนที่filterด้วยelem& shortenlengthเพื่อกำจัดความน่าเกลียด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 ลิงก์จะให้รายการของแต่ละรายการที่มีจำนวนเต็มและอักขระ)

ลองออนไลน์!

Huskขนาด 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'กับจุดเริ่มต้นของตัวละครแต่ละตัวเพื่อให้มันกลับมา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 bytes เป็นตัวแก้ไขสำหรับอินพุตที่มีตัวอักษรมากกว่า 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`

สกาลา , 103 ไบต์

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

ลองออนไลน์!

Swift 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ดังนั้นผมจึงต้องเพิ่มตัวแปร loop ที่ใช้งานแต่ละครั้ง.)

Ｆβ

วนตัวอักษรตัวพิมพ์เล็กอีกครั้ง

¿⁼№↧θκ⊕ι

หากการนับตัวอักษรปัจจุบันเท่ากับค่าลูปนอก ...

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

เชื่อมต่อการนับปัจจุบันกับการเกิดล่าสุดของตัวอักษรปัจจุบันและพิมพ์โดยนัย

เยลลี่ขนาด 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='')

ลองออนไลน์!

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

ฉบับที่ไม่ได้บรรจุด้วยตรรกะเดียวกัน:

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