19
\$\begingroup\$

Letters of the words want fairness.

They decided to appear same number of times in a sentence equally.

Example:

Priorities

Will become:

Ppprrioooritttieeesss

Each letter appears 3 times, as the most common letter was i, appearing 3 times.

It does not matter where you put the repeated letters, as long as they are next to a similar letter.

I.e.:

Pppriooorritttieeesss is OK (the 'r' letter)

Ppprioororitttieeesss is not OK (the 'r' letter)

Another example:

invoice

Will become:

innvvooiccee

Another example:

Remittance Advice

Will become:

Rrremmmiitttaannncce Adddvvvice

Space, comma, question mark, quotation, etc. are not considered letters for this challenge. Only need to consider [a-zA-Z]. Just once space is enough, and the order of the letters should remain the same.

The capitalization of letters does not matter, upper and lower case are countes as the same letter. That is: Pip has 2 'P's and 1 'I', so it will become Piip.

It is case insensitive letters can be in any form, Piip=piip=piiP=PiiP

This is

\$\endgroup\$
  • 2
    \$\begingroup\$ Might I suggest using the Sandbox for future challenges to help iron out all the details before posting the question to main \$\endgroup\$ – Jo King Oct 4 '18 at 7:19
  • \$\begingroup\$ Is " rrreeemmmiiitttaaannncccdddvvv" an acceptable output in the given example (since the order of the distinct letters (as defined as a-z) is still maintained)? (My Jelly answer currently relies on this interpretation being OK.) \$\endgroup\$ – Jonathan Allan Oct 4 '18 at 8:44
  • 1
    \$\begingroup\$ @JonathanAllan Hmm, although I leave the choice to OP, I highly doubt it. Not only are the non-letter characters (the space) gone, but you've also put all characters next to each other instead of keeping it at the same place. Your output makes the challenge different and easier (imho). \$\endgroup\$ – Kevin Cruijssen Oct 4 '18 at 9:15
  • 1
    \$\begingroup\$ @KevinCruijssen the space is at the left - it is not a letter hence does not need to adhere to "and the order of the letters should remain the same" \$\endgroup\$ – Jonathan Allan Oct 4 '18 at 9:35
  • 1
    \$\begingroup\$ @JonathanAllan Ah, didn't notice the space, my bad. I completely understand the reasoning you provided in your Jelly answer and based on that it's indeed a valid output, but I would rather see the phrasing changed, then allowing your output, since it would completely change the challenge itself. \$\endgroup\$ – Kevin Cruijssen Oct 4 '18 at 10:14

23 Answers 23

5
\$\begingroup\$

05AB1E, 16 bytes

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

Try it online!

Explanation

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
\$\endgroup\$
7
\$\begingroup\$

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

Try it online!

Base R approach :

  • stealing some ideas from @J.Doe R+stringr approach, I saved 26 bytes !
  • another 5 bytes saved using @J.Doe suggestion to abuse R + operator
\$\endgroup\$
  • \$\begingroup\$ I'm impressed you got to 111 with base-R! \$\endgroup\$ – J.Doe Oct 4 '18 at 10:36
  • \$\begingroup\$ @J.Doe : After publishing my original 137 bytes solution, I slightly changed my approach inspired by yours, and I basically converged to your solution, just with stringr removed :D \$\endgroup\$ – digEmAll Oct 4 '18 at 10:38
  • 1
    \$\begingroup\$ 106 bytes with operator abuse. Base-R wins! \$\endgroup\$ – J.Doe Oct 4 '18 at 10:52
  • \$\begingroup\$ @J.Doe: awesome ! \$\endgroup\$ – digEmAll Oct 4 '18 at 11:36
5
\$\begingroup\$

Perl 6, 82 bytes

-3 bytes thanks to nwellnhof

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

Try it online!

Takes a mutable string and modifies it in place.

Explanation:

->\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
\$\endgroup\$
  • \$\begingroup\$ You can chain the .= operator like a.=lc.=subst(...). I'm not sure whether changing the case of an existing letter is allowed though. Also <:L> instead of <:Ll>. \$\endgroup\$ – nwellnhof Oct 4 '18 at 9:08
  • \$\begingroup\$ @nwellnhof Yeah, the asker says that the output is case insensitive \$\endgroup\$ – Jo King Oct 4 '18 at 9:16
5
\$\begingroup\$

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

Try it online!

Commented

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
\$\endgroup\$
  • \$\begingroup\$ My JS skills suck, so I'm a bit confused about this part: o[l] = // updates o[l] to a non-numeric value. If I understand correctly, o is an integer-array in the F and g functions, but changes to a string-array holding one or more times the character c at the part I mentioned earlier? Also, I guess the values of o are undefined by default, since you are using o[l]=-~o[l] instead of ++o[l]? \$\endgroup\$ – Kevin Cruijssen Oct 4 '18 at 10:25
  • 1
    \$\begingroup\$ @KevinCruijssen We want each letter to be padded to the maximum number of occurrences only once. By updating o[l] to a letter, any subsequent iteration with the same letter will lead to m - o[l] --> NaN (integer minus letter) and l.repeat(NaN) == ''. (About the last point: yes, that's correct.) \$\endgroup\$ – Arnauld Oct 4 '18 at 10:30
  • \$\begingroup\$ Ah ok, thanks for the explanation! :) \$\endgroup\$ – Kevin Cruijssen Oct 4 '18 at 10:43
  • \$\begingroup\$ (and I should have said string rather than letter) \$\endgroup\$ – Arnauld Oct 4 '18 at 11:00
5
\$\begingroup\$

J, 33 56 46 bytes

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

Try it online!

Couldn't find a way to avoid using ~:tolower twice.

How it works

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
\$\endgroup\$
5
\$\begingroup\$

R + stringr, 108 bytes

I am not very good at stringr. Returns a mixture of lower and upper case since the question says it doesn't matter.

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}

Try it online!

Explanation

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
}
\$\endgroup\$
3
\$\begingroup\$

K4, 35 bytes

Solution:

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

Examples:

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"

Explanation:

Might be golfable with a different approach, will keep thinking

{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
\$\endgroup\$
3
\$\begingroup\$

Charcoal, 33 32 bytes

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

Try it online! Link is to verbose version of code. Explanation:

  θ                                 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
\$\endgroup\$
3
\$\begingroup\$

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 thanks to @Nevay.

Output is in full uppercase.

Try it online. (NOTE: String.repeat(int) is emulated as repeat(String,int) for the same byte-count, because Java 11 isn't on TIO yet.)

Explanation:

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
\$\endgroup\$
  • \$\begingroup\$ Can you use var for a byte? \$\endgroup\$ – Quintec Oct 4 '18 at 11:42
  • \$\begingroup\$ @Quintec Instead of the char you mean? Unfortunately no. var can only be used for single fields. So instead of char m=1,i=127,a[]=new char[i]; it would be var m=1;var i=127;var a=new char[i];. Here a useful tip of what you can and cannot do with Java 10's var. (I could replace the int in the loop with var, but the byte-count would remain the same.) \$\endgroup\$ – Kevin Cruijssen Oct 4 '18 at 11:44
  • \$\begingroup\$ Gotcha, thanks. Still have no idea how Java 9/10/11 work, haha, I’ll stick to 8 ;p \$\endgroup\$ – Quintec Oct 4 '18 at 11:51
  • \$\begingroup\$ @Quintec Java 9 I also don't really get, since it's mainly focussed on that REPL. Java 10 is mostly the same as Java 8, except for the var. And Java 11 barely has any changes at all codegolf related, except for the String.repeat method that I've used loads of times already. It also has the new String.stripLeading or String.stripTrailing, which act like trim but only the leading/trailing whitespaces, and String.isBlank() which is the same as String.trim().isEmpty() (empty or whitespace only). \$\endgroup\$ – Kevin Cruijssen Oct 4 '18 at 11:59
  • 1
    \$\begingroup\$ -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;} \$\endgroup\$ – Nevay Oct 4 '18 at 16:28
3
\$\begingroup\$

Japt -h, 27 bytes

-3 bytes from @ETHproductions

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

Trying to explain

;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

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ Hope you don't mind, I expanded part of the explanation (that one line that was explaining what about 10 chars did at once :P) The ú trick is genius, btw :-) \$\endgroup\$ – ETHproductions Oct 5 '18 at 17:59
  • \$\begingroup\$ @ETHproductions I appreciate it. Im not too good at English so thanks \$\endgroup\$ – Luis felipe De jesus Munoz Oct 5 '18 at 18:01
  • 1
    \$\begingroup\$ Unfortunately, it seems to fail when there's non-letters involved (they should not be changed). A simple fix would be to insert an ñ oC ó¥, though it requires adding back in the ;... \$\endgroup\$ – ETHproductions Oct 5 '18 at 18:35
  • \$\begingroup\$ Wait ... since when did ñ work on strings?! @ETHproductions, please tell me that's a recent addition and I haven't been overlooking it all this time! \$\endgroup\$ – Shaggy Oct 6 '18 at 0:38
  • \$\begingroup\$ @Shaggy Apparently it was 2.5 months ago--but don't worry, even I'd forgotten it existed until this answer ;-) \$\endgroup\$ – ETHproductions Oct 6 '18 at 2:38
2
\$\begingroup\$

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}

Try it online!

I tried different approaches, but what really saves a lot of bytes is adding one character at a time.

How:

->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
\$\endgroup\$
2
\$\begingroup\$

Powershell 6, 123 bytes

It uses a char range 'a'..'z'. See script for previous Powershell below.

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

Explained test script:

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

Output:

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
\$\endgroup\$
2
\$\begingroup\$

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

Try it online!

Ridiculously long solution...

Explanation:

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)
        ]
    ]
]
\$\endgroup\$
2
\$\begingroup\$

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

Try it online!

+33 bytes from my first solution for those never-ending additional constraints. JS sucks at case-insensitive string manipulations you know.

-3 bytes back Thanks @Arnauld.

Explanation

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
\$\endgroup\$
  • \$\begingroup\$ Solutions needs to be able to handle mixed-case inputs. \$\endgroup\$ – Shaggy Oct 4 '18 at 7:15
  • \$\begingroup\$ @Shaggy I think the challenge has been edited after your comment. It seems like the case of the output doesn't matter. \$\endgroup\$ – Arnauld Oct 4 '18 at 18:53
  • \$\begingroup\$ On the other hand, functions must be reusable, which is not the case here. \$\endgroup\$ – Arnauld Oct 4 '18 at 18:54
  • \$\begingroup\$ @Arnauld Oh I sometimes see you using fs as temporary storage so I thought that's okay \$\endgroup\$ – Shieru Asakoto Oct 5 '18 at 1:06
  • \$\begingroup\$ map() callback functions are safe to use for storage, because they're defined in a local scope. Using the main function -- which is globally defined -- is more hazardous. Here, you can use the callback of the first map(), which brings you back to 137 bytes. \$\endgroup\$ – Arnauld Oct 5 '18 at 6:40
2
\$\begingroup\$

Husk, 15 bytes

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

Try it online!

Brute force, so very slow.

Explanation

ḟ§Ë#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).
\$\endgroup\$
  • \$\begingroup\$ could not get results at all \$\endgroup\$ – asmgx Oct 6 '18 at 3:42
  • \$\begingroup\$ @asmgx The program is just really slow. It seems to time out on TIO for inputs of length 8 and longer, because it kills the computation after 1 minute. The offline interpreter should give a result if you wait long enough (probably several hours for length-10 inputs). \$\endgroup\$ – Zgarb Oct 6 '18 at 5:23
2
\$\begingroup\$

Perl 6, 77 70 bytes

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

Try it online!

Taking G B's approach of inserting a character until all characters appear the same number of times. Receives a string that is modified in-place.

If underscores can be treated like letters, the regex can become /\w/, saving two bytes.

Explanation

{
                    .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
}
\$\endgroup\$
  • \$\begingroup\$ @JoKing It seems that your improvement is based on the old version before I discovered the {*} trick. \$\endgroup\$ – nwellnhof Jan 20 at 15:14
  • \$\begingroup\$ So that"s like a shortcut for .value(s) is it? Neat, I may have to update some of my old solutions \$\endgroup\$ – Jo King Jan 20 at 23:40
1
\$\begingroup\$

Python 2, 97 117 bytes

s=input().upper()
S=''
for c in s:S+=c+c*(max(map(s.count,map(chr,range(65,91))))-(S+s).count(c))*('@'<c<'[')
print S

Try it online!

\$\endgroup\$
  • \$\begingroup\$ @JoKing Fixed,. \$\endgroup\$ – TFeld Oct 4 '18 at 7:40
1
\$\begingroup\$

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

Compiler flag -DF=;for(i=0;b[i];i++ -DB=b[i] (29 bytes)

Added mixed case support.

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Pyth, 31 30 bytes

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

Try it here

Explanation

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.
\$\endgroup\$
1
\$\begingroup\$

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

Ungolfed

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
}

Try it online!

\$\endgroup\$
0
\$\begingroup\$

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

Try online

Explanation step 1 --> Select list of distinct chars. step 2 --> Get count of every char in string and select max char frequency. step 3 --> get difference in frequency of chars with respect to max char frequency step 4 --> place chars with respect to positions in string. Happy Solving !

\$\endgroup\$
0
\$\begingroup\$

C# (Visual C# Interactive Compiler), 145 bytes

x=>x.ToLower().Select((a,b)=>x.IndexOf(a)==b&char.IsLetter(a)?a+new String(a,x.GroupBy(d=>x.Count(e=>e==d)).Max(d=>d.Key)-x.Count(d=>d==a)):a+"")

Try it online!

\$\endgroup\$
0
\$\begingroup\$

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

Try it online!

Ungolfed (and un-ternaried and un-optimized).

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; 
}
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.