Générez un mot de passe


26

Il est très difficile de se souvenir de mon mot de passe, j'ai donc trouvé un moyen de générer un mot de passe.

La façon dont je génère mon mot de passe est à partir d'un mot ou d'une phrase, en suivant ces étapes:

  1. Partir de gauche à droite

  2. Trouvez le nombre de chaque lettre

  3. Mettre une lettre avec son nombre dans une commande

    • Les lettres avec une répétition plus élevée seront finalement

    • Les lettres avec la même répétition seront classées par ordre alphabétique

  4. Les chiffres et les lettres spéciales seront ignorés, y compris les espaces (par exemple, 9, 4, @, (, *, etc. sont ignorés)

  5. Lettres de groupe ignorant la casse. Dans la sortie, utilisez le cas de la dernière occurrence dans l'entrée

  6. Le nombre de lettres peut être n'importe quel nombre, par exemple 5H17M345K
  7. Si l'entrée est composée uniquement de chiffres ou de lettres spéciales, la sortie sera une chaîne vide, par exemple Entrée "12 $ * 34 ^!" puis sortez ""
  8. lorsque l'ordre pour la même occurrence par ordre alphabétique n'a pas d'importance, par exemple 1a1B1c

Exemple:

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

Un autre exemple:

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

Remarque: les lettres avec 1 répétition sont au début classées par ordre alphabétique puis les lettres avec plus de répétitions

C'est le , le code le plus court l'emporte.


16
Une lettre peut-elle apparaître plus de 9 fois?
Shaggy

3
@manatwork: Mais ce n'est pas clair (notez, leur réponse ne supposait pas que les lettres apparaissent moins de 10 fois), il essaie simplement de desserrer les restrictions de saisie.
ბიმო

4
assurez-vous d'ajouter ces clarifications au corps de la question, afin que les répondeurs n'aient pas à parcourir les commentaires
Jo King

2
Les commentaires ne constituent pas une spécification. Vous devez mettre à jour le défi pour 1.ajouter au moins 1 cas de test qui comprend plus de 9 occurrences d'une ou plusieurs lettres, 2.spécifier que la sortie doit être une chaîne (bien que je déconseille fortement d'être aussi strict; cela n'ajoute rien au défi ), 3.spécifiez que nous devons être en mesure de gérer les entrées ne contenant pas de lettres et 4.clarifiez si nous devons ou non gérer une chaîne vide en entrée.
Shaggy

1
Une fois que vous avez fait cela, vous devrez alors tester toutes les solutions existantes et les informer si elles doivent apporter des modifications. J'ai déjà trouvé pas mal de solutions qui échouent sur le point 1. De plus, à l'avenir, vous pourriez envisager d'utiliser notre bac à sable pour essayer de résoudre des problèmes comme ceux-ci avant de publier un défi.
Shaggy

Réponses:


7

Japt v2.0a0 -P, 14 octets

f\l üv ñÊ®ÌiZÊ

Essayez-le

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"

10

05AB1E , 19 17 16 octets

1 octet enregistré grâce à Kevin Cruijssen

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

Essayez-le en ligne! ou comme suite de tests

Explication

á                  # 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

Vous pouvez enregistrer un octet en changeant le (paire avec) en «(concat / fusion), de sorte que l'un des deux Js (jointures) puisse être supprimé.
Kevin Cruijssen

@KevinCruijssen: Wow. Je me sens stupide maintenant :) Pourquoi n'ai-je pas simplement bougé un Jintérieur? Edit: En fait, j'en avais besoin en tant que paire dans la version 19 octets et je n'ai pas pensé à le changer quand j'ai fait celui de 17: P
Emigna

Vous pourriez être en mesure de laisser tomber le deuxième Join, selon la réponse à cette question
Shaggy


7

Perl 6 , 66 63 octets

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

Essayez-le en ligne!

Explication

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

6

Rétine , 67 66 41 39 octets

\P{L}

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

-25 octets et correction d'un bug mineur grâce à @Neil .
-2 octets grâce à @Neil et @Shaggy ensemble.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

Supprimez tout sauf les lettres majuscules et minuscules:
ie Kitkat Tango 123!KitkatTango

\P{L}

Trier les lettres individuelles insensibles à la casse ( merci à @MartinEnder pour cela ):
ie KitkatTangoaagiKknottT

O$`.
$l$0

Capturez chaque morceau de la casse des lettres adjacentes répétées: à
savoir aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Préfixer par la longueur de chaque match, et ne garder que la dernière lettre de chaque morceau:
soit [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Triez les chiffres et les groupes de lettres en fonction des chiffres:
2a1g1i2k1n1o3T1g1i1n1o2a2k3T

N`\d+.

Après quoi, le résultat est implicitement émis.


Êtes-vous sûr que c'est un bug? N'est-ce pas seulement un tri lexicographique? ( "aA" < "aa")
Shaggy

1
@Shaggy Je ne sais pas si c'est possible. Parce que le \wet .le O`\w.ont été utilisés pour indiquer que nous trions des paires de caractères. Je ne sais pas si nous pouvons trier chaque paire de caractères, mais uniquement en fonction du premier caractère. Mais bon, la suggestion de Martin de trier chaque personnage en fonction d'une substitution (qui est la variante minuscule de la correspondance) fonctionne comme un charme. :)
Kevin Cruijssen

1
Peut-il être fait en 41 octets ou ai-je raté quelque chose?
Neil


2
@Shaggy En fait, une lecture plus approfondie \P{L}pourrait fonctionner, ce qui économise 2 octets.
Neil

4

Langue Wolfram (Mathematica) , 102 96 93 87 octets

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

Essayez-le en ligne!

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.

4

Pyth, 27 24 22 octets

ssrD0m,lded.gr0k@+Gr1G

Essayez-le en ligne ici .

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

Edit: Golfé 3 octets par ordre de caractère avant groupe, version précédente: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edit 2: Golfed off 2 octets supplémentaires en formatant la sortie avant toute commande, version précédente: sm+ldedlD.gr0krD0f}r0TGQ

Edit 3: Golfé d'un autre octet en changeant le filtre, grâce à @FryAmTheEggman. A également dû corriger un bogue lorsque OP a précisé qu'une seule lettre peut apparaître plus de 9 fois, ce qui a ajouté un octet à: o (Version précédente:srD0m+lded.gr0kf}r0TGQ


@FryAmTheEggman grand appel, merci!
Sok

4

APL (Dyalog Extended) , 28 octets SBCS

Fonction de préfixe tacite anonyme.

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

Essayez-le en ligne!

'\PL' non-lettres
⎕R PCRE R remplacées par
'' des chaînes vides

() Appliquez la fonction tacite suivante:

 avec les minuscules comme clés,
 …  appliquez la fonction tacite ci-dessous à chaque clé et à son ensemble de valeurs correspondant, à savoir
 l'argument:

  () Appliquer la fonction tacite suivante
   à
   la liste de valeurs:

   ⊢/ la dernière valeur

   … , Ajoutez ce qui suit à cela:

     la stringification
     du
     décompte

    entourer (pour traiter la liste de caractères comme une chaîne unique)

ε nlist (Aplatir)
 la
 Version tri-croissant de cette


1
@Shaggy Merci. Fixé à +1 octet.
Adám

3

Perl 5, 74 68 66 octets

-6 octets passant -pà -net utilisant sayau lieu de $_=join"", -2 octets grâce à Abigail utilisant \pLau lieu de[a-z]

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

TIO

59 octets, au cas où il n'y aurait pas plus de 9 occurrences de chaque caractère

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

@Abigail, merci, dans le deuxième programme c'était un oubli après mise à jour
Nahuel Fouilleul

3

Python 2 , 116 octets

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

Essayez-le en ligne!


La sortie pour Database Partitions Taskn'est pas égale à1b1D1e1k1n1o1P1r2i3s4T5a
mdahmoune

@mdahmoune merci, devrait être corrigé.
TFeld

In the output, use the case of the last occurrence in the inputvous aurez besoin rfindau lieu de findcela. ...] forpeut devenir ...]forpour compenser cela cependant.
ArBo


3

Haskell , 114/113 105 octets

-9 octets grâce à Laikoni ( en utilisant la liste-compréhension et au (||)lieu de filteravec elemet raccourcir lengthpour se débarrasser de laid 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

Essayez-le en ligne!




@Laikoni: Maintenant plus court qu'avec les importations, très sympa !!
ბიმო

3

Rouge , 220 196 206 octets

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]

Essayez-le en ligne!

Merci à Shaggy d'avoir trouvé un bug.


1
@Shaggy Merci de l'avoir signalé, je vais essayer de le réparer.
Galen Ivanov


2

Husk , 15 octets

Aucun problème avec les importations lors de l' utilisation Husk, nous pouvons donc utiliser les différentes fonctions pratiques telles que groupOn, sortOn, toLoweretc:

ṁ§:osL→ÖLSġÖ_f√

Essayez-le en ligne ou essayez-les tous!

Explication

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

2

JavaScript (Node.js) , 127 octets

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

Essayez-le en ligne!

  • parseInt(numberAsString, radix)va essayer d'analyser un entier au début de la chaîne. Par exemple, parseInt('120px', 10)affichera 120. Lorsque l'analyse a échoué, elle revient à la NaNplace. Nous connectons un '0'au début de chaque caractère afin qu'il revienne 0pour tout caractère non numérique-alpha. Et nous pouvons trier les mêmes lettres ensemble et les caractères non alpha au début par cet algorithme.
  • Après sortet join, "Hello world!123"deviendrait " !123deHllloorw". Une contre-correspondance /([a-z])\1*/igignorera tout caractère non alpha et divisera la chaîne en morceaux avec les mêmes lettres. ".
  • mapconvertir "aaa"au "3a"besoin dans la question.
  • Le deuxième tri utilise la même fonction que le premier. Grâce au système numérique, ce "3b"serait moins qu'en "12a"base 36 comme on s'y attend: il compare d'abord les décomptes ( n div 36), et compare la lettre plus tard ( n mod 36).
  • Enfin join, ensemble.

JavaScript (Node.js) , 146 octets

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

Essayez-le en ligne!


Pourquoi ne pas soumettre la solution la plus courte comme solution principale? En outre, il peut être 2 octets plus court car il n'est pas récursif.
Shaggy

@Shaggy Ah, totalement oublié de supprimer f=. Le premier était plus court. Mais il obtient 4 octets de plus car OP a demandé que la sortie soit une chaîne vide. Et je les ai juste gardés là ...
tsh

1
@Shaggy OK, découvrez simplement que le second peut être encore plus court. Et je l'ai placé comme premier.
tsh

2

Java 10, 223 209 301 octets

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 octets comme correctif pour les entrées avec plus de 9 d'une seule lettre .. Je verrai si je peux redescendre avec une approche différente.

Essayez-le en ligne.

Explication:

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`

1
@Shaggy Dang .. fixé au prix de 92 octets ..>. <Je vais voir si je peux le jouer à nouveau en n'utilisant pas de comparateur pour trier mais trier manuellement moi-même plus tard ..
Kevin Cruijssen

Aie! Désolé pour ça!
Shaggy


2

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

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

Essayez-le en ligne!

@KevinCruijssen a également supprimé certains espaces.


Salut, bienvenue chez PPCG! Je ne connais pas Swift, mais il semble que vous ayez oublié de supprimer certains espaces, et vous pouvez également jouer falseau golf de 0>1et truevers 1>0. Essayez-le en ligne 1027 octets . Il y a probablement beaucoup plus de golf, comme le double que if let v=$0.key.escaped(asASCII:0>1).lowercased().unicodeScalars.first?.value{return v<$1.key.value}else{return 0>1}vous avez, mais je laisse cela à quelqu'un qui connaît Swift.
Kevin Cruijssen

1
De plus, si vous ne l'avez pas encore vu: les conseils pour jouer au golf dans <toutes les langues> et les conseils pour jouer au golf dans Swift peuvent être intéressants à lire. Encore une fois bienvenue, et profitez de votre séjour! :)
Kevin Cruijssen

Bonjour @KevinCruijssen. Merci pour les conseils, j'ai supprimé trueet falsede ma réponse.
Roman Podymov

1
Bien, vous l'avez beaucoup joué depuis vos 1000+ octets initiaux. :) Je vois 6 autres espaces qui peuvent être supprimés après / avant toutes les =affectations: essayez-le en ligne 364 octets . Profitez de votre séjour! :)
Kevin Cruijssen

1

Fusain , 30 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

F⌈Eβ№↧θι

Parcourez l'alphabet en minuscules et trouvez le nombre de caractères le plus élevé dans l'entrée en minuscules. Boucle sur la plage implicite. (La boucle va de 0à, n-1donc je dois incrémenter la variable de boucle à chaque utilisation.)

Fβ

Parcourez à nouveau l'alphabet minuscule.

¿⁼№↧θκ⊕ι

Si le nombre de la lettre actuelle est égal à la valeur de la boucle externe ...

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

Concaténez le nombre actuel avec la dernière occurrence de la lettre actuelle et imprimez implicitement.



1

NodeJS, 299 octets, -6 octets grâce à @tsh

Pas si beau mais ça marche!

(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 ou Chrome), 294 octets, -1 octet merci à @tsh

Avec une nouvelle .flatméthode, je peux économiser 10 octets:

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

Essayez ceci en ligne: https://repl.it/repls/ConcernedHorribleHypothesis


Bonjour et bienvenue chez PPCG. Ce serait bien si vous fournissiez un moyen de tester votre soumission, comme un lien vers un interprète en ligne.
Jonathan Frech

@JonathanFrech Je viens d'ajouter des cas de test, merci!
chau giang

.replacex 3 fois -> [R='replace]et [R]x 2 fois
tsh

.charCodeAt(0)-> .charCodeAt()( 0par défaut)
tsh

@tsh Merci beaucoup pour tous vos bons conseils, je viens de mettre à jour ma réponse!
chau giang

1

R , 131 129 octets

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

Essayez-le en ligne!


1

Julia 1.0 , 158 octets

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

Version originale non golfée avec la même logique:

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

Essayez-le en ligne!


0

Perl 6, 86 82 octets

{[~] flat map *[0,2],sort map {+$^b,$^a,$b[*-1]},kv classify &lc,.comb: /<alpha>/}
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.