Te same cyfry

19

Litery słów chcą sprawiedliwości.

Postanowili pojawić się jednakowo tyle samo razy w zdaniu.

Przykład:

Priorities

Stanie się:

Ppprrioooritttieeesss

Każda litera pojawia się 3 razy, jak najczęściej i, pojawia się 3 razy.

Nie ma znaczenia, gdzie umieszczasz powtarzające się litery, o ile znajdują się obok podobnej litery.

To znaczy:

Pppriooorritttieeesss jest OK (litera „r”)

Ppprioororitttieeesss nie jest OK (litera „r”)

Inny przykład:

invoice

Stanie się:

innvvooiccee

Inny przykład:

Remittance Advice

Stanie się:

Rrremmmiitttaannncce Adddvvvice

Spacja, przecinek, znak zapytania, cytat itp. Nie są traktowane jako litery do tego wyzwania. Trzeba tylko wziąć pod uwagę [a-zA-Z]. Tylko raz wystarczy miejsca, a kolejność liter powinna pozostać taka sama.

Wielkie litery nie mają znaczenia, wielkie i małe litery są liczone jako ta sama litera. To znaczy: Pipma 2 „P” i 1 „I”, więc się stanie Piip.

Litery bez rozróżniania wielkości liter mogą mieć dowolną formę, Piip=piip=piiP=PiiP

To jest

asmgx
źródło
2
Czy mogę zasugerować użycie Piaskownicy do przyszłych wyzwań, aby pomóc w ustaleniu wszystkich szczegółów przed wysłaniem pytania do głównego
Jo King
Czy „rrreeemmmiiitttaaannncccdddvvv” jest akceptowalnym wyjściem w podanym przykładzie (ponieważ nadal zachowana jest kolejność oddzielnych liter (zdefiniowanych jako az))? (Moja odpowiedź na Jelly polega obecnie na tym, że ta interpretacja jest OK.)
Jonathan Allan,
1
@JonathanAllan Hmm, chociaż pozostawiam wybór OP, bardzo w to wątpię. Nie tylko zniknęły znaki nieliterowe (spacja), ale wszystkie znaki zostały umieszczone obok siebie, zamiast trzymać je w tym samym miejscu. Twoje wyniki sprawiają, że wyzwanie jest inne i łatwiejsze (imho).
Kevin Cruijssen
1
@KevinCruijssen przestrzeń jest po lewej stronie - nie jest to litera, dlatego nie trzeba się jej trzymać „a kolejność liter powinna pozostać taka sama”
Jonathan Allan,
1
@JonathanAllan Ah, nie zauważyłem miejsca, moje złe. W pełni rozumiem uzasadnienie podane w odpowiedzi na Jelly i na podstawie tego, że jest to rzeczywiście poprawny wynik, ale wolałbym, aby frazowanie zmieniło się, a następnie pozwoliło na wyjście, ponieważ całkowicie zmieniłoby ono samo wyzwanie.
Kevin Cruijssen

Odpowiedzi:

5

05AB1E , 16 bajtów

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

Wypróbuj online!

Wyjaśnienie

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
Emigna
źródło
7

R , 106 bajtów

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

Wypróbuj online!

Podejście bazowe R:

  • kradnąc kilka pomysłów z @ J.Doe R + stringr , zapisałem 26 bajtów!
  • kolejne 5 bajtów zapisanych przy użyciu sugestii @ J.Doe do nadużycia +operatora R.
digEmAll
źródło
Jestem pod wrażeniem, że dostałeś 111 z base-R!
J.Doe
@ J.Doe: Po opublikowaniu mojego oryginalnego 137-bajtowego rozwiązania nieznacznie zmieniłem swoje podejście zainspirowane twoim i po prostu zszedłem do twojego rozwiązania, tylko z usuniętym stringr: D
digEmAll
1
106 bajtów z nadużyciem operatora. Wygrywa Base-R!
J.Doe
@ J.Doe: awesome!
digEmAll
5

Perl 6 , 82 bajtów

-3 bajty dzięki nwellnhof

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

Wypróbuj online!

Pobiera zmienny ciąg i modyfikuje go na miejscu.

Wyjaśnienie:

->\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
Jo King
źródło
Możesz połączyć .=operatora jak a.=lc.=subst(...). Nie jestem jednak pewien, czy zmiana wielkości liter w istniejącym liście jest dozwolona. Również <:L>zamiast <:Ll>.
nwellnhof,
@nwellnhof Tak, pytający mówi, że wielkość liter nie uwzględnia wielkości liter
Jo King,
5

JavaScript (ES6), 112 bajtów

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

Wypróbuj online!

Skomentował

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
Arnauld
źródło
Umiejętności My JS ssać, więc jestem trochę zdezorientowany o tej części: o[l] = // updates o[l] to a non-numeric value. Jeśli dobrze rozumiem, oto tablica liczb całkowitych w funkcjach Fi g, ale zmienia się w tablicę ciągów zawierającą jeden lub więcej znakówc w części, o której wspomniałem wcześniej? Sądzę też, że wartości oundefineddomyślnie, ponieważ używasz o[l]=-~o[l]zamiast ++o[l]?
Kevin Cruijssen
1
@KevinCruijssen Chcemy, aby każda litera została dopełniona do maksymalnej liczby wystąpień tylko raz. Poprzez aktualizację o[l]do litery, każda kolejna iteracja z tą samą literą doprowadzi do m - o[l] --> NaN(liczba całkowita minus litera) i l.repeat(NaN) == ''. (O ostatnim punkcie: tak, zgadza się.)
Arnauld
Ach, ok, dzięki za wyjaśnienie! :)
Kevin Cruijssen
(i powinienem był powiedzieć ciąg zamiast liter )
Arnauld
5

J , 33 56 46 bajtów

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

Wypróbuj online!

Nie można znaleźć sposobu na uniknięcie ~:tolowerdwukrotnego użycia .

Jak to działa

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
Bubbler
źródło
5

R + stringr, 108 bajtów

Nie jestem zbyt dobry w stringr. Zwraca mieszaninę małych i wielkich liter, ponieważ pytanie mówi, że to nie ma znaczenia.

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}

Wypróbuj online!

Wyjaśnienie

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
}
J.Doe
źródło
3

K4 , 35 bajtów

Rozwiązanie:

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

Przykłady:

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"

Wyjaśnienie:

Może być golfa z innym podejściem, będzie myśleć

{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
streetster
źródło
3

Węgiel drzewny , 33 32 bajty

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

  θ                                 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
Neil
źródło
3

Java 11, 190 176 162 bajtów

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 bajtów dzięki @Nevay .

Dane wyjściowe są pisane wielkimi literami.

Wypróbuj online. (UWAGA: String.repeat(int)jest emulowany jakorepeat(String,int) dla tej samej liczby bajtów, ponieważ Java 11 nie jest jeszcze w TIO).

Wyjaśnienie:

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
Kevin Cruijssen
źródło
Czy możesz użyć var ​​jako bajtu?
Quintec,
@Quintec Zamiast na charmyśli? Niestety nie. varmoże być użyty tylko dla pojedynczych pól. Więc zamiast char m=1,i=127,a[]=new char[i];tego byłoby var m=1;var i=127;var a=new char[i];. Oto przydatna wskazówka dotycząca tego, co możesz, a czego nie możesz zrobić w Javie 10 var. (Mógłbym zamienić intpętlę na var, ale liczba bajtów pozostanie taka sama.)
Kevin Cruijssen
Gotcha, dzięki. Nadal nie mam pojęcia, jak działa Java 9/10/11, haha, pozostanę przy 8; p
Quintec,
@Quintec Java 9 Ja też tak naprawdę nie rozumiem, ponieważ głównie skupia się na REPL. Java 10 jest w większości taka sama jak Java 8, z wyjątkiem var. A Java 11 prawie nie ma żadnych zmian związanych z kodegolfem, z wyjątkiem String.repeatmetody, której już używałem wiele razy. Ma także nowe String.stripLeadinglub String.stripTrailing, które działają jak, trimale tylko wiodące / końcowe białe spacje, i String.isBlank()które są takie same jak String.trim().isEmpty()(tylko puste lub tylko białe spacje).
Kevin Cruijssen
1
-14 bajtów: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 bajtów

-3 bajty z @ETHproductions

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

Próbuję wyjaśnić

;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

Wypróbuj online!

Luis Felipe De Jesus Munoz
źródło
1
Mam nadzieję, że nie masz nic przeciwko, rozwinąłem część objaśnienia (ten wiersz, który wyjaśniał, co zrobiło około 10 znaków jednocześnie: P) úSztuczka jest
genialna
@ETHproductions Doceniam to. Nie jestem zbyt dobry w języku angielskim, więc dziękuję
Luis Felipe De Jesus Munoz
1
Niestety wydaje się, że zawodzi, gdy w grę wchodzą nieliterowe litery (nie należy ich zmieniać). Prostym rozwiązaniem byłoby wstawienie ñ oC ó¥, choć wymaga dodania z powrotem do ;...
ETHproductions
Poczekaj ... od kiedy to ñdziałało na łańcuchach ?! @ETHproductions, proszę powiedz mi, że to najnowszy dodatek i nie przeoczyłem go przez cały ten czas!
Kudłaty,
@Shaggy Najwyraźniej to było 2,5 miesiąca temu - ale nie martw się, nawet zapomniałem, że istniało aż do tej odpowiedzi ;-)
ETHproductions
2

Rubinowy , 89 bajtów

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

Wypróbuj online!

Próbowałem różnych podejść, ale to, co naprawdę oszczędza wiele bajtów, polega na dodawaniu jednego znaku na raz.

W jaki sposób:

->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
GB
źródło
2

PowerShell 6, 123 bajty

Używa zakresu char 'a'..'z'. Zobacz skrypt dla poprzedniej Powershell poniżej.

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

Wyjaśniony skrypt testowy:

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

Wynik:

True: Pppriooorritttieeesss
True: innvvooiccee
True: Rrremmmitttannnce Aadddvvviicce

PowerShell 5.1-, 133 bajty

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

Czerwony , 252 bajty

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

Wypróbuj online!

Śmiesznie długie rozwiązanie ...

Wyjaśnienie:

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)
        ]
    ]
]
Galen Iwanow
źródło
2

JavaScript (Node.js) , 140 137 bajtów

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

Wypróbuj online!

+33 bajtów od mojego pierwszego rozwiązania dla tych niekończących się dodatkowych ograniczeń. JS jest do bani z powodu nierozróżniających wielkości liter manipulacji ciągami, które znasz.

-3 bajty wstecz Dzięki @Arnauld.

Wyjaśnienie

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
Shieru Asakoto
źródło
Rozwiązania muszą być w stanie obsługiwać dane wejściowe o różnej wielkości liter.
Kudłaty
@Shaggy Myślę, że wyzwanie zostało edytowane po twoim komentarzu. Wygląda na to, że przypadek wyjścia nie ma znaczenia.
Arnauld,
Z drugiej strony funkcje muszą być wielokrotnego użytku , co nie ma miejsca w tym przypadku.
Arnauld
@Arnauld Oh Czasami widzę, że używasz fs jako tymczasowego magazynu, więc pomyślałem, że to w porządku
Shieru Asakoto
map()funkcji oddzwaniania można bezpiecznie używać do przechowywania, ponieważ są zdefiniowane w zasięgu lokalnym. Korzystanie z głównej funkcji - która jest zdefiniowana globalnie - jest bardziej niebezpieczne. Tutaj możesz użyć wywołania zwrotnego pierwszego map(), co spowoduje powrót do 137 bajtów .
Arnauld,
2

Łuska , 15 bajtów

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

Wypróbuj online!

Brutalna siła, bardzo wolna.

Wyjaśnienie

ḟ§Ë#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).
Zgarb
źródło
w ogóle nie można uzyskać wyników
asmgx
@asmgx Program jest po prostu bardzo wolny. Wydaje się, że przekroczył limit czasu dla TIO dla danych wejściowych o długości 8 i większej, ponieważ zabija obliczenia po 1 minucie. Tłumacz offline powinien dać wynik, jeśli zaczekasz wystarczająco długo (prawdopodobnie kilka godzin na dane o długości 10).
Zgarb,
2

Perl 6 , 77 70 bajtów

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

Wypróbuj online!

Podejście GB do wstawiania znaku, dopóki wszystkie znaki nie pojawią się tyle samo razy. Otrzymuje ciąg, który jest modyfikowany w miejscu.

Jeśli podkreślenia można traktować jak litery, wyrażenie regularne może stać się /\w/, oszczędzając dwa bajty.

Wyjaśnienie

{
                    .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
}
nwellnhof
źródło
@JoKing Wygląda na to, że twoje ulepszenie opiera się na starej wersji, zanim odkryłem {*}sztuczkę.
nwellnhof
To jest skrót, .value(s)prawda? Zgrabne, być może będę musiał zaktualizować niektóre z moich starych rozwiązań
Jo King
1

Python 2 , 97 117 bajtów

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

Wypróbuj online!

TFeld
źródło
@JoKing Naprawiono.
TFeld
1

C (clang) , 246 223 220 210 208 193 188 bajtów

Flaga kompilatora -DF=;for(i=0;b[i];i++ -DB=b[i](29 bajtów)

Dodano obsługę mieszanych przypadków.

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

Wypróbuj online!

Logern
źródło
1

Pyth, 31 30 bajtów

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

Wypróbuj tutaj

Wyjaśnienie

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.

źródło
1

C (GCC) - 175 bajtów

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

Nie golfił

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
}

Wypróbuj online!

Śpi
źródło
0

Kotlin Android, 413 bajtów

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

Wypróbuj online

Objaśnienie krok 1 -> Wybierz listę różnych znaków. krok 2 -> Zlicz liczbę znaków w ciągu i wybierz maksymalną częstotliwość znaków. krok 3 -> uzyskaj różnicę w częstotliwości znaków w stosunku do maksymalnej częstotliwości znaków krok 4 -> umieść znaki w odniesieniu do pozycji w łańcuchu. Happy Solving!

Syed Hamza Hassan
źródło
0

PHP ,185 173 170 bajtów

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

Wypróbuj online!

Nieskluczone (i nieskonfigurowane i niezoptymalizowane).

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; 
}
640 KB
źródło