비밀번호를 기억하기가 매우 어렵 기 때문에 비밀번호를 생성하는 방법을 생각해 냈습니다.

비밀번호를 생성하는 방법은 다음 단계에 따라 단어 나 문장에서 오는 것입니다.

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 번 반복되는 문자는 알파벳순으로 시작된 다음 더 많은 담당자가있는 문자입니다.

이것은 가장 짧은 코드가 승리하는 code-golf 입니다.

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 바이트

Kevin Cruijssen 덕분에 1 바이트 절약

áΣ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 # 대화식 컴파일러) , 105 바이트

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

온라인으로 사용해보십시오!

138 바이트에서 105 바이트로 줄인 dana 덕분입니다.

펄 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+.

@Neil 덕분에 -25 바이트 및 사소한 버그 수정 .
-2 덕분 바이트 @Neil 및 @Shaggy을 함께.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

대문자와 소문자를 제외한 모든 것을 제거하십시오.
즉 Kitkat Tango 123!→KitkatTango

\P{L}

정렬 개별 문자의 대소 문자를 구분 ( 덕분에 @MartinEnder 이에 대한 ) :
예 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 Language (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

편집 : 그룹, 이전 버전 전에 문자별로 순서대로 3 바이트 골프 : sm+ldedo,lNr0eN.gr0kf}r0TGQ

편집 2 : 이전 버전을 주문하기 전에 출력을 형식화하여 다른 2 바이트를 제거했습니다. sm+ldedlD.gr0krD0f}r0TGQ

편집 3 : @FryAmTheEggman 덕분에 필터를 변경하여 다른 바이트를 제거했습니다. 또한 OP가 단일 문자가 9 번 이상 나타날 수 있음을 분명히하여 버그를 수정해야했습니다.srD0m+lded.gr0kf}r0TGQ

APL (Dyalog Extended) , 28 바이트 ^SBCS

익명의 암묵적 접두사 기능.

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

온라인으로 사용해보십시오!

'\PL' 비 문자
⎕R PCRE R은 함께 eplaced
'' 빈 문자열

(… ) 다음 암묵적 기능을 적용하십시오.

 ⌊ 소문자를 키로 사용하여
 … ⌸ 아래의 암묵적 기능을 각 키와 해당 값 세트, 즉
 ⊢ 인수에 적용합니다.

  (… ) 다음의 암묵적 기능
  ⍤ 을
  ⊢ 값 목록에 적용하십시오 .

   ⊢/ 마지막 값

   … 그 , 앞에 다음을 덧붙이십시오.

    ⍕ 문자열 화 (stringification)
    ⍤ 의
    ≢ 집계

   ⊂ 묶음 (문자 목록을 단일 문자열로 처리)

 ∊ ε NLIST (편평한)  그 정렬 - 오름차순 버전
 ⍤
 ∧

펄 5, 74 68 66 바이트

Abigail 대신 -2 바이트 대신 -2 바이트로 변경 -p하여 -n사용say$_=join"",\pL[a-z]

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

TIO

각 문자의 발생이 9 개 이하인 경우 59 바이트

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

파이썬 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()))

온라인으로 사용해보십시오!

파이썬 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)])

온라인으로 사용해보십시오!

ArBo 덕분에 -1 .

하스켈 , 114/113 105 바이트

^{-9 덕분 바이트 Laikoni을 (및 목록-이해를 사용하는 (||)대신 filter에 elem및 단축 length추한 제거하는 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,Ṫ)

지정된대로 비밀번호를 인쇄하는 전체 프로그램 (모나 딕 링크로 각각 정수와 문자를 포함하는 목록 목록을 생성 함).

온라인으로 사용해보십시오!

껍질 , 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"

자바 스크립트 (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'는 각 문자의 시작 부분에 a 를 연결하여 0숫자가 아닌 문자를 반환 합니다. 그리고 우리는이 알고리즘으로 같은 문자를 알파벳이 아닌 문자와 함께 처음부터 정렬 할 수 있습니다.
• sort그리고 후에 join, "Hello world!123"될 것 " !123deHllloorw"입니다. 일치하는 /([a-z])\1*/ig문자는 알파벳이 아닌 문자를 무시하고 문자열을 동일한 문자의 덩어리로 분할합니다. `.
• map변환 "aaa"에 "3a"대한 질문에 필요.
• 두 번째 정렬은 첫 번째 정렬과 동일한 기능을 사용합니다. 숫자 체계 덕분에 예상대로 36 밑 "3b"보다 적을 것 "12a"입니다. 먼저 카운트를 n div 36비교하고 ( n mod 36) 나중에 문자를 비교합니다 ( ).
• 마지막으로 join함께.

자바 스크립트 (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``

온라인으로 사용해보십시오!

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

단일 문자 9 개 이상의 입력에 대한 수정으로 +92 바이트.

온라인으로 사용해보십시오.

설명:

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

온라인으로 사용해보십시오!

신속한 4.2.1 / 엑스 코드 10.1 , 1,054 1,050 1,048 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나는 각각의 사용에서 루프 변수를 증가해야하므로.)

Ｆβ

소문자 알파벳을 다시 반복합니다.

¿⁼№↧θκ⊕ι

현재 문자의 개수가 외부 루프 값과 같은 경우 ...

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

현재 카운트를 현재 문자의 마지막 항목과 연결하고 암시 적으로 인쇄합니다.

젤리 , 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())

자바 스크립트 (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='')

온라인으로 사용해보십시오!

줄리아 1.0 , 158 바이트

¬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

온라인으로 사용해보십시오!

펄 6, 86 82 바이트

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