Generiere ein Passwort

26

Es ist sehr schwer, sich mein Passwort zu merken, deshalb habe ich mir eine Möglichkeit ausgedacht, ein Passwort zu generieren.

So generiere ich mein Passwort aus einem Wort oder einem Satz:

  1. Beginnen Sie von links nach rechts

  2. Ermitteln Sie die Anzahl der einzelnen Buchstaben

  3. Bringe den Buchstaben mit seiner Zählung in eine Reihenfolge

    • Briefe mit höherer Wiederholung werden am Ende sein

    • Buchstaben mit der gleichen Wiederholung werden alphabetisch sortiert

  4. Zahlen und Sonderzeichen einschließlich Leerzeichen werden ignoriert (z. B. 9, 4, @, (, * usw. werden ignoriert)

  5. Gruppenbuchstaben ignorieren Groß- und Kleinschreibung. Verwenden Sie in der Ausgabe den Fall des letzten Vorkommens in der Eingabe

  6. Die Anzahl der Buchstaben kann eine beliebige Zahl sein, z. B. 5H17M345K
  7. Wenn es sich bei der Eingabe um alle Zahlen oder Sonderzeichen handelt, ist die Ausgabe eine leere Zeichenfolge, z. B. Eingabe "12 $ * 34 ^!" dann "" ausgeben
  8. wenn die Reihenfolge für dasselbe Vorkommen in alphabetischer Reihenfolge keine Rolle spielt, z. B. 1a1B1c

Beispiel:

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

Ein anderes Beispiel:

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

Hinweis: Die Buchstaben mit 1 Wiederholung sind am Anfang alphabetisch geordnet, danach die Buchstaben mit mehr Wiederholungen

Dies ist , der kürzeste Code gewinnt.

asmgx
quelle
16
Kann ein Buchstabe mehr als neunmal vorkommen?
Shaggy
3
@manatwork: Aber das ist nicht unklar (beachten Sie, dass bei der Beantwortung nicht angenommen wurde, dass Buchstaben weniger als zehn Mal vorkommen). Es wird lediglich versucht, die Eingabebeschränkungen zu lockern.
18.
4
Stellen Sie sicher, dass Sie diese Erläuterungen zum eigentlichen Fragenkörper hinzufügen, damit die Antwortenden die Kommentare nicht durchgehen müssen
Jo King,
2
Kommentare stellen keine Spezifikation dar. Sie müssen die Herausforderung aktualisieren, 1.um mindestens einen Testfall hinzuzufügen, der mehr als 9 Vorkommen von einem oder mehreren Buchstaben enthält. 2.Geben Sie an, dass die Ausgabe eine Zeichenfolge sein muss (obwohl ich dringend davon abraten würde, so streng zu sein; dies fügt der Herausforderung nichts hinzu ), 3.geben Sie an, dass Eingaben ohne Buchstaben verarbeitet werden müssen, und 4.klären Sie, ob eine leere Zeichenfolge als Eingabe verarbeitet werden muss.
Shaggy
1
Sobald Sie dies getan haben, müssen Sie alle vorhandenen Lösungen testen und informieren, wenn Änderungen erforderlich sind. Ich habe bereits eine ganze Reihe von Lösungen gefunden, die auf den Punkt scheitern 1. In Zukunft können Sie auch unsere Sandbox verwenden , um Probleme wie diese auszubügeln, bevor Sie eine Herausforderung veröffentlichen.
Shaggy

Antworten:

7

Japt v2.0a0 -P, 14 Bytes

f\l üv ñÊ®ÌiZÊ

Versuch es

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"
Zottelig
quelle
10

05AB1E , 19 17 16 Bytes

Dank Kevin Cruijssen 1 Byte gespeichert

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

Probieren Sie es online! oder als Testsuite

Erläuterung

á                  # 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
Emigna
quelle
Sie können ein Byte speichern, indem Sie das (Pair with) in ein «(Concat / Merge) ändern, also eines der beidenJ s (Joins) entfernt werden kann.
Kevin Cruijssen
@ KevinCruijssen: Wow. Ich fühle mich jetzt dumm :) Warum bin ich nicht einfach Jumgezogen? Bearbeiten: Eigentlich brauchte ich sie als Paar in der 19-Byte-Version und ich dachte nicht daran, es zu ändern, als ich die 17 machte: P
Emigna
JAbhängig von der Antwort auf diese Frage ist
Shaggy,
7

Perl 6 , 66 63 Bytes

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

Probieren Sie es online!

Erläuterung

{                                                             }  # 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
nwellnhof
quelle
6

Retina , 67, 66, 41 39 Bytes

\P{L}

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

-25 Bytes und ein kleiner Bugfix dank @Neil .
-2 Bytes dank @Neil und @Shaggy zusammen.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Entfernen Sie alles außer Groß- und Kleinbuchstaben:
dh Kitkat Tango 123!KitkatTango

\P{L}

Sortieren Sie die einzelnen Buchstaben ohne Berücksichtigung der Groß- / Kleinschreibung ( danke an @MartinEnder dafür ):
dh KitkatTangoaagiKknottT

O$`.
$l$0

Erfassen Sie jedes Stück von Groß- und Kleinschreibung wiederholten benachbarte Buchstaben:
dh aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Prepend die Länge jedes Spiel, und halten nur den letzten Buchstaben eines jeden Brocken:
dh [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Sortieren Sie die Zahlen- und Buchstabengruppen nach den Zahlen:
2a1g1i2k1n1o3T1g1i1n1o2a2k3T

N`\d+.

Danach wird das Ergebnis implizit ausgegeben.

Kevin Cruijssen
quelle
Bist du sicher, dass das ein Fehler ist? Wird nicht nur lexikografisch sortiert? ( "aA" < "aa")
Shaggy
1
@ Shaggy Ich bin mir nicht sicher, ob es geht. Weil die \wund .in verwendet O`\w.wurden, um anzuzeigen, dass wir Zeichenpaare sortieren. Wir sind uns nicht sicher, ob wir jedes Zeichenpaar sortieren können, sondern sortieren es nur basierend auf dem ersten Zeichen. Aber na ja, Martins Vorschlag, die einzelnen Zeichen nach Substitutionen zu sortieren (dies ist die Kleinbuchstabenvariante des Spiels), wirkt wie ein Zauber. :)
Kevin Cruijssen
1
Kann es in 41 Bytes gemacht werden oder fehle ich etwas?
Neil
2
@Shaggy Eigentlich weiterlesen, \P{L}könnte funktionieren, was 2 Bytes spart.
Neil
4

Wolfram Language (Mathematica) , 102 96 93 87 Bytes

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

Probieren Sie es 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.
Lirtosiast
quelle
4

Pyth, 27 24 22 Bytes

ssrD0m,lded.gr0k@+Gr1G

Probieren Sie es hier online aus .

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

Bearbeiten: 3 Bytes nach Zeichen vor Gruppe sortiert, Vorgängerversion: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edit 2: Weitere 2 Bytes durch Formatieren der Ausgabe vor einer Bestellung entfernt, vorherige Version: sm+ldedlD.gr0krD0f}r0TGQ

Edit 3: Durch Ändern des Filters dank @FryAmTheEggman ein weiteres Byte herausgefiltert. Außerdem musste ein Fehler behoben werden, als OP klarstellte, dass ein einzelner Buchstabe mehr als neunmal vorkommen kann, wodurch ein Byte wieder hinzugefügt wurde am: o (Vorgängerversion:srD0m+lded.gr0kf}r0TGQ

Sok
quelle
@FryAmTheEggman toller Anruf, danke!
Sok
4

APL (Dyalog Extended) , 28 Byte SBCS

Anonyme implizite Präfixfunktion.

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

Probieren Sie es online!

'\PL' Nicht-Buchstaben
⎕R PCRE R eplaced mit
'' leeren Saiten

() Wenden folgende stillschweigende Funktion an:

 Mit dem Kleinbuchstaben als Schlüssel
 …  wenden Sie die folgende implizite Funktion auf jeden Schlüssel und die entsprechende Menge von Werten an, nämlich
 das Argument:

  () Wenden Sie die folgende implizite Funktion
   auf
   die Werteliste an:

   ⊢/ der letzte Wert

   … , Dem Folgendes voranstellen:

     die stringification
     von
     Tally

    einschließen (um die Zeichenliste als einzelne Zeichenfolge zu behandeln)

ϵ nliste (verflache)
 die
 aufsteigend sortierte Version davon

Adam
quelle
1
@ Shaggy Danke. Festgelegt auf +1 Byte.
Am
3

Perl 5, 74 68 66 Bytes

-6 Bytes ändern sich -pzu -nund verwenden saystatt $_=join"", -2 Bytes dank Abigail verwenden \pLstatt[a-z]

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

TIO

59 Bytes, falls nicht mehr als 9 Zeichen vorkommen

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{lc$a cmp lc$b}values%h
Nahuel Fouilleul
quelle
@Abigail, danke, im zweiten Programm war es ein Versehen nach dem Update
Nahuel Fouilleul
3

Python 2 , 116 Bytes

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

Probieren Sie es online!

TFeld
quelle
Die Ausgabe für Database Partitions Taskist nicht gleich1b1D1e1k1n1o1P1r2i3s4T5a
mdahmoune
@mdahmoune danke, sollte behoben werden.
TFeld
In the output, use the case of the last occurrence in the inputdu wirst rfindstattdessen dafür brauchen find. ...] forkann aber werden ...]for, um das auszugleichen.
ArBo
3

Haskell , 114/113, 105 Bytes

-9 Bytes dank Laikoni (mit Listenverständnis und (||)statt filtermit elem& kürzen length, um hässlich loszuwerden 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

Probieren Sie es online!

ბიმო
quelle
107 Bytes: Probieren Sie es online!
Laikoni
1
105: Online ausprobieren!
Laikoni
@Laikoni: Jetzt kürzer als bei Importen, sehr schön !!
19.
3

Rot , 220 196 206 Bytes

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]

Probieren Sie es online!

Vielen Dank an Shaggy für das Auffinden eines Fehlers.

Galen Ivanov
quelle
1
@ Shaggy Danke für den Hinweis, ich werde versuchen, es zu beheben.
Galen Ivanov
2

Gelee , 15 Bytes

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

Ein vollständiges Programm, das das angegebene Passwort druckt (als monadischer Link gibt es eine Liste von Listen aus, die jeweils eine Ganzzahl und ein Zeichen enthalten).

Probieren Sie es online!

Jonathan Allan
quelle
2

Schale , 15 Bytes

Keine Probleme mit der Einfuhr , wenn Husk verwenden, deshalb können wir den Einsatz der verschiedenen praktischen Funktionen wie machen groupOn, sortOn, toLoweretc:

ṁ§:osL→ÖLSġÖ_f√

Probieren Sie es online aus oder probieren Sie sie alle aus!

Erläuterung

ṁ§:(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"
ბიმო
quelle
2

JavaScript (Node.js) , 127 Byte

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

Probieren Sie es online!

  • parseInt(numberAsString, radix)versucht, eine Ganzzahl am Anfang der Zeichenfolge zu analysieren. Beispielsweise parseInt('120px', 10)wird 120 ausgegeben. Wenn das Parsen fehlgeschlagen ist, wird NaNstattdessen zurückgegeben. Wir verbinden ein '0'mit dem Anfang jedes Zeichens, damit es 0für alle nicht numerisch-alphanumerischen Zeichen zurückgegeben wird. Und wir können durch diesen Algorithmus dieselben Buchstaben und Nicht-Alpha-Zeichen an den Anfang sortieren.
  • Nach sortund join, "Hello world!123"würde " !123deHllloorw". Bei einem Abgleich mit /([a-z])\1*/igwird jedes Nicht-Alpha-Zeichen ignoriert und die Zeichenfolge in Abschnitte mit denselben Buchstaben aufgeteilt. `.
  • mapkonvertieren "aaa"nach "3a"wie in der frage erforderlich.
  • Die zweite Sortierung verwendet dieselbe Funktion wie die erste. Dank des Zahlensystems "3b"wäre es weniger als "12a"in Basis 36, so wie wir es erwarten: Es wird zuerst die Anzahl verglichen ( n div 36) und später der Buchstabe verglichen (n mod 36 ).
  • Endlich joinsie zusammen.

JavaScript (Node.js) , 146 Byte

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

Probieren Sie es online!

tsh
quelle
Warum nicht die kürzere Lösung als Hauptlösung einreichen? Es kann auch 2 Bytes kürzer sein, da es nicht rekursiv ist.
Shaggy
@ Shaggy Ah, total vergessen zu entfernen f=. Der erste war früher kürzer. Es werden jedoch 4 Bytes mehr ausgegeben, da OP gefragt hat, ob die Ausgabe eine leere Zeichenfolge sein darf. Und ich habe sie einfach dort
gelassen
1
@ Shaggy OK, finde heraus, dass der zweite vielleicht noch kürzer ist. Und ich habe es als erstes platziert.
Dienstag,
2

Java 10, 223 209 301 Bytes

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 als Fehlerbehebung für Eingaben mit mehr als 9 Buchstaben. Mal sehen, ob ich das mit einem anderen Ansatz wieder reduzieren kann.

Probieren Sie es online aus.

Erläuterung:

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`
Kevin Cruijssen
quelle
1
@ Shaggy Dang .. behoben auf den Preis von 92 Bytes ..>. <Mal sehen, ob ich es wieder runter spielen kann, indem ich keinen Komparator zum Sortieren benutze, sondern später selbst manuell sortiere ..
Kevin Cruijssen
Autsch! Das tut mir leid!
Shaggy
2

Scala , 103 Bytes

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

Probieren Sie es online!

hucko
quelle
2

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

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

Probieren Sie es online!

@ KevinCruijssen entfernt auch einige Leerzeichen.

Roman Podymov
quelle
Hallo, willkommen bei PPCG! Ich kenne Swift nicht, aber Sie haben anscheinend vergessen, einige Leerzeichen zu entfernen, und Sie können auch alle falsenach 0>1und truenach Golf spielen 1>0. Probieren Sie es online aus 1027 Bytes . Wahrscheinlich können Sie mehr Golf spielen, wie das Duplizierte, dasif let v=$0.key.escaped(asASCII:0>1).lowercased().unicodeScalars.first?.value{return v<$1.key.value}else{return 0>1}Sie haben, aber das überlasse ich jemandem, der Swift tatsächlich kennt.
Kevin Cruijssen
1
Auch wenn Sie es noch nicht gesehen haben: Tipps zum Golfen in <allen Sprachen> und Tipps zum Golfen in Swift könnten interessant sein, durchzulesen. Nochmals herzlich willkommen und genießen Sie Ihren Aufenthalt! :)
Kevin Cruijssen
Hallo @ KevinCruijssen. Danke für Tipps, die ich entfernt trueund falseaus meiner Antwort entfernt habe.
Roman Podymov
1
Schön, Sie haben von Ihren anfänglichen 1000+ Bytes ziemlich viel Golf gespielt. :) Ich sehe 6 weitere Leerzeichen, die nach / vor allen =Zuweisungen entfernt werden können: Probieren Sie es online 364 Bytes . Genieße deinen Aufenthalt! :)
Kevin Cruijssen
1

Kohle , 30 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

F⌈Eβ№↧θι

Durchsuche das Kleinbuchstaben und finde die höchste Zeichenanzahl in der Eingabe in Kleinbuchstaben. Schleife über den impliziten Bereich. (Die Schleife geht tatsächlich von 0nach, n-1so dass ich die Schleifenvariable bei jeder Verwendung erhöhen muss.)

Fβ

Bewegen Sie sich erneut über das Kleinbuchstaben.

¿⁼№↧θκ⊕ι

Wenn die Anzahl der aktuellen Buchstaben gleich dem Wert der äußeren Schleife ist ...

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

Verketten Sie die aktuelle Anzahl mit dem letzten Vorkommen des aktuellen Buchstabens und drucken Sie implizit.

Neil
quelle
1

NodeJS, 299 Bytes, -6 Bytes, danke an @tsh

Nicht so schön, aber es funktioniert!

(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 oder Chrome), 294 Byte, -1 Byte danke an @tsh

Mit der neuen .flatMethode kann ich 10 Bytes sparen:

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

Versuchen Sie dies online: https://repl.it/repls/ConcernedHorribleHypothesis

Chau Giang
quelle
Hallo und willkommen bei PPCG. Es wäre schön, wenn Sie eine Möglichkeit zur Verfügung stellen würden, Ihre Einreichung zu testen, z. B. einen Link zu einem Online-Dolmetscher.
Jonathan Frech
@ JonathanFrech Ich habe gerade Testfälle hinzugefügt, danke!
Chau Giang
.replacex 3 mal -> [R='replace]und [R]x 2 mal
tsh
.charCodeAt(0)-> .charCodeAt()( 0Standardeinstellung)
Dienstag,
@tsh Vielen Dank für all deine guten Tipps, ich habe gerade meine Antwort aktualisiert!
Chau Giang
1

R , 131 129 Bytes

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

Probieren Sie es online!

digEmAll
quelle
1

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

Original ungolfed version mit der gleichen 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

Probieren Sie es online!

niczky12
quelle
0

Perl 6, 86 82 Bytes

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