Lettres identiques


19

Les lettres des mots veulent l'équité.

Ils ont décidé d'apparaître de manière égale le même nombre de fois dans une phrase.

Exemple:

Priorities

Va devenir:

Ppprrioooritttieeesss

Chaque lettre apparaît 3 fois, comme la lettre la plus courante i, apparaissant 3 fois.

Peu importe où vous mettez les lettres répétées, tant qu'elles sont à côté d'une lettre similaire.

C'est à dire:

Pppriooorritttieeesss est OK (la lettre «r»)

Ppprioororitttieeesss n'est pas OK (la lettre «r»)

Un autre exemple:

invoice

Va devenir:

innvvooiccee

Un autre exemple:

Remittance Advice

Va devenir:

Rrremmmiitttaannncce Adddvvvice

L'espace, la virgule, le point d'interrogation, la citation, etc. ne sont pas considérés comme des lettres pour ce défi. Il suffit de considérer [a-zA-Z]. Une fois que l'espace est suffisant, l'ordre des lettres doit rester le même.

La majuscule des lettres n'a pas d'importance, les majuscules et les minuscules sont des comptés comme la même lettre. C'est-à-dire: Pipa 2 «P» et 1 «I», il deviendra donc Piip.

Il est possible que les lettres insensibles à la casse se présentent sous n'importe quelle forme, Piip=piip=piiP=PiiP

C'est du


2
Puis-je suggérer d'utiliser le bac à sable pour les défis futurs pour aider à résoudre tous les détails avant de poster la question au principal
Jo King

"Rrreeemmmiiitttaaannncccdddvvv" est-il une sortie acceptable dans l'exemple donné (puisque l'ordre des lettres distinctes (comme défini comme az) est toujours maintenu)? (Ma réponse Jelly repose actuellement sur le fait que cette interprétation est OK.)
Jonathan Allan

1
@JonathanAllan Hmm, bien que je laisse le choix à OP, j'en doute fortement. Non seulement les caractères non-lettres (l'espace) ont disparu, mais vous avez également mis tous les caractères les uns à côté des autres au lieu de les conserver au même endroit. Votre sortie rend le défi différent et plus facile (à mon humble avis).
Kevin Cruijssen

1
@KevinCruijssen l'espace est à gauche - ce n'est pas une lettre donc n'a pas besoin de respecter "et l'ordre des lettres doit rester le même"
Jonathan Allan

1
@JonathanAllan Ah, je n'ai pas remarqué l'espace, ma mauvaise. Je comprends parfaitement le raisonnement que vous avez fourni dans votre réponse Jelly et sur la base de cela, il s'agit bien d'une sortie valide, mais je préférerais voir le libellé modifié, puis autoriser votre sortie, car cela changerait complètement le défi lui-même.
Kevin Cruijssen

Réponses:


5

05AB1E , 16 octets

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

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Approche Base R:

  • en volant quelques idées de l' approche @ J.Doe R + stringr , j'ai économisé 26 octets!
  • 5 autres octets enregistrés en utilisant la suggestion de @ J.Doe pour abuser de l' +opérateur R

Je suis impressionné que vous ayez atteint 111 avec la base-R!
J.Doe

@ J.Doe: Après avoir publié ma solution originale de 137 octets, j'ai légèrement changé mon approche inspirée par la vôtre, et j'ai essentiellement convergé vers votre solution, juste avec stringr supprimé: D
digEmAll

1
106 octets avec abus de l'opérateur. Base-R gagne!
J.Doe

@ J.Doe: génial!
digEmAll

5

Perl 6 , 82 octets

-3 octets grâce à nwellnhof

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

Essayez-le en ligne!

Prend une chaîne mutable et la modifie en place.

Explication:

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

Vous pouvez enchaîner l' .=opérateur comme a.=lc.=subst(...). Je ne sais pas si le changement de casse d'une lettre existante est autorisé. Aussi <:L>au lieu de <:Ll>.
nwellnhof

@nwellnhof Ouais, le demandeur dit que la sortie est insensible à la casse
Jo King

5

JavaScript (ES6), 112 octets

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

Essayez-le en ligne!

Commenté

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

Mes compétences JS sucent, donc je suis un peu confus au sujet de cette partie: o[l] = // updates o[l] to a non-numeric value. Si je comprends bien, oun tableau d'entiers se trouve-t-il dans les fonctions Fet g, mais se transforme-t-il en un tableau de chaînes contenant une ou plusieurs fois le caractère cde la partie que j'ai mentionnée précédemment? De plus, je suppose que les valeurs de osont undefinedpar défaut, puisque vous utilisez o[l]=-~o[l]au lieu de ++o[l]?
Kevin Cruijssen

1
@KevinCruijssen Nous voulons que chaque lettre soit complétée une seule fois au nombre maximum d'occurrences. En mettant o[l]à jour vers une lettre, toute itération ultérieure avec la même lettre mènera à m - o[l] --> NaN(entier moins lettre) et l.repeat(NaN) == ''. (À propos du dernier point: oui, c'est exact.)
Arnauld

Ah ok, merci pour l'explication! :)
Kevin Cruijssen

(et j'aurais dû dire chaîne plutôt que lettre )
Arnauld

5

J , 33 56 46 octets

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

Essayez-le en ligne!

Impossible de trouver un moyen d'éviter d'utiliser ~:tolowerdeux fois.

Comment ça fonctionne

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 octets

Je ne suis pas très bon stringr. Renvoie un mélange de minuscules et de majuscules, car la question indique que cela n'a pas d'importance.

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}

Essayez-le en ligne!

Explication

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 octets

Solution:

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

Exemples:

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"

Explication:

Peut être jouable au golf avec une approche différente, continuera à penser

{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

Fusain , 33 32 octets

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

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

  θ                                 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 162 octets

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 octets grâce à @Nevay .

La sortie est en majuscule.

Essayez-le en ligne. (REMARQUE: String.repeat(int)est émulé comme repeat(String,int)pour le même nombre d'octets, car Java 11 n'est pas encore sur TIO.)

Explication:

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

Pouvez-vous utiliser var pour un octet?
Quintec

@Quintec Au lieu de ce que charvous voulez dire? Malheureusement non. varne peut être utilisé que pour des champs uniques. Au lieu de char m=1,i=127,a[]=new char[i];cela, ce serait var m=1;var i=127;var a=new char[i];. Voici une astuce utile de ce que vous pouvez et ne pouvez pas faire avec Java 10 var. (Je pourrais remplacer le intdans la boucle par var, mais le nombre d'octets resterait le même.)
Kevin Cruijssen

Gotcha, merci. Je n'ai toujours aucune idée du fonctionnement de Java 9/10/11, haha, je m'en
tiendrai

@Quintec Java 9, je ne comprends pas vraiment non plus, car il est principalement axé sur ce REPL. Java 10 est essentiellement le même que Java 8, à l'exception de var. Et Java 11 n'a quasiment pas de changement du tout lié au codegolf, à l'exception de la String.repeatméthode que j'ai déjà utilisée beaucoup de fois. Il a également le nouveau String.stripLeadingou String.stripTrailing, qui agit comme trimmais uniquement les espaces blancs de début / fin, et String.isBlank()qui est le même que String.trim().isEmpty()(vide ou blanc uniquement).
Kevin Cruijssen

1
-14 octets: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 octets

-3 octets de @ETHproductions

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

Essayer d'expliquer

;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

Essayez-le en ligne!


1
J'espère que cela ne vous dérange pas, j'ai développé une partie de l'explication (cette ligne qui expliquait ce que faisaient environ 10 caractères à la fois: P) L' úastuce est le génie, btw :-)
ETHproductions

@ETHproductions Je l'apprécie. Je ne suis pas trop bon en anglais donc merci
Luis felipe De jesus Munoz

1
Malheureusement, cela semble échouer lorsqu'il n'y a pas de lettres impliquées (elles ne doivent pas être modifiées). Une solution simple serait d'insérer un ñ oC ó¥, même si cela nécessite de rajouter dans le ;...
ETHproductions

Attendez ... depuis quand ñtravaillez-vous sur les cordes?! @ETHproductions, dites-moi s'il vous plaît que c'est un ajout récent et que je ne l'ai pas ignoré tout ce temps!
Shaggy

@Shaggy Apparemment, c'était il y a 2,5 mois - mais ne vous inquiétez pas, même j'avais oublié que cela existait jusqu'à cette réponse ;-)
ETHproductions

2

Rubis , 89 octets

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

Essayez-le en ligne!

J'ai essayé différentes approches, mais ce qui permet d'économiser beaucoup d'octets est d'ajouter un caractère à la fois.

Comment:

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

Il utilise une plage de caractères 'a'..'z'. Voir le script pour Powershell précédent ci-dessous.

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

Script de test expliqué:

$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"
}

Production:

True: Pppriooorritttieeesss
True: innvvooiccee
True: Rrremmmitttannnce Aadddvvviicce

Powershell 5.1-, 133 octets

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

2

Rouge , 252 octets

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

Essayez-le en ligne!

Solution ridiculement longue ...

Explication:

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 octets

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

Essayez-le en ligne!

+33 octets de ma première solution pour ces contraintes supplémentaires sans fin. JS craint les manipulations de chaîne insensibles à la casse que vous connaissez.

-3 octets en arrière Merci @Arnauld.

Explication

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

Les solutions doivent être capables de gérer des entrées mixtes.
Shaggy

@Shaggy Je pense que le défi a été modifié après votre commentaire. Il semble que le cas de la sortie n'ait pas d'importance.
Arnauld

En revanche, les fonctions doivent être réutilisables , ce qui n'est pas le cas ici.
Arnauld

@Arnauld Oh, je vois parfois que vous utilisez fs comme stockage temporaire, donc je pensais que ça allait
Shieru Asakoto

map()Les fonctions de rappel sont sûres à utiliser pour le stockage, car elles sont définies dans une portée locale. L'utilisation de la fonction principale - qui est définie globalement - est plus dangereuse. Ici, vous pouvez utiliser le rappel du premier map(), qui vous ramène à 137 octets .
Arnauld

2

Husk , 15 octets

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

Essayez-le en ligne!

Force brute, donc très lente.

Explication

ḟ§Ë#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).

n'a pas pu obtenir de résultats du tout
asmgx

@asmgx Le programme est vraiment très lent. Il semble expirer sur TIO pour les entrées de longueur 8 et plus, car il tue le calcul après 1 minute. L'interpréteur hors ligne devrait donner un résultat si vous attendez assez longtemps (probablement plusieurs heures pour des entrées de longueur 10).
Zgarb

2

Perl 6 , 77 70 octets

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

Essayez-le en ligne!

Prendre l'approche de GB d'insérer un caractère jusqu'à ce que tous les caractères apparaissent le même nombre de fois. Reçoit une chaîne qui est modifiée sur place.

Si les traits de soulignement peuvent être traités comme des lettres, l'expression régulière peut devenir /\w/, économisant deux octets.

Explication

{
                    .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 Il semble que votre amélioration repose sur l'ancienne version avant de découvrir l' {*}astuce.
nwellnhof

Donc, c'est comme un raccourci pour .value(s)ça? Bien, je devrai peut-être mettre à jour certaines de mes anciennes solutions
Jo King


1

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

Drapeau du compilateur -DF=;for(i=0;b[i];i++ -DB=b[i](29 octets)

Ajout de la prise en charge des cas mixtes.

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);}

Essayez-le en ligne!


1

Pyth, 31 30 octets

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

Essayez-le ici

Explication

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 octets

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);}

Non 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
}

Essayez-le en ligne!


0

Kotlin Android, 413 octets

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

Essayez en ligne

Explication étape 1 -> Sélectionnez la liste des caractères distincts. étape 2 -> Obtenez le nombre de chaque caractère dans la chaîne et sélectionnez la fréquence maximale de caractères. étape 3 -> obtenir la différence de fréquence des caractères par rapport à la fréquence maximale des caractères étape 4 -> placer les caractères par rapport aux positions dans la chaîne. Bonne résolution!



0

PHP ,185 173 170 octets

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;}

Essayez-le en ligne!

Non golfé (et non ternarié et non optimisé).

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; 
}
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.