Vous fournissez un support technique à la Bruce Dickenson comme il produit une session d'enregistrement Blue Öyster Cult. Quand il demande plus de cloche , vous pouvez le lui donner.

Ta tâche

Ecrivez un programme ou une fonction prenant une chaîne (ou son équivalent dans votre langue) en entrée et générant une chaîne associée contenant une cloche supplémentaire.

Combien de clochettes une corde contient-elle?

Le nombre de clochettes qu'une chaîne contient contient le nombre maximal de copies distinctes de "clochette" pouvant être obtenues en permutant les caractères de la chaîne. Par exemple, "bbbccceeellllllooowwwwwwwww"contient 3 clochettes, tandis "bbccceeellllllooowwwwwwwww"que "bbbccceeelllllooowwwwwwwww"chacune contient 2 clochettes et "cowbel"0 clochettes.

Comment la sortie devrait-elle être liée à l'entrée?

La sortie doit consister en la concaténation, dans cet ordre, de la chaîne d'entrée et du préfixe le plus court de la chaîne d'entrée nécessaire pour augmenter le nombre de clochettes.

Par exemple, un "bbbccceeelllllooowwwwwwwww"seul élément supplémentaire suffit "l"pour contenir 3 clochettes au lieu de 2; le préfixe le plus court qui contient "l"c'est "bbbccceeel". Par conséquent, si l'entrée est "bbbccceeelllllooowwwwwwwww", la sortie doit l'être "bbbccceeelllllooowwwwwwwwwbbbccceeel".

Les aspects techniques

• Vous pouvez supposer que l'entrée ne contient que des caractères ASCII imprimables. Si un ou deux caractères sont gênants pour le traitement des chaînes de votre langue (tels que les nouvelles lignes ou \), vous pouvez supposer que l'entrée ne les contient pas - il suffit de mentionner cette restriction.
• Vous pouvez en outre supposer que les caractères alphabétiques de l'entrée sont tous en minuscules ou en majuscules. Si vous choisissez de ne pas en assumer l’une, comptez les cloches sans distinction de casse.
• Vous pouvez en outre supposer que l'entrée contient au moins une copie de chacun des caractères b, c, e, l, o, et w. Cela revient à supposer que certains préfixes de la chaîne peuvent lui être concaténés pour produire une chaîne contenant plus de sonnailles. (Notez que la chaîne d'entrée elle-même n'a pas besoin de contenir une cloche.)
• Si votre langue a un langage intégré qui résout ce problème ... alors utilisez-le totalement, sérieusement, comme c'est génial.

Couches plaquées or

Comme le temps d’enregistrement en studio est coûteux, votre code doit être aussi court que possible. L'entrée avec le moins d'octets est le gagnant!

Cas de test

( lien pastebin pour un copier / coller plus facile)

Test d'entrée n ° 1: "christopher walken begs for more cowbell!"

Test de sortie n ° 1: "christopher walken begs for more cowbell!christopher wal"

Test d'entrée n ° 2: "the quick brown fox jumps over the lazy dog"

Test de sortie n ° 2: "the quick brown fox jumps over the lazy dogthe quick brown fox jumps over the l"

Test d'entrée n ° 3: "cowbell"

Test de sortie n ° 3: "cowbellcowbell"

Test d'entrée n ° 4: "cowbell cowbell cowbell"

Test de sortie n ° 4: "cowbell cowbell cowbellcowbell"

Test d'entrée n ° 5: "cowbell cowbell cowbel"

Test de sortie n ° 5: "cowbell cowbell cowbelcowbel"

Entrée de test n ° 6: "bcelow"

Test de sortie n ° 6: "bcelowbcel"

Test d'entrée n ° 7: "abcdefghijklmnopqrstuvwxyz"

Test de sortie n ° 7: "abcdefghijklmnopqrstuvwxyzabcdefghijkl"

Entrée de test n ° 8: "cccowwwwbbeeeeelllll"

Test de sortie n ° 8: "cccowwwwbbeeeeelllllccco"

Entrée de test n ° 9: "be well, programming puzzles & code golf"

Test de sortie n ° 9: "be well, programming puzzles & code golfbe well, programming puzzles & c"

Test d'entrée n ° 10: "lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. wow!"

Test de sortie n ° 10: "lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. wow!lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut lab"

Entrée de test n ° 11:

"c-c-b-c

i have a cow, i have a bell.
uh! bell-cow!
i have a cow, i have a cowbell.
uh! cowbell-cow!

bell-cow, cowbell-cow.
uh! cow-cowbell-bell-cow.
cow-cowbell-bell-cow!
"

Test de sortie n ° 11:

"c-c-b-c

i have a cow, i have a bell.
uh! bell-cow!
i have a cow, i have a cowbell.
uh! cowbell-cow!

bell-cow, cowbell-cow.
uh! cow-cowbell-bell-cow.
cow-cowbell-bell-cow!
c-c-b-c

i have a cow, i have a bell"

Pip , 50 42 38 octets

T$<(MN{_NaM"lcowbe"}//^2M[aYa@<i])++iy

Passez la chaîne en tant qu’argument de ligne de commande, entre guillemets si nécessaire. Essayez-le en ligne!

Explication

Je vais expliquer cela en deux parties: la fonction cloche et le programme complet. Premièrement, voici la fonction qui calcule la quantité de cloche dans une chaîne:

MN{_NaM"lcowbe"}//^2

{...}définit une fonction. De nombreux opérateurs de pip, lorsqu'ils sont appliqués à une fonction, renvoient une autre fonction. par exemple, -{a+1}est le même que {-(a+1)}. Donc, ce qui précède est équivalent à

{MN(_NaM"lcowbe")//^2}

qui fonctionne comme suit:

{                    }  Function, in which a is the 1st argument (the string)
    _Na                 Lambda fn: returns number of times its argument occurs in a
       M"lcowbe"        Map that function to the characters of "lcowbe"
                   ^2   A devious way to get [2]: split the scalar 2 into characters
   (            )//     Int-divide the list of character counts by [2]
                        Since the lists are not the same length, this divides the first
                          element (# of l's) by 2 and leaves the others alone
 MN                     Take the min of the resulting list

Maintenant que nous avons cela, voici le programme complet:

T$<(MN{_NaM"lcowbe"}//^2M[aYa@<i])++iy
                                        a is 1st cmdline arg, i is 0 (implicit)
T                                       Loop till condition is true:
                            a@<i        Slice leftmost i characters of a
                           Y            Yank that into y variable
                         [a     ]       List containing a and that value
                        M               To that list, map...
    MN{_NaM"lcowbe"}//^2                ... the cowbell function
                                        Result: a list containing the amount of cowbell
                                        in the original string and the amount in the slice
 $<(                             )      Fold on less-than: true if the first element is
                                        less than the second, otherwise false
                                  ++i   In the loop, increment i
                                     y  Once the loop exits, print y (the latest slice)

C, 511 488 474 470 463 454

void f(char*a){char*s;int i=-1,c,o,w,b,e=b=w=o=c=1,l=3,n,r,z=i;for(;s=a[++i];c+=s==67,o+=s==79,w+=s==87,b+=s==66,e+=s==69,l+=s==76);r=~-l/2;n=c<o?c:o;n=w<n?w:n;n=b<n?b:n;n=e<n?e:n;n=r<n?r:n;c=c==n;o=o==n;w=w==n;b=b==n;e=e==n;if(l=r==n?l:0)if(l%2)l=2;else l=1,c=o=w=b=e=0;else l+=l%2;n=c+o+w+b+e+l;for(printf("%s",a);s=n?a[++z]:0;s==67&&c?n--,c--:0,s==79&&o?n--,o--:0,s==87&&w?n--,w--:0,s==66&&b?n--,b--:0,s==69&&e?n--,e--:0,s==76&&l?n--,l--:0,putchar(s));}

Essayez-le en ligne

Format lisible + explication:

void f(char*a){
//a = input

    char*s;

    int i=-1,c,o,w,b,e=b=w=o=c=1,l=3,n,r,z=i;//c,o,w,b,e all start at 1; L starts at 3

    for(;s=a[++i];c+=s==67,o+=s==79,w+=s==87,b+=s==66,e+=s==69,l+=s==76);
    //loop to obtain number of times each character C,O,W,B,E,L is found in string (using the ASCII numeric values of each letter)

    //to get an extra cowbell we need to increment C,O,W,B,E by 1 and L by 2 (two Ls in cowbell); except we don't have to because we already did that by starting them at c=1, o=1, w=1, b=1, e=1, L=3 when we declared them. 

    r=~-l/2;
    //r is half of (1 less the number of times L is in string (+ init value))

    n=c<o?c:o;n=w<n?w:n;n=b<n?b:n;n=e<n?e:n;n=r<n?r:n;
    //n is the number of times that the least occouring character appears in the string, (use R instead of L since cowbell has two L's in it and we just need ~-l/2)

    c=c==n;o=o==n;w=w==n;b=b==n;e=e==n;
    //convert c,o,w,b,e to BOOL of whether or not we need 1 more of that letter to create one more cowbell (logic for L handled below since it's trickier)

    if(l=r==n?l:0)//if L-1/2 is [or is tied for] least occurring character do below logic, else set l to 0 and skip to `else`
        if(l%2)//if l is divisible by 2 then we need 2 more Ls
            l=2;
        else //otherwise we just need 1 more l and no other letters
            l=1,c=o=w=b=e=0;
    else //add 1 to L if it's divisible by 2 (meaning just 1 more L is needed in addition to possibly other C,O,W,B,E letters) (*Note: L count started at 3, so a count of 4 would be divisible by 2 and there is only 1 L in the string)
        l+=l%2;

    n=c+o+w+b+e+l;
    //n = number of specific characters we need before we reach 1 more cowbell

    for(printf("%s",a);s=n?a[++z]:0;s==67&&c?n--,c--:0,s==79&&o?n--,o--:0,s==87&&w?n--,w--:0,s==66&&b?n--,b--:0,s==69&&e?n--,e--:0,s==76&&l?n--,l--:0,putchar(s));
    //loop starts by printing the original string, then starts printing it again one character at a time until the required number of C,O,W,B,E,L letters are reached, then break (s=n?a[++z]:0) will return 0 when n is 0. Each letter subtracts from n only when it still requires letters of its type (e.g. b?n--,b--:0)

}

Quelques astuces amusantes utilisées:

• Lors de la vérification des caractères que je tape 'w'pour le caractère w qui est de 3 octets, mais pour les caractères 'c'et 'b'je peux saisir leurs valeurs ASCII 99 et 98 respectivement pour sauvegarder un octet à chaque fois. (Edit: Merci à @Titus, je sais le faire avec toutes les lettres COWBELL en utilisant uniquement des majuscules qui sont toutes des valeurs ascii numériques de 2 octets)

• r=~-l/2est r=(l-1)/2utilise bitshifts

• a[++i]Je reçois le caractère à l’index (i) et je le répète en même temps. Je commence juste par iau i=-1lieu de i=0(je fais la même chose avec zet le lance comme z=ipour sauvegarder un autre octet)

Python 2, 125 113 112 octets

n=lambda s:min(s.count(c)>>(c=='l')for c in "cowbel")
def f(s,i=0):
 while n(s)==n(s+s[:i]):i+=1
 return s+s[:i]

n compte le nombre de clochettes

-12 octets grâce à @Rod
-1 octet grâce à @Titus

Perl 6 , 91 octets

{my &c={.comb.Bag.&{|.<c o w b e>,.<l>div 2}.min}
first *.&c>.&c,($_ X~[\,](.comb)».join)}

Suppose une entrée en minuscule.

Comment ça marche

À l'intérieur du lambda, un autre lambda servant à compter le nombre de clochettes dans une chaîne est défini comme tel:

my &c={                                        }  # Lambda, assigned to a variable.
       .comb                                      # Split the string into characters.
            .Bag                                  # Create a Bag (maps items to counts).
                .&{                       }       # Transform it into:
                   |.<c o w b e>,                 #   The counts of those letters, and
                                 .<l>div 2        #   half the count of "l" rounded down.
                                           .min   # Take the minimum count.

Le reste du code utilise ce lambda interne &cpour trouver le résultat, comme ceci:

                     [\,](.comb)».join   # All prefixes of the input,
               ($_ X~                 )  # each appended to the input.
first         ,                          # Return the first one for which:
      *.&c>                              #   The cowbell count is greater than
           .&c                           #   the cowbell count of the input.

MATL , 38 37 octets

1 byte off grâce à l'idée de @ DLosc d'utiliser le modèle de chaîne lcowbeau lieu decowbel

n`Gt@q:)hXK!'lcowbe'=s32BQ/kX<wy-Q]xK

Les caractères d'entrée sont tous en minuscules. Si l'entrée contient des sauts de ligne, le caractère de nouvelle ligne doit être saisi en tant que code ASCII concaténé avec les caractères normaux (voir la dernière entrée dans le lien avec tous les scénarios de test).

Essayez-le en ligne! Ou vérifiez tous les cas de test .

JavaScript (ES6), 106 107 113 126 141

Un portage en javascript de la réponse du Pip par @DLosc. Il me fallait un peu de temps pour bien le comprendre et c'est un génie.

Éditez -15 octets en suivant l'indice de @Titus, en ajoutant directement des caractères à la chaîne d'entrée aet en évitant un retour rapide (donc non for/if)

Edit 2 en énumérant la valeur 6 pour la fonction Min enregistre 13 octets supplémentaires

Edit 3 a de nouveau changé de fonction. Je pensais que le verbeux lengthet splitserait trop long. J'avais tort.

En supposant que les minuscules soient saisies

a=>[...a].some(z=>c(a+=z)>b,c=a=>Math.min(...[...'lcowbe'].map((c,i)=>~-a.split(c).length>>!i)),b=c(a))&&a

Moins golfé

a=>{
  c=a=>{ // cowbell functions - count cowbells
    k = [... 'lcowbe'].map((c,i) => 
          (a.split(c).length - 1) // count occurrences of c in a
           / (!i + 1) // divide by 2 if first in list ('l')
    );
    return Math.min(...k);
  };
  b = c(a); // starting number of cowbells
  [...a].some(z => ( // iterate for all chars of a until true
    a += z,
    c(a) > b // exit when I have more cowbells
  ));
  return a;
}

Tester

f=
a=>[...a].some(z=>c(a+=z)>b,c=a=>Math.min(...[...'lcowbe'].map((c,i)=>~-a.split(c).length>>!i)),b=c(a))&&a

;["christopher walken begs for more cowbell!"
,"the quick brown fox jumps over the lazy dog"
,"cowbell"
,"cowbell cowbell cowbell"
,"cowbell cowbell cowbel"
,"bcelow"
,"abcdefghijklmnopqrstuvwxyz"
,"cccowwwwbbeeeeelllll"
,"be well, programming puzzles & code golf"
,"lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. wow!"
,`c-c-b-c
 
i have a cow, i have a bell.
uh! bell-cow!
i have a cow, i have a cowbell.
uh! cowbell-cow!
 
bell-cow, cowbell-cow.
uh! cow-cowbell-bell-cow.
cow-cowbell-bell-cow!
`].forEach(x=>console.log(x+'\n\n'+f(x)))

Utilitaires Bash + Unix, 184 octets

f()(tr -cd cowbel<<<"$1"|sed 's/\(.\)/\1\
/g'|sort|uniq -c|awk '{print int($1/(($2=="l")?2:1))}'|sort -n|head -1)
for((m=1;`f "$1${1:0:m}"`!=$[`f "$1"`+1];m++)){ :;}
echo "$1${1:0:$m}"

Essayez-le en ligne!

Merci à @AlbertRenshaw pour avoir joué au golf 2 octets.

JavaScript (ES6), 124 114 octets

Merci à Neil pour avoir économisé quelques octets

a=>eval("for(c=0,d=a;(A=$=>Math.min([...'cowbel'].map(_=>($.split(_).length-1)>>(_=='l'))))(a)==A(d+=a[c++]););d")

Étant donné que cette réponse est très différente de la réponse JavaScript existante et que j'y ai mis du temps, j'ai décidé de créer une réponse moi-même.

Usage

f=a=>eval("for(c=0,d=a;(A=$=>Math.min([...'cowbel'].map(_=>($.split(_).length-1)>>(_=='l'))))(a)==A(d+=a[c++]););d")
f("cowbell")

Sortie

"cowbellcowbell"

Octave, 80 87 97 octets

s=input('');k=1;do;until(x=@(A)min(fix(sum('cowbel'==A')./('111112'-48))))(b=[s s(1:++k)])>x(s);b

Essayez-le en ligne!

CJam, 37

q___S\+{+"cowbel"1$fe=)2/+:e<\}%()#)<

Essayez-le en ligne

Si je peux exclure les caractères "et \, alors…

35 octets

q___`{+"cowbel"1$fe=)2/+:e<\}%()#)<

Essayez-le en ligne

Explication

Le code ajoute successivement chaque caractère de la chaîne à la chaîne initiale (en passant de l’original à doublé), détermine le nombre de cloches pour chaque chaîne (en comptant le nombre d’occurrences de chaque caractère dans "cowbel" et en divisant le nombre par "l"). par 2, puis en prenant le minimum), trouve la position de la première chaîne où le nombre de clochettes augmente de 1, puis prend le préfixe correspondant à l'entrée et le met après la chaîne d'entrée.

Afin d'inclure également la chaîne d'origine (sans aucun caractère ajouté), le code ajoute un caractère neutre à la chaîne qui est itérée. La première version ajoute un espace et la seconde utilise la représentation sous forme de chaîne, c'est-à-dire la chaîne entre guillemets.

q___          read input and make 3 more copies: one for output, one for prefix,
               one for appending and one for iterating
S\+           prepend a space to the iterating string
              or
`             get the string representation
{…}%          map each character of the string
  +           append the character to the previous string
  "cowbel"    push this string
  1$          copy the appended string
  fe=         get the number of occurrences of each "cowbel" character
  )2/+        take out the last number, divide by 2 and put it back
  :e<         find the minimum
  \           swap with the appended string
(             take out the first number (cowbells in the initial string)
)#            increment and find the index of this value in the array
)             increment the index (compensating for taking out one element before)
<             get the corresponding prefix
              another copy of the input is still on the stack
              and they are both printed at the end

PHP, 133 octets

un port PHP du port JavaScript @ edc65 de la réponse de DLosc´s Pip.

function f($s){for(;$c=lcowbe[$i];)$a[$c]=substr_count($s,$c)>>!$i++;return min($a);}for($s=$argv[1];f($s)==f($s.=$s[$i++]););echo$s;

prend les minuscules de l'argument de la ligne de commande. Courez avec -nr.

panne

// function to count the cowbells:
function f($s)
{
    for(;$c=lcowbe[$i];)            # loop through "cowbel" characters
        $a[$c]=substr_count($s,$c)  # count occurences in $s
            >>!$i++;                # divide by 2 if character is "l" (first position)
        return min($a);             # return minimum value
}
for($s=$argv[1];    # copy input to $s, loop:
    f($s)               # 1. count cowbells in $s
    ==                  # 3. keep looping while cowbell counts are equal
    f($s.=$s[$i++])     # 2. append $i-th character of $s to $s, count cowbells
;);
echo$s;             # print $s