Şifremi hatırlamak çok zor, bu yüzden bir şifre oluşturmanın bir yolunu buldum.

Şifremi üretme yöntemim şu adımları izleyerek bir kelime veya cümleye dayanıyor:

1. Soldan sağa doğru başlayın

2. Her harfin sayısını bulun

3. Sayısını bir mektubu ile mektubu koymak

   • Tekrarı daha yüksek olan harfler sonunda olacak

   • Aynı tekrarı olan harfler alfabetik olarak sıralanacaktır.

4. Boşluk içeren sayılar ve özel harfler dikkate alınmayacaktır (örneğin 9, 4, @, (, *, vb. Dikkate alınmaz)

5. Görmezden gelinen grup mektupları. Çıktıda, girişteki son olayın durumunu kullanın.

6. Harflerin sayısı herhangi bir sayı olabilir, örneğin 5H17M345K
7. Girdi tüm sayılar veya özel harfler ise, çıktı boş dize olacak, örneğin: "12 $ * 34 ^!" daha sonra "" çıktı
8. Aynı oluşum sırası, alfabetik olarak önemli olmadığında, örneğin 1a1B1c

Örnek:

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

Başka bir örnek:

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

Not: 1 tekrarlı harfler, alfabetik olarak sıralanan başlangıçta, daha sonra tekrarlanan harfler ise

Bu kod golf , en kısa kod kazanır.

Japt v2.0a0 -P, 14 bayt

f\l üv ñÊ®ÌiZÊ

Dene

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 bayt

Kevin Cruijssen sayesinde 1 bayt kaydedildi

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

Çevrimiçi deneyin! veya Test Paketi olarak

açıklama

á                  # 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 # Etkileşimli Derleyici) , 105 bayt

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

Çevrimiçi deneyin!

138 byte'tan 105 byte'e düşürdüğü için teşekkürler.

Perl 6 , 66 63 bayt

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

Çevrimiçi deneyin!

açıklama

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

\P{L}

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

-25 Bayt ve küçük bir hata düzeltme @Neil sayesinde . @Neil ve @Shaggy ile birlikte
-2 bayt .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

Büyük ve küçük harfleri dışında Kaldır her şey:
yani Kitkat Tango 123!→KitkatTango

\P{L}

Sıralama tek tek harfler küçük harf duyarsız ( sayesinde @MartinEnder bunun için ):
yani KitkatTango→aagiKknottT

O$`.
$l$0

Bitişik harfleri durumda duyarsız her yığın tekrarlanan Yakalama:
yani aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Her maç uzunluğunu başa ekleyerek ve sadece her yığın son harfi tutmak:
yani [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Rakamlara göre harfleri ve harf gruplarını sıralayın:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

Bundan sonra sonuç örtük olarak çıktı.

Wolfram Dili (Mathematica) , 102 96 93 87 bayt

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

Çevrimiçi deneyin!

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 bayt

ssrD0m,lded.gr0k@+Gr1G

Burada çevrimiçi deneyin .

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

Düzenleme: Grup öncesi karaktere göre sıralayarak Golf 3 bayt, önceki sürüm: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Düzenleme 2: Herhangi bir siparişten önce çıktısını biçimlendirerek başka bir 2 baytlık golf attı, önceki sürüm: sm+ldedlD.gr0krD0f}r0TGQ

Düzenleme 3: @FryAmTheEggman sayesinde, filtreyi değiştirerek başka bir bayttan golf oynadım. OP, tek bir harfin 9 defadan daha fazla görünebileceğini netleştiğinde bir hatayı düzeltmek zorunda kaldı, bu da tekrar bir bayt ekledi: o (Önceki sürüm:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Genişletilmiş) , 28 bayt ^SBCS

Anonim zımni önek işlevi.

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

Çevrimiçi deneyin!

'\PL' olmayan harfler
⎕R PCRE R ile eplaced
'' boş dizeleri

(… ) Aşağıdaki taktik işlevini uygulayın:

 ⌊ küçük harfli tuşlar ile
 … ⌸ her tuşa ve buna karşılık gelen değerler grubuna,
 ⊢ aşağıdaki argüman işlevini uygulayın :

  (... ) Aşağıdaki zımni fonksiyonunu uygulamak
  ⍤ için
  ⊢ değerler listesinde:

   ⊢/ son değer

   … , Şuna şunu hazırla:

    ⍕ stringification
    ⍤ ait
    ≢ taksitli

   ⊂ kuşat (karakter listesini tek bir dize olarak ele almak için)

 ∊ ε nlist (düzleştirmek)  Bunun kriteri-artan versiyonu
 ⍤
 ∧

Perl 5, 74 68 66 bayt

-6 değişen bayt -piçin -nkullanılarak sayyerine $_=join"", kullanarak abigaille sayesinde bayt -2 \pLyerine[a-z]

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

TIO

59 bayt, en fazla 9 karakterden oluşması durumunda

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

Python 2 , 116 bayt

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

Çevrimiçi deneyin!

Python 3 , 105 bayt

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

Çevrimiçi deneyin!

ArBo'ya -1 teşekkürler .

Haskell , 114/113 105 bayt

^{-9 sayesinde bayt Laikoni (ve liste-kavrayışa (||)yerine filtersahip elemve kısaltmak lengthçirkin kurtulmak için 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

Çevrimiçi deneyin!

Kırmızı , 220 196 206 bayt

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]

Çevrimiçi deneyin!

Bir böcek bulmak için Shaggy teşekkürler.

Jöle , 15 bayt

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

Parolayı belirtilen şekilde basan tam bir program (monadik Bağlantı olarak her biri tam sayı ve karakter içeren listelerin bir listesini verir).

Çevrimiçi deneyin!

Kabuğu , 15 bayt

Kabuğundan kullanırken ithalatı sorun yok, bu nedenle gibi çeşitli kullanışlı fonksiyonlar yararlanabilirler groupOn, sortOn, toLowervb:

ṁ§:osL→ÖLSġÖ_f√

Çevrimiçi deneyin ya da hepsini deneyin!

açıklama

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

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

Çevrimiçi deneyin!

• parseInt(numberAsString, radix)dize başında tamsayı ayrıştırmaya çalışır. Örneğin, parseInt('120px', 10)120 çıkacaktır. Ayrıştırma başarısız olduğunda, bunun NaNyerine geri döner . Biz bir bağlantı '0'onu dönecektir böylece her karakterin başına 0olmayan herhangi bir sayısal-alfa karakterler için. Ve aynı harfleri birlikte ve alfa olmayan karakterleri bu algoritma ile baştan başa sıralayabiliriz.
• Sonra sortve join, "Hello world!123"olacak " !123deHllloorw". Karşı eşleştirme/([a-z])\1*/ig , alfa olmayan karakterleri yok sayar ve dizeyi aynı harflerle topaklara böler. `.
• mapdönüştürme "aaa"için"3a" söz konusu gerektiği gibi.
• İkinci sıralama ilki ile aynı işlevi kullanır. Sayı sistemi sayesinde, beklediğimiz gibi 36 üssünde "3b"olduğundan daha az olurdu "12a": Önce sayıları karşılaştırır ( n div 36), sonra harfi karşılaştırır ( n mod 36).
• Sonunda joinbirlikte onları.

JavaScript (Node.js) , 146 bayt

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

Çevrimiçi deneyin!

Java 10, 223 209 301 bayt

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

9'dan fazla tek harfli girişler için +92 bayt düzeltildi. Bunu farklı bir yaklaşımla tekrar aşağı indirebilir miyim göreceğim.

Çevrimiçi deneyin.

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Swift 4.2.1 / Xcode 10.1 , 1054 1050 1048 370 368 364 bayt

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

Çevrimiçi deneyin!

@KevinCruijssen ayrıca bazı boşlukları kaldırdı.

Kömür , 30 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

Ｆ⌈Ｅβ№↧θι

Küçük harfli alfabeyi çalıştırın ve küçük harfli girişteki en yüksek karakter sayısını bulun. Örtük aralığın üzerinde döngü. (Döngü aslında her yere gider, 0bu n-1yüzden her kullanımda döngü değişkenini arttırmam gerekir.)

Ｆβ

Küçük harfli alfabe üzerinde tekrar dolaşın.

¿⁼№↧θκ⊕ι

Geçerli harfin sayısı, dış döngü değerine eşitse ...

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

Geçerli sayımı, geçerli mektubun son oluşumuyla birleştirin ve örtük olarak yazdırın.

Jöle , 14 bayt

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

Çevrimiçi deneyin!

Tam program

DüğümJS, 299 bayt, -6 bayt teşekkür ederim @tsh

Çok güzel değil ama işe yarıyor!

(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 veya Chrome), 294 bayt, -1ts bayt @tsh

Yeni .flatyöntemle 10 bayt kaydedebilirim:

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

Bunu çevrimiçi deneyin: https://repl.it/repls/ConcernedHorribleHypothesis

R , 131 129 bayt

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

Çevrimiçi deneyin!

Julia 1.0 , 158 bayt

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

Aynı mantıkla orijinal ungolfed versiyonu:

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

Çevrimiçi deneyin!

Perl 6, 86 82 bayt

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