Bardzo trudno zapamiętać moje hasło, więc wymyśliłem sposób na wygenerowanie hasła.

Generuję moje hasło ze słowa lub zdania, wykonując następujące kroki:

1. Zacznij od lewej do prawej

2. Znajdź liczbę każdej litery

3. Ułóż literę z jej liczbą w kolejności

   • Na końcu pojawią się litery o większej powtarzalności

   • Listy o tym samym powtórzeniu zostaną uporządkowane alfabetycznie

4. Liczby i litery specjalne będą ignorowane, w tym spacje (np. 9, 4, @, (, * itd. Są ignorowane)

5. Grupuj litery ignorując wielkość liter. W danych wyjściowych użyj przypadku ostatniego wystąpienia na wejściu

6. Liczba liter może być dowolną liczbą, np. 5H17M345K
7. Jeśli wejściowe są wszystkie cyfry lub litery specjalne, wówczas wyjściowy będzie pusty ciąg znaków, np. Wpisz „12 $ * 34 ^!” następnie wyślij „”
8. gdy kolejność dla tego samego wystąpienia alfabetycznie nie ma znaczenia, np. 1a1B1c

Przykład:

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

Inny przykład:

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

Uwaga: litery z 1 powtórzeniem są na początku uporządkowane alfabetycznie, a następnie z większą liczbą powtórzeń

To jest code-golf , wygrywa najkrótszy kod.

Japt v2.0a0 -P, 14 bajtów

f\l üv ñÊ®ÌiZÊ

Spróbuj

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 bajtów

Zaoszczędził 1 bajt dzięki Kevinowi Cruijssenowi

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

Wypróbuj online! lub jako pakiet testowy

Wyjaśnienie

á                  # 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 # (interaktywny kompilator Visual C #) , 105 bajtów

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

Wypróbuj online!

Dzięki Dana za zmniejszenie jej do 105 bajtów z 138 bajtów.

Perl 6 , 66 63 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Siatkówka , 67 66 41 39 bajtów

\P{L}

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

-25 bajtów i drobna poprawka dzięki @Neil .
-2 bajty dzięki @Neil i @Shaggy razem.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

Usuń wszystko oprócz wielkich i małych liter:
tj. Kitkat Tango 123!→KitkatTango

\P{L}

Segregowanie poszczególne litery wielkości liter ( dzięki @MartinEnder na to ):
tzn KitkatTango→aagiKknottT

O$`.
$l$0

Uchwycić każdy kawałek wielkości liter wielokrotne sąsiednie litery:
tj aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Poprzedzić długość każdego meczu i tylko zachować ostatnią literę każdego fragmentu:
tj [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Posortuj liczby i grupy liter według liczb:
2a1g1i2k1n1o3T→1g1i1n1o2a2k3T

N`\d+.

Po czym wynik jest dorozumiany.

Wolfram Language (Mathematica) , 102 96 93 87 bajtów

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

Wypróbuj 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 bajtów

ssrD0m,lded.gr0k@+Gr1G

Wypróbuj online tutaj .

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

Edycja: Golfowane 3 bajty, sortując według postaci przed grupą, poprzednia wersja: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edycja 2: Grałem w golfa o kolejne 2 bajty, formatując dane wyjściowe przed złożeniem zamówienia, poprzednia wersja: sm+ldedlD.gr0krD0f}r0TGQ

Edycja 3: Zmieniłem filtr, zmieniając filtr dzięki @FryAmTheEggman. Musiałem również naprawić błąd, gdy OP wyjaśnił, że pojedyncza litera może pojawić się więcej niż 9 razy, co dodało bajt z powrotem na: o (Poprzednia wersja:srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Extended) , 28 bajtów ^SBCS

Anonimowa ukryta funkcja prefiksu.

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

Wypróbuj online!

'\PL' non-Letters
⎕R PCRE R eplaced z
''  pustych strunach

(…)  Zastosuj następującą funkcję ukrytą:

 ⌊ z małymi literami jako klawiszami
 … ⌸ zastosuj poniższą funkcję ukrytą do każdego klawisza i odpowiadającego mu zestawu wartości, a mianowicie
 ⊢  argumentu:

  (… ) Zastosuj następującą ukrytą funkcję
  ⍤ do
  ⊢  listy wartości:

   ⊢/ ostatnia wartość

   … , Wstaw do tego następujące:

    ⍕ stringification
    ⍤ z
    ≢ tally

   ⊂ załącz (traktuj listę znaków jako pojedynczy ciąg)

 ∊ ε nlist (Spłaszczenie)  wersja posortowane rosnąco-tego
 ⍤
 ∧

Perl 5, 74 68 66 bajtów

-6 bajtów zmienia się -pna -ni używa sayzamiast $_=join"", -2 bajtów dzięki Abigail używa \pLzamiast[a-z]

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

TIO

59 bajtów, w przypadku gdy nie ma więcej niż 9 wystąpień każdego znaku

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

Python 2 , 116 bajtów

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

Wypróbuj online!

Python 3 , 105 bajtów

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

Wypróbuj online!

-1 dzięki ArBo .

Haskell , 114/113 105 bajtów

^{-9 bajtów dzięki Laikoni (przy użyciu listy i (||)zamiast filterz elem& shorten, lengthaby pozbyć się brzydkich 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

Wypróbuj online!

Czerwony , 220 196 206 bajtów

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]

Wypróbuj online!

Dzięki Shaggy za znalezienie błędu.

Galaretka , 15 bajtów

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

Pełny program wypisujący hasło zgodnie ze specyfikacją (jako monadyczny link daje listę list zawierających każdą liczbę całkowitą i znak).

Wypróbuj online!

Łuska , 15 bajtów

Żadnych problemów z importu przy użyciu łuskę, więc możemy skorzystać z różnych przydatnych funkcji, takich jak groupOn, sortOn, toLoweritp:

ṁ§:osL→ÖLSġÖ_f√

Wypróbuj online lub wypróbuj je wszystkie!

Wyjaśnienie

ṁ§:(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 bajtów

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

Wypróbuj online!

• parseInt(numberAsString, radix)spróbuje parsować liczbę całkowitą na początku łańcucha. Na przykład parseInt('120px', 10)wyświetli 120. Gdy parsowanie nie powiodło się, zwraca NaNzamiast tego. Łączymy '0'z początkiem każdej postaci, aby ona powróciła0 wszelkie znaki inne niż cyfry. Za pomocą tego algorytmu możemy sortować te same litery razem i znaki inne niż alfa.
• Po sorti join, "Hello world!123"by stać " !123deHllloorw". Dopasowanie do /([a-z])\1*/igzignoruje dowolny znak inny niż alfa i podzieli ciąg na części o takich samych literach. `.
• mapprzekonwertować "aaa"na"3a" wymagane w pytaniu.
• Drugi sort używa tej samej funkcji, co pierwszy. Dzięki systemowi liczbowemu "3b"byłby mniejszy niż "12a"w bazie 36, tak jak się spodziewamy: najpierw porównuje liczby (n div 36 ), a później porównuje literęn mod 36 ).
• Wreszcie joinje razem.

JavaScript (Node.js) , 146 bajtów

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

Wypróbuj online!

Java 10, 223 209 301 bajtów

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 bajtów jako poprawka dla danych wejściowych zawierających więcej niż 9 pojedynczych liter. Zobaczę, czy mogę to jeszcze raz obniżyć, stosując inne podejście.

Wypróbuj online.

Wyjaśnienie:

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 bajty

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

Wypróbuj online!

Swift 4.2.1 / Xcode 10.1 , 1054 1050 1048 370 368 364 bajtów

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

Wypróbuj online!

@KevinCruijssen również usunął niektóre spacje.

Węgiel drzewny , 30 bajtów

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

Wypróbuj online!Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｆ⌈Ｅβ№↧θι

Przeprowadź alfabet małymi literami i znajdź najwyższą liczbę znaków w danych wejściowych pisanych małymi literami. Pętla powyżej domyślnego zakresu. (Pętla faktycznie przechodzi od 0do, n-1więc muszę zwiększać zmienną pętli przy każdym użyciu).

Ｆβ

Ponownie zapętlaj małe litery.

¿⁼№↧θκ⊕ι

Jeśli liczba bieżącej litery jest równa wartości zewnętrznej pętli ...

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

Połącz bieżącą liczbę z ostatnim wystąpieniem bieżącej litery i niejawnie wydrukuj.

Galaretka , 14 bajtów

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

Wypróbuj online!

Pełny program

NodeJS, 299 bajtów, -6 bajtów dzięki @tsh

Nie tak piękna, ale działa!

(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 lub Chrome), 294 bajty, -1 bajt dzięki @tsh

Dzięki nowej .flatmetodzie mogę zapisać 10 bajtów:

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

Spróbuj tego online: https://repl.it/repls/ConcernedHorribleHypotheis

R , 131 129 bajtów

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

Wypróbuj online!

Julia 1.0 , 158 bajtów

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

Oryginalna wersja bez golfa z tą samą logiką:

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

Wypróbuj online!

Perl 6, 86 82 bajtów

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