Generar una contraseña

26

Es muy difícil recordar mi contraseña, así que se me ocurrió una forma de generar una contraseña.

La forma en que genero mi contraseña es a partir de una palabra o una oración, siguiendo estos pasos:

  1. Comience de izquierda a derecha

  2. Encuentra el recuento de cada letra

  3. Poner la letra con su recuento en un orden

    • Las letras con mayor repetición estarán al final

    • Las letras con la misma repetición se ordenarán alfabéticamente.

  4. Se ignorarán los números y las letras especiales, incluidos los espacios en blanco (por ejemplo, se ignoran 9, 4, @, (, *, etc.)

  5. Grupo de letras ignorando mayúsculas y minúsculas. En la salida, use el caso de la última aparición en la entrada

  6. El recuento de la letra puede ser cualquier número, por ejemplo, 5H17M345K
  7. Si la entrada es todos números o letras especiales, entonces la salida será una cadena vacía, por ejemplo, Entrada "12 $ * 34 ^! luego salida ""
  8. cuando el orden alfabético para el mismo caso no importa, por ejemplo, 1a1B1c

Ejemplo:

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

Otro ejemplo:

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

Nota: las letras con 1 repetición están ordenadas alfabéticamente al principio y luego las letras con más repeticiones

Este es el , el código más corto gana.

asmgx
fuente
16
¿Puede una carta aparecer más de 9 veces?
Shaggy
3
@manatwork: Pero eso no está claro (nota, su respuesta no asumió que las letras aparecen menos de 10 veces), solo está tratando de aflojar las restricciones de entrada.
ბიმო
44
asegúrese de agregar estas aclaraciones al cuerpo de la pregunta real, para que los respondedores no tengan que buscar los comentarios
Jo King
2
Los comentarios no hacen una especificación. Debe actualizar el desafío para 1.agregar al menos 1 caso de prueba que incluya más de 9 ocurrencias de una o más letras, 2.especifique que la salida debe ser una cadena (aunque recomiendo encarecidamente que no sea tan estricto; no agrega nada al desafío ), 3.especifique que debemos ser capaces de manejar entradas que no contengan letras y 4.aclare si necesitamos o no manejar una cadena vacía como entrada.
Shaggy
1
Una vez que haya hecho eso, tendrá que probar todas las soluciones existentes e informarles si necesitan hacer algún cambio. Ya he encontrado bastantes soluciones que fallan en el punto 1. Además, en el futuro podría considerar usar nuestro Sandbox para tratar de resolver problemas como estos antes de publicar un desafío.
Shaggy

Respuestas:

7

Japt v2.0a0 -P, 14 bytes

f\l üv ñÊ®ÌiZÊ

Intentalo

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"
Lanudo
fuente
10

05AB1E , 19 17 16 bytes

Guardado 1 byte gracias a Kevin Cruijssen

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

Pruébalo en línea! o como un conjunto de pruebas

Explicación

á                  # 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
fuente
Puede guardar un byte cambiando el (par con) a a «(concat / merge), de modo que Jse pueda eliminar uno de los dos s (combinaciones).
Kevin Cruijssen
@KevinCruijssen: Wow. Me siento estúpido ahora :) ¿Por qué no me moví Jdentro? Editar: En realidad, los necesitaba como pareja en la versión de 19 bytes y no pensé en cambiarlo cuando hice el 17: P
Emigna
Es posible que pueda soltar el segundo Join, dependiendo de la respuesta a esta pregunta
Shaggy
7

Perl 6 , 66 63 bytes

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

Pruébalo en línea!

Explicación

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

Retina , 67 66 41 39 bytes

\P{L}

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

-25 bytes y una pequeña corrección de errores gracias a @Neil .
-2 bytes gracias a @Neil y @Shaggy juntos.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

Elimine todo excepto las letras mayúsculas y minúsculas:
es decir, Kitkat Tango 123!KitkatTango

\P{L}

Ordene las letras individuales sin distinción entre mayúsculas y minúsculas ( gracias a @MartinEnder por esto ):
es decir, KitkatTangoaagiKknottT

O$`.
$l$0

Captura cada trozo de mayúsculas y minúsculas letras repetidas adyacentes:
es decir aagiKknottT→ [ aa, g, i, Kk, n, o, ttT]

ir`\1*(.)

Anteponer la longitud de cada partido, y sólo mantener la última letra de cada trozo:
es decir [ aa, g, i, Kk, n, o, ttT] →2a1g1i2k1n1o3T

$.0$1

Clasifique los números y grupos de letras según los números:
2a1g1i2k1n1o3T1g1i1n1o2a2k3T

N`\d+.

Después de lo cual el resultado se emite implícitamente.

Kevin Cruijssen
fuente
¿Estás seguro de que es un error? ¿No es solo ordenar lexicográficamente? ( "aA" < "aa")
Shaggy
1
@ Shaggy No estoy seguro si puede. Porque \wy .en O`\w.se usaron para indicar que estamos ordenando pares de caracteres. No estoy seguro de si podemos ordenar cada par de caracteres, pero solo lo hacemos en función del primer carácter. Pero bueno, la sugerencia de Martin de ordenar cada personaje en función de una sustitución (que es la variante en minúscula del partido) funciona como un encanto. :)
Kevin Cruijssen
1
¿Se puede hacer en 41 bytes o me falta algo?
Neil
2
@Shaggy Leer más, \P{L}podría funcionar, lo que ahorra 2 bytes.
Neil
4

Wolfram Language (Mathematica) , 102 96 93 87 bytes

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

Pruébalo en línea!

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
fuente
4

Pyth, 27 24 22 bytes

ssrD0m,lded.gr0k@+Gr1G

Pruébelo en línea aquí .

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

Editar: Golfed 3 bytes ordenando por carácter antes del grupo, versión anterior: sm+ldedo,lNr0eN.gr0kf}r0TGQ

Edición 2: Golfed otros 2 bytes formateando la salida antes de cualquier pedido, versión anterior: sm+ldedlD.gr0krD0f}r0TGQ

Edición 3: Golfed otro byte cambiando el filtro, gracias a @FryAmTheEggman. También tuve que corregir un error cuando OP aclaró que una sola letra puede aparecer más de 9 veces, lo que agregó un byte en: o (Versión anterior:srD0m+lded.gr0kf}r0TGQ

Sok
fuente
@FryAmTheEggman gran llamada, gracias!
Sok
4

APL (Dyalog Extended) , SBCS de 28 bytes

Función de prefijo tácito anónimo.

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

Pruébalo en línea!

'\PL'
⎕R PCRE R  sin letras reemplazadas con
'' cadenas vacías

(... ) aplique la siguiente función tácita:

 con las minúsculas como teclas,
 ...  aplique la siguiente función tácita a cada tecla y su conjunto de valores correspondiente, a saber,
 el argumento:

  (... ) aplique la siguiente función tácita
   a
   la lista de valores:

   ⊢/ el último valor

   ... , anteponga lo siguiente a eso:

     la stringificación
     de
     la cuenta

    encierre (para tratar la lista de caracteres como una sola cadena)

ε nlist (aplanar)
 la
 versión ordenados-ascendente de ese

Adán
fuente
1
@ Shaggy Gracias. Fijo en +1 byte.
Adám
3

Perl 5, 74 68 66 bytes

-6 bytes cambiando -pa -ny utilizar sayen lugar de $_=join"", -2 bytes gracias a Abigail utilizando \pLen lugar de[a-z]

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

TIO

59 bytes, en caso de que no haya más de 9 ocurrencias de cada carácter

s/\pL/($h{lc$&}+=1).=$&/gie;say sort{lc$a cmp lc$b}values%h
Nahuel Fouilleul
fuente
@Abigail, gracias, en el segundo programa fue un descuido después de la actualización
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()))

Pruébalo en línea!

TFeld
fuente
La salida para Database Partitions Taskno es igual a1b1D1e1k1n1o1P1r2i3s4T5a
mdahmoune
@mdahmoune gracias, debe arreglarse.
TFeld
In the output, use the case of the last occurrence in the inputnecesitarás en rfindlugar de findpara esto. ...] forSin ...]forembargo, puede llegar a compensar eso.
ArBo
3

Python 3 , 105 bytes

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

Pruébalo en línea!

-1 gracias a ArBo .

Erik el Outgolfer
fuente
3

Haskell , 114/113 105 bytes

-9 bytes gracias a Laikoni (usando lista de comprensión y en (||)lugar de filtercon elem& acortar lengthpara deshacerse de feo 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

Pruébalo en línea!

ბიმო
fuente
107 bytes: ¡ Pruébelo en línea!
Laikoni
1
105: ¡ Pruébalo en línea!
Laikoni
@Laikoni: ¡Ahora más corto que con las importaciones, muy bueno!
ბიმო
3

Rojas , 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]

Pruébalo en línea!

Gracias a Shaggy por encontrar un error.

Galen Ivanov
fuente
1
@ Shaggy Gracias por señalar esto, intentaré solucionarlo.
Galen Ivanov
2

Jalea , 15 bytes

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

Un programa completo que imprime la contraseña como se especifica (como un enlace monádico produce una lista de listas que contienen un número entero y un carácter).

Pruébalo en línea!

Jonathan Allan
fuente
2

Cáscara , 15 bytes

No hay problemas con las importaciones cuando se utiliza la cáscara, por lo tanto, pueden hacer uso de las diversas funciones útiles, tales como groupOn, sortOn, toLoweretc:

ṁ§:osL→ÖLSġÖ_f√

¡Pruébalo en línea o pruébalos todos!

Explicación

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

JavaScript (Node.js) , 127 bytes

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

Pruébalo en línea!

  • parseInt(numberAsString, radix)intentará analizar un entero al comienzo de la cadena. Por ejemplo, parseInt('120px', 10)generará 120. Cuando el análisis falló, regresa en su NaNlugar. Conectamos un '0'al principio de cada personaje para que regrese0 para cualquier carácter alfa numérico. Y podemos ordenar las mismas letras juntas y caracteres no alfa al principio por este algoritmo.
  • Después sorty join, "Hello world!123"se convertiría " !123deHllloorw". Una coincidencia contra /([a-z])\1*/igignorará cualquier carácter no alfa y dividirá la cadena en trozos con las mismas letras. `.
  • mapconvertir "aaa"a"3a" lo requerido en la pregunta.
  • El segundo tipo usa la misma función que el primero. Gracias al sistema de números, "3b"sería menor que "12a"en la base 36, tal como esperamos: compara los recuentos primero ( n div 36) y compara la letra más tarde (n mod 36 ).
  • Finalmente joinellos juntos.

JavaScript (Node.js) , 146 bytes

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

Pruébalo en línea!

tsh
fuente
¿Por qué no presentar la solución más corta como su solución principal? Además, puede ser 2 bytes más corto ya que no es recursivo.
Shaggy
@ Shaggy Ah, se olvidó por completo de eliminar f=. El primero solía ser más corto. Pero obtiene 4 bytes más ya que OP preguntó que la salida puede ser una cadena vacía. Y solo los mantuve allí ...
tsh
1
@Shaggy OK, solo descubre que el segundo puede ser aún más corto. Y lo puse como el primero.
tsh
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 como una solución para entradas con más de 9 de una sola letra. Veré si puedo volver a bajar eso con un enfoque diferente.

Pruébalo en línea.

Explicación:

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
fuente
1
@Shaggy Dang ... corregido a un costo de 92 bytes ...>. <Veré si puedo volver a jugar golf al no usar un Comparador para ordenar, sino ordenarlo manualmente más tarde ...
Kevin Cruijssen
¡Ay! ¡Lo siento por eso!
Shaggy
2

Scala , 103 bytes

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

Pruébalo en línea!

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

Pruébalo en línea!

@KevinCruijssen también eliminó algunos espacios.

Roman Podymov
fuente
Hola, bienvenido a PPCG! No sé Swift, pero parece que se olvidó de eliminar algunos espacios, y se puede también golf todo falsea 0>1y truea 1>0. Pruébelo en línea 1027 bytes . Probablemente se pueda jugar mucho más, como el duplicado if let v=$0.key.escaped(asASCII:0>1).lowercased().unicodeScalars.first?.value{return v<$1.key.value}else{return 0>1}que tienes, pero se lo dejaré a alguien que realmente conozca a Swift.
Kevin Cruijssen
1
Además, si aún no lo ha visto: puede ser interesante leer los consejos para jugar golf en <todos los idiomas> y los consejos para jugar golf en Swift . Nuevamente bienvenido, y disfruta tu estadía! :)
Kevin Cruijssen
Hola @KevinCruijssen. Gracias por los consejos, eliminé truey falsede mi respuesta.
Roman Podymov
1
Bien, lo has jugado bastante desde tus más de 1000 bytes iniciales. :) Veo 6 espacios más que se pueden eliminar después / antes de todos =-assigns: Pruébelo en línea 364 bytes . ¡Disfruta tu estancia! :)
Kevin Cruijssen
1

Carbón , 30 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

F⌈Eβ№↧θι

Ejecute el alfabeto en minúsculas y encuentre el recuento de caracteres más alto en la entrada en minúsculas. Recorrer el rango implícito. (El ciclo en realidad va de 0a, n-1así que tengo que incrementar la variable del ciclo en cada uso).

Fβ

Pase el alfabeto en minúsculas nuevamente.

¿⁼№↧θκ⊕ι

Si el recuento de la letra actual es igual al valor del bucle externo ...

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

Concatene el recuento actual con la última aparición de la letra actual e imprima implícitamente.

Neil
fuente
1

NodeJS, 299 bytes, -6 bytes gracias a @tsh

¡No es tan bello pero funciona!

(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 o Chrome), 294 bytes, -1 byte gracias a @tsh

Con el nuevo .flatmétodo, puedo guardar 10 bytes:

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

Pruebe esto en línea: https://repl.it/repls/ConcernedHorribleHypothesis

chau giang
fuente
Hola y bienvenidos a PPCG. Sería bueno si proporcionara una forma de probar su presentación, como vincular a un intérprete en línea.
Jonathan Frech
@ JonathanFrech Acabo de agregar casos de prueba, ¡gracias!
chau giang
.replacex 3 veces -> [R='replace]y [R]x 2 veces
TSH
.charCodeAt(0)-> .charCodeAt()( 0es el valor predeterminado)
tsh
@tsh Muchas gracias por todos tus buenos consejos, ¡acabo de actualizar mi respuesta!
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='')

Pruébalo en línea!

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

Versión original sin golf con la misma lógica:

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

Pruébalo en línea!

niczky12
fuente
0

Perl 6, 86 82 bytes

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