Letras del mismo número


19

Las letras de las palabras quieren justicia.

Decidieron aparecer el mismo número de veces en una oración por igual.

Ejemplo:

Priorities

Se convertirá:

Ppprrioooritttieeesss

Cada letra aparece 3 veces, como la letra más común i, apareciendo 3 veces.

No importa dónde coloque las letras repetidas, siempre que estén al lado de una letra similar.

Es decir:

Pppriooorritttieeesss está bien (la letra 'r')

Ppprioororitttieeesss no está bien (la letra 'r')

Otro ejemplo:

invoice

Se convertirá:

innvvooiccee

Otro ejemplo:

Remittance Advice

Se convertirá:

Rrremmmiitttaannncce Adddvvvice

El espacio, la coma, el signo de interrogación, la cita, etc. no se consideran letras para este desafío. Solo necesita considerar [a-zA-Z]. Solo una vez que el espacio es suficiente, y el orden de las letras debe permanecer igual.

La mayúscula de las letras no importa, las mayúsculas y minúsculas se cuentan como la misma letra. Es decir: Piptiene 2 'P's y 1' I ', por lo que se convertirá Piip.

Es mayúsculas y minúsculas las letras pueden ser de cualquier forma, Piip=piip=piiP=PiiP

Este es el


2
¿Puedo sugerir el uso de la caja de arena para los futuros desafíos para el hierro ayuda de todos los detalles antes de publicar la cuestión principal a
Jo Rey

¿Es "rrreeemmmiiitttaaannncccdddvvv" un resultado aceptable en el ejemplo dado (ya que el orden de las letras distintas (como se define como az) todavía se mantiene)? (Mi respuesta de Jelly actualmente se basa en que esta interpretación está bien).
Jonathan Allan

1
@JonathanAllan Hmm, aunque le dejo la opción a OP, lo dudo mucho. No solo desaparecen los caracteres que no son letras (el espacio), sino que también pone todos los caracteres uno al lado del otro en lugar de mantenerlos en el mismo lugar. Su salida hace que el desafío sea diferente y más fácil (en mi humilde opinión).
Kevin Cruijssen

1
@KevinCruijssen el espacio está a la izquierda, no es una carta, por lo tanto, no necesita adherirse a "y el orden de las letras debe permanecer igual"
Jonathan Allan

1
@ JonathanAllan Ah, no noté el espacio, mi mal. Entiendo completamente el razonamiento que proporcionó en su respuesta de Jelly y en base a eso es realmente una salida válida, pero preferiría ver la redacción cambiada, y luego permitir su salida, ya que cambiaría por completo el desafío en sí.
Kevin Cruijssen

Respuestas:


5

05AB1E , 16 bytes

lDáÙSйls¢Zα>×.;

Pruébalo en línea!

Explicación

l                  # convert input to lowercase
 D                 # duplicate
  á                # keep only letters
   Ù               # remove duplicates
    S              # split to list of chars
     Ð             # triplicate
      ¹ls¢         # count the occurrences of each letter in lowercase input
          Zα       # absolute valuue with max occurrence
            >      # increment
             ×     # repeat each unique char that many times
              .;   # replace the first occurrence of the char in lowercase input with this

7

R , 106 bytes

function(s){for(A in L<-LETTERS)s=sub(A,strrep(A,max(x<-+s-+Map(gsub,L,'',s,T))-x[A]--1),s,T);s}
"+"=nchar

Pruébalo en línea!

Enfoque de base R:


Estoy impresionado de que llegaste a 111 con base-R!
J.Doe

@ J.Doe: Después de publicar mi solución original de 137 bytes, cambié ligeramente mi enfoque inspirado en el tuyo, y básicamente convergí en tu solución, solo con la eliminación de stringr: D
digEmAll

1
106 bytes con abuso de operador. ¡Base-R gana!
J.Doe

@ J.Doe: ¡increíble!
digEmAll el

5

Perl 6 , 82 bytes

-3 bytes gracias a nwellnhof

->\a{a.=lc.=subst($_,$_ x a.comb(/<:L>/).Bag.values.max+1-a.comb($_))for 'a'..'z'}

Pruébalo en línea!

Toma una cadena mutable y la modifica en su lugar.

Explicación:

->\a{        # Anonymous code block that takes a mutable string            }
 a.=lc;  # Lowercase
                                                               for 'a'..'z'  # For each letter
 .=subst(                                                    )  # Substitute
          $_,   #The first occurrence of the letter with
             $_ x  #The letter repeated
                  a.comb(/<:L>/).Bag.values.max    # The count of the most common letter
                                                 +1  # Plus 1
                                                   -a.comb($_)  # Minus the count of that letter already in the string

Puede encadenar al .=operador como a.=lc.=subst(...). Sin embargo, no estoy seguro de si está permitido cambiar el caso de una carta existente. También en <:L>lugar de <:Ll>.
nwellnhof

@nwellnhof Sí, el autor de la pregunta dice que la salida no distingue entre mayúsculas y minúsculas
Jo King

5

JavaScript (ES6), 112 bytes

s=>(m=g=F=>s.replace(/[a-z]/gi,c=>F(c.toLowerCase())))(c=>g[c]=c+c.repeat(m-g[c]),g(c=>m=(n=g[c]=-~g[c])<m?m:n))

Pruébalo en línea!

Comentado

s => (                       // s = input string
  m =                        // m = max. number of occurrences of the same letter
  g = F =>                   // g = helper function taking a callback function F
    s.replace(               //     (also used to store the # of occurrences of each letter)
      /[a-z]/gi,             //   for each letter c in s:
      c => F(                //     invoke F():
        c.toLowerCase()      //       with c.toLowerCase()
      )                      //     end of call to F()
    )                        //   end of replace()
)(c =>                       // invoke g() (second pass):
  g[c] =                     //   update g[c] to a non-numeric value
    c +                      //   append c once, unconditionally
    c.repeat(m - g[c]),      //   and append c as many times as required to reach m
                             //   (any subsequent iteration with the same letter will
                             //   lead to c.repeat(m - g[c]) --> c.repeat(NaN) --> '')
  g(c =>                     //   invoke g() (first pass):
    m = (n = g[c] = -~g[c])  //     increment g[c], save the result in n
      < m ? m : n            //     and update m to max(m, n)
  )                          //   end of first pass
)                            // end of second pass

Mi habilidades JS chupan, así que estoy un poco confundido acerca de esta parte: o[l] = // updates o[l] to a non-numeric value. Si entiendo correctamente, ¿ ohay una matriz de enteros en las funciones Fy g, pero cambia a una matriz de cadenas que contiene una o más veces el carácter cen la parte que mencioné anteriormente? Además, supongo que los valores de oson undefinedpor defecto, ya que está utilizando en o[l]=-~o[l]lugar de ++o[l]?
Kevin Cruijssen

1
@KevinCruijssen Queremos que cada letra se rellene con el número máximo de ocurrencias solo una vez. Al actualizar o[l]a una letra, cualquier iteración posterior con la misma letra dará lugar a m - o[l] --> NaN(entero menos letra) y l.repeat(NaN) == ''. (Sobre el último punto: sí, eso es correcto.)
Arnauld

Ah ok, gracias por la explicación! :)
Kevin Cruijssen

(y debería haber dicho cadena en lugar de letra )
Arnauld

5

J , 33 56 46 bytes

t=:~:tolower
(#~1+t*~:(*>./-])t*1#.e.)@toupper

Pruébalo en línea!

No se pudo encontrar una manera de evitar el uso ~:tolowerdos veces.

Cómo funciona

t=:~:tolower    Auxiliary function: isupper
     tolower    Is lowercase version of itself...
   ~:           different from itself?

(#~1+t*~:(*>./-])t*1#.e.)@toupper    Main function
                          toupper    Convert to uppercase
                      e.     Build 2D array by comparing to itself
                   1#.       Row-wise sum; Count occurrences
                 t*     A) Filter by isupper (needed for finding max count)
           >./-]        Compute max of A) minus each element of A)
       ~:          Nub sieve; 1 if first occurrence, 0 otherwise
          *        Filter first occurrences only
     t*       Filter by isupper again, to ban non-alphabets from duplicating
   1+         Add one to preserve given chars
 #~           Duplicate

5

R + stringr, 108 bytes

No soy muy bueno en stringr. Devuelve una mezcla de minúsculas y mayúsculas ya que la pregunta dice que no importa.

function(x){for(l in L<-letters)x=sub(l,strrep(l,max(s<-stringr::str_count(tolower(x),L))-s[L==l]+1),x,T);x}

Pruébalo en línea!

Explicación

function(x){
for(l in letters){ # Iterate through builtin vector "a", "b", "c"...
   # Generate a 26-long integer vector for how many a's, b's, c's in lower case string
  s = stringr::str_count(tolower(x),letters)
    # Take the max of this
  m = max(s)
    # Repeat the letter in the iteration enough times to make the word 'fair'
  new.l = strrep(l,m-s[letters==l]+1)
    # Substitute the first instance only of the letter in the string for the repeated letter
    # This is case insensitive (the T at the end)
    # Notice we calculate the max letter frequency each loop
    # This is inefficient but doesn't change the answer and avoids bytes
  x=sub(l,new.l,x,T);
  }
x # Return the substituted string
}

3

K4 , 35 bytes

Solución:

{x@o@<o:(&^x),/(|/#:'g)#'g:" "_=_x}

Ejemplos:

q)k){x@o@<o:(&^x),/(|/#:'g)#'g:" "_=_x}"Priorities"
"PPPrrioooritttieeesss"
q)k){x@o@<o:(&^x),/(|/#:'g)#'g:" "_=_x}"invoice"
"innvvooiccee"
q)k){x@o@<o:(&^x),/(|/#:'g)#'g:" "_=_x}"Remittance Notice"
"RRRemmmiittaaanncce Noootice"

Explicación:

Podría ser golfable con un enfoque diferente, seguirá pensando

{x@o@<o:(&^x),/(|/#:'g)#'g:" "_=_x} / the solution
{                                 } / lambda taking implicit argument x
                                _x  / lowercase input
                               =    / group
                           " "_     / drop space from keys
                         g:         / save as g
                       #'           / take each
               (      )             / do this together
                  #:'g              / count occurances in each group
                |/                  / take the maximum
             ,/                     / flatten with
        (&^x)                       / indices where input is null (ie " ")
      o:                            / save as o
     <                              / indices to sort o ascending
   o@                               / apply these to o
 x@                                 / apply these indices to original input

3

Carbón , 33 32 bytes

⭆↧θ⁺§θκ×ι∧№βι∧⁼κ⌕↧θι⁻⌈Eβ№↧θλ№↧θι

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

  θ                                 Input string
 ↧                                  Lower case
⭆                                   Map over characters and join
      κ                             Current index
     θ                              Input string
    §                               Original character
   ⁺                                Concatenate with
        ι                           Lowercased character
       ×                            Repeated
            ι                       Lowercased character
           β                        Lowercase alphabet
          №                         Count
         ∧                          Logical And
                   ι                Lowercased character
                  θ                 Input string
                 ↧                  Lower case
                ⌕                   Find
               κ                    Current index
              ⁼                     Equals
             ∧                      Logical And
                       β            Lowercase alphabet
                      E             Map over characters
                           λ        Current character
                          θ         Input string
                         ↧          Lower case
                        №           Count
                     ⌈              Maximum
                    ⁻               Minus
                               ι    Lowercased character
                              θ     Input string
                             ↧      Lower case
                            №       Count
                                    Implicitly print

3

Java 11, 190 176 162 bytes

s->{s=s.toUpperCase();char m=2,i=64,a[]=new char[127];for(int c:s.getBytes())m-=m+~++a[c]>>-1;for(;++i<91;)s=s.replaceFirst(i+"",repeat((i+""),m-a[i]));return s;}

-14 bytes gracias a @Nevay .

La salida está en mayúscula completa.

Pruébalo en línea. (NOTA: String.repeat(int)se emula comorepeat(String,int) para el mismo recuento de bytes, porque Java 11 aún no está en TIO).

Explicación:

s->{                      // Method with String as both parameter and return-type
  s=s.toUpperCase();      //  Convert the input-String to full uppercase
  char m=2,               //  Max occurrence (+1), starting at 2
       i=64,              //  Index integer, starting at 64 ('A'-1)
       a[]=new char[127]; //  Create a count-array of size 127 (printable ASCII chars)
  for(int c:s.getBytes()) //  Loop over the characters of the String as integers
    m-=m+~++a[c]>>-1;     //   Increase the occurrence-counter of the char by 1 first
                          //   And if it's larger than the max-2, increase the max by 1
  for(;++i<91;)           //  Loop `i` in the range ['A', 'Z']
    s=s.replaceFirst(i+"",//   Replace the first char `i` in the string with:
       (i+"").repeat(     //   That same character repeated
        m-a[i]));         //   The max(+1) minus its array-occurrence amount of times
  return s;}              //  Then return the now modified String as result

¿Puedes usar var para un byte?
Quintec

@Quintec En lugar de lo que charquieres decir? Lamentablemente no. varsolo se puede usar para campos individuales. Entonces, en lugar de char m=1,i=127,a[]=new char[i];eso sería var m=1;var i=127;var a=new char[i];. Aquí un consejo útil de lo que puede y no puede hacer con Java 10 var. (Podría reemplazar el inten el bucle con var, pero el recuento de bytes seguirá siendo el mismo.)
Kevin Cruijssen

Te tengo, gracias. Todavía no tengo idea de cómo funciona Java 10/09/11, jaja, me quedaré con 8; p
Quintec

@Quintec Java 9 Realmente tampoco entiendo, ya que se centra principalmente en ese REPL. Java 10 es casi lo mismo que Java 8, excepto por el var. Y Java 11 apenas tiene cambios en todos los codegolf relacionados, excepto por el String.repeatmétodo que ya he usado muchas veces. También tiene los nuevos String.stripLeadingo String.stripTrailing, que actúan como trimpero solo los espacios en blanco iniciales / finales, y String.isBlank()que es lo mismo que String.trim().isEmpty()(solo espacios en blanco o vacíos).
Kevin Cruijssen

1
-14 bytes:s->{s=s.toUpperCase();char m=2,i=91,a[]=new char[127];for(int c:s.getBytes())m-=m+~++a[c]>>-1;for(;i-->65;)s=s.replaceFirst(i+"",repeat((i+""),m-a[i]));return s;}
Nevay

3

Japt -h , 27 bytes

-3 bytes de @ETHproductions

;v
ñ oC ó¥ ú £=iXÎpXèS)UbXg

Tratando de explicar

;v                          Convert implicit input to lowercase
ñ oC ó¥ ú £=iXÎpXèS)UbXg      Main function. Implicit lowercase input => "priorities"
ñ                           Sort => "eiiioprrst"
 oC                         Remove non alphabetical chars
   ó¥                       Split on different letters => ["e","iii","o","p","rr","s","t"]
     ú                      Right-pad each to the length of the longest with space => ["e  ","iii","o  ","p  ","rr ","s  ","t  "]
       £                    For each X in this array:
             XèS              Count the number of spaces in X
          XÎ                  Get the first character in X
            p   )             Repeat it (number of spaces) times
                              example the mapped value "e  " will become "ee"
         i                    Insert this into U at
                 UbXg           the first index of (first character in X) in U
        =                     Set U to the result

Pruébalo en línea!


1
Espero que no te ú
importe

@ETHproductions lo aprecio. No soy muy bueno en inglés, así que gracias
Luis felipe De jesus Munoz

1
Desafortunadamente, parece fallar cuando no hay letras involucradas (no se deben cambiar). Una solución simple sería insertar un ñ oC ó¥, aunque requiere agregar de nuevo en el ;...
ETHproductions

Espera ... ¿desde cuándo ñtrabajaste con cuerdas? @ETHproductions, ¡dígame que es una adición reciente y no lo he pasado por alto todo este tiempo!
Shaggy

@Shaggy Aparentemente fue hace 2.5 meses, pero no te preocupes, incluso me había olvidado de que existía hasta esta respuesta ;-)
ETHproductions

2

Ruby , 89 bytes

->s{1while(a=s.scan /\w/).map(&g=->x{s.scan(/#{x}/i).size}).uniq[1]&&s[a.min_by &g]*=2;s}

Pruébalo en línea!

Intenté diferentes enfoques, pero lo que realmente ahorra muchos bytes es agregar un carácter a la vez.

Cómo:

->s{
    1while                             # 1 is a nop to the while
    (a=s.scan /\w/)                    # For all the letters in the string
    .map(&g=->x{s.scan(/#{x}/i).size}) # Count occurrences ignoring case.
    .uniq[1]                           # Break out of loop if all equals
    &&s[a.min_by &g]*=2                # Otherwise duplicate the letter
                                       #  with the lowest count
    ;s}                                # Return the string

2

Powershell 6, 123 bytes

Utiliza una gama de caracteres 'a'..'z'. Vea la secuencia de comandos para Powershell anterior a continuación.

param($s)for(;'a'..'z'|%{
if($d=($s-replace"[^$_]").Length-$n){if($d-gt0){1}else{$s=$s-replace"^(.*$_)","`$1$_"}}}){$n++}$s

Script de prueba explicado:

$f = {

param($s)                               # a parameter string
for(;                                   # loop while exists at least one letter...
'a'..'z'|%{                             # for each letter
    $d=($s-replace"[^$_]").Length-$n    # let $d is a difference between a number of current letter and current $n 
    if($d-gt0){                         # if the difference > 0
        1                               # then return a object to increase $n on next iteration
    }
    if($d-lt0){                         # if the differenct < 0
        $s=$s-replace"^(.*$_)","`$1$_"  # append the current letter after a last instance of the letter. Use "^(.*?$_)" regexp to append it after a first instance of the letter.
    }
}){
    $n++                                # increment $n if exists at least one letter number of witch greather then $n
}                                       # and make next iteration of the 'for'.

$s                                      # return modified string if all letters in the string occur the same number of times

}

@(
    ,('Priorities', 'Ppprrioooritttieeesss', 'PPPriooorritttieeesss')
    ,('invoice', 'innvvooiccee')
    ,('Remittance Advice', 'Rrremmmiitttaannncce Adddvvvice', 'RRRemmmitttannnce Aadddvvviicce')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-in$e): $r"
}

Salida:

True: Pppriooorritttieeesss
True: innvvooiccee
True: Rrremmmitttannnce Aadddvvviicce

Powershell 5.1-, 133 bytes

param($s)for(;97..122|%{$_=[char]$_
if($d=($s-replace"[^$_]").Length-$n){if($d-gt0){1}else{$s=$s-replace"^(.*$_)","`$1$_"}}}){$n++}$s

2

Rojo , 252 bytes

func[s][a: charset[#"a"-#"z"#"A"-#"Z"]t: parse s[collect[any[keep a | skip]]]m: copy
#()foreach c t[c: form c either n: m/:c[m/:c: n + 1][m/:c: 1]]d: last sort extract next
to-block m 2 foreach c s[prin c: form c if n: m/:c[loop d - n[prin c]m/:c: d]]]

Pruébalo en línea!

Solución ridículamente larga ...

Explicación:

f: func [ s ] [
    a: charset [ #"a" - #"z" #"A" - #"Z" ]   ; letters
    t: parse s [                             ; parse the string 
        collect [ any [ keep a | skip ] ]    ; and keep only the letters
    ]
    m: copy #()                              ; initialize a map
    foreach c t [                            ; for each character in t
        c: form c                            ; the character as a string
        either n: select m c [ m/:c: n + 1 ] ; increase the count if already in map
                             [ m/:c: 1 ]     ; otherwise create a map entry with count 1 
    ]
    d: last sort extract next to-block m 2   ; convert the map to a block; extract only the 
                                             ; numbers and take the last of the sorted block
    foreach c s [                            ; for each character in the input
        c: form c                            ; the character as a string
        prin c                               ; print it (with no space nor newline)
        if n: select m c [                   ; if c is a key in the map
            loop d - n [ prin c ]            ; print the character again up to d times 
            m/:c: d                          ; set the count to max (flag it as used)
        ]
    ]
]

2

Javascript (Node.js) , 140 137 bytes

x=>[...x=x.toLowerCase()].map(F=c=>(F[c]=-~F[c],F[c]>w?w=F[c]:w,c),w=0).map(c=>x=x.replace(c,c.repeat(c>'`'&c<'{'?w-F[c]+1:1),F[c]=w))&&x

Pruébalo en línea!

+33 bytes de mi primera solución para esas restricciones adicionales interminables. JS apesta a las manipulaciones de cadenas que no distinguen entre mayúsculas y minúsculas que conoces.

-3 bytes atrás Gracias @Arnauld.

Explicación

x =>                                     // The function.
  [...x = x.toLowerCase()].map(f = c => (// - Iterate among each character...
                                         // - Additional constraint 2
    f[c] = -~f[c],                       //   - Add one to the character counter
    f[c] > w ? w = f[c] : w,             //   - Update the maximum count if necessary
    c                                    //   - Return back the character for the use in
                                         //     the next map function
  ), w = 0)                              // - The counters
  .map(c =>                              // - Iterate again...
    x = x.replace(                       //   - Repeat the first appearance of
      c,                                 //   - Each character
      c.repeat(                          //   - Needed number times
        c > '`' & c < '{'                //   - Additional constraint 1
        ? w - f[c] + 1                   //   - If this is letter, repeat
        : 1                              //   - If not, stay as is
      ),                                 //   - That should've been clearly stated
      f[c] = w                           //   - And set the counter so that no further 
                                         //     replacements are done on this character 
    )                                    //   - (w - f[c] + 1 = 1 in further iterations)
  ) && x                                 // - Return the result

Las soluciones deben ser capaces de manejar entradas de mayúsculas y minúsculas.
Shaggy

@ Shaggy Creo que el desafío se ha editado después de tu comentario. Parece que el caso de la salida no importa.
Arnauld

Por otro lado, las funciones deben ser reutilizables , que no es el caso aquí.
Arnauld

@Arnauld Oh, a veces te veo usando fs como almacenamiento temporal, así que pensé que estaba bien
Shieru Asakoto

map()Las funciones de devolución de llamada son seguras de usar para el almacenamiento, ya que están definidas en un ámbito local. Usar la función principal, que está definida globalmente, es más peligroso. Aquí, puede usar la devolución de llamada de la primera map(), que lo devuelve a 137 bytes .
Arnauld

2

Casco , 15 bytes

ḟ§Ë#f√MṘO´πL¹m_

Pruébalo en línea!

Fuerza bruta, muy lenta.

Explicación

ḟ§Ë#f√MṘO´πL¹m_  Implicit input, say s = "To do"
             m_  Convert to lowercase: t = "to do"
           L¹    Length of s: 5
         ´π      All length-5 combinations of [1..5]:
                   [[1,1,1,1,1], [1,1,1,1,2], [2,1,1,1,1], ..., [5,5,5,5,5]]
        O        Sort them lexicographically:
                   [[1,1,1,1,1], [1,1,1,1,2], [1,1,1,1,3], ..., [5,5,5,5,5]]
      MṘ         For each, replicate letters of t that many times:
                   ["to do", "to doo", "to dooo", ..., "tttttooooo     dddddooooo"]
ḟ                Find the first string that satisfies this:
                   Example argument: x = "tto ddo"
    f√             Letters of x: "ttoddo"
  Ë                They have equal
 § #               number of occurrences in x: true (all have 2).

no se pudieron obtener resultados
asmgx

@asmgx El programa es realmente lento. Parece que se agotó el tiempo de espera en TIO para entradas de longitud 8 y más largas, porque mata el cálculo después de 1 minuto. El intérprete fuera de línea debería dar un resultado si espera lo suficiente (probablemente varias horas para entradas de longitud 10).
Zgarb

2

Perl 6 , 77 70 bytes

{s:i|$($!.min(*{*}).key)|$/$/|until [==] ($!=.lc.comb(/<:L>/).Bag){*}}

Pruébalo en línea!

Adoptando el enfoque de GB de insertar un carácter hasta que todos los caracteres aparezcan el mismo número de veces. Recibe una cadena que se modifica en el lugar.

Si los guiones bajos se pueden tratar como letras, la expresión regular puede convertirse /\w/, ahorrando dos bytes.

Explicación

{
                    .lc.comb(/<:L>/).Bag          # Create Bag of letter/count pairs
                ($!=                    )         # Store temporarily in $!
 ... until [==]                          .values  # Until all counts are equal
 s:i|                      |    |                 # Replace (ignoring case)
     $($!.min(*.value).key)                       # letter with minimum count
                            $/$/                  # with itself doubled
}

@JoKing Parece que tu mejora se basa en la versión anterior antes de que descubriera el {*}truco.
nwellnhof

Entonces, ¿eso es como un atajo para .value(s)eso? Genial, es posible que tenga que actualizar algunas de mis viejas soluciones
Jo King,


1

C (clang) , 246 223 220 210 208 193 188 bytes

Indicador del compilador -DF=;for(i=0;b[i];i++ -DB=b[i](29 bytes)

Se agregó compatibilidad con mayúsculas y minúsculas.

f(char*c){char m,i,s,*b,a[255]={0};s=asprintf(&b,c)F)B=tolower(B),a[B]++F,a[B]>a[m]?m=B:0)F)a[B]^a[m]?b=realloc(b,s+i),bcopy(&B,b+i+1,s),a[B]++:(m=B);puts(b);}

Pruébalo en línea!


1

Pyth, 31 30 bytes

JeSm/Qd=r0QVQ=tQ=+k*N-J/+kQN)k

Pruébalo aquí

Explicación

JeSm/Qd=r0QVQ=tQ=+k*N-J/+kQN)k
       =r0Q                        Convert input to lowercase.
JeSm/Qd                            Find the count of the most common character.
           VQ               )      For each character in the input...
             =tQ                   ... remove that character from the input...
                =+k*N-J/+kQN       ... append copies to k until we have enough.
                             k     Output.

1

C (GCC) : 175 bytes

f(char*s){int c[999]={0},i=0,m=0,k,L;while((L=s[i++])&&(k=++c[L<97?L+32:L]))m=k>m?k:m;i=0;while(L=s[i++])for(L=L<97&&L>64?L+32:L,putchar(L);isalpha(L)&&++c[L]<=m;)putchar(L);}

Sin golf

f(char *s) {
  int c[999]={0},i=0,m=0,k,L;                      // Array used like a dictionary, temp vars
  while((L=s[i++])&&(k=++c[L<97?L+32:L]))          // store letter counts
    m=k>m?k:m;                                     // calculate max occurance
  i=0;                                             // reset string index
  while(L=s[i++])                                  // iterate string
    for(L=L<97&&L>64?L+32:L,putchar(L);isalpha(L)&&++c[L]<=m;) // set character L to lowercase if in alphabet, print always once, repeat if in alphabet
      putchar(L);                                  // print character
}

Pruébalo en línea!


0

Kotlin Android, 413 bytes

var l: List<Char> = w.toList().distinct();val h = HashMap<Char, Int>();var x='m';var n=0;for(z in l.indices){var c=0;for (i in 0.rangeTo(w.length-1)){if(l[z]==(w[i]))c++};h.put(l[z],c);if(n<c){n=c}};for(entry in h){h.replace(entry.key,n-entry.value)};var v=ArrayList<Char>();for(i  in 0.rangeTo(w.length-1)){if(h.containsKey(w[i])){for(p in 0.rangeTo(h.get(w[i])!!)){v.add(w[i])};h.remove(w[i])}else{v.add(w[i])}}

Probar en línea

Explicación paso 1 -> Seleccione la lista de caracteres distintos. paso 2 -> Obtener el recuento de cada carácter en la cadena y seleccionar la frecuencia máxima de caracteres paso 3 -> obtener diferencia en la frecuencia de caracteres con respecto a la frecuencia máxima de caracteres paso 4 -> colocar caracteres con respecto a las posiciones en cadena. ¡Feliz solución!



0

PHP ,185 173 170 bytes

function($s){$m=max($a=count_chars($s=strtolower($s),1));foreach(str_split($s)as$c)$o.=str_repeat($c,($b=$a[$d=ord($c)])!=($a[$d]=$m)&&$d>96&&$d<123?$m-$b+1:1);return$o;}

Pruébalo en línea!

Sin golf (y sin ternar y sin optimizar).

function f($s) {
    $s = strtolower( $s );
    $a = count_chars( $s, 1 );
    $m = max( $a );
    foreach( str_split( $s ) as $c ) {
        if ( $c < 'a' or $c > 'z') {           // is non a-z
            $n = 1;
        } elseif ( $a[ord($c)] == $m ) {    // already has max number
            $n = 1;
        } else {
            $n = $m - $a[ord($c)] + 1;       // add this many chars
        }
        $o .= str_repeat( $c, $n );
        $a[ord($c)] = $m;                   // has reached the max
    }
    return $o; 
}
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.