비밀번호 생성 오는 것입니다. 왼쪽에서 오른쪽으로

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

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

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

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 이에 대한 ) :
KitkatTangoaagiKknottT

O$`.
$l$0

인접한 문자를 대소 문자를 구별의 모든 덩어리를 반복 캡처 :
aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

모든 경기의 길이를 앞에 추가하고, 매 청크의 마지막 문자로 유지 :
즉 [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

숫자를 기준으로 숫자와 문자 그룹을 정렬합니다.
2a1g1i2k1n1o3T1g1i1n1o2a2k3T

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