Sie bieten auf den technischen Support der Bruce Dickenson als er eine Blue Öyster Cult Aufnahme - Session erzeugt. Wenn er nach mehr Kuhglocke fragt , kannst du sie ihm geben.

Deine Aufgabe

Schreiben Sie ein Programm oder eine Funktion, die eine Zeichenfolge (oder eine Entsprechung in Ihrer Sprache) als Eingabe verwendet und eine zugehörige Zeichenfolge ausgibt, die eine weitere Kuhglocke enthält.

Wie viele Kuhglocken enthält eine Schnur?

Die Anzahl der Kuhglocken, die eine Zeichenfolge enthält, entspricht der maximalen Anzahl unterschiedlicher Kopien von "Kuhglocken", die durch Permutieren der Zeichenfolgen erhalten werden können. Zum Beispiel "bbbccceeellllllooowwwwwwwww"enthält 3 cowbells, während "bbccceeellllllooowwwwwwwww"und "bbbccceeelllllooowwwwwwwww"jeweils 2 cowbells enthalten und "cowbel"enthält 0 cowbells.

In welcher Beziehung soll der Output zum Input stehen?

Die Ausgabe sollte aus der Verkettung der Eingabezeichenfolge und dem kürzesten Präfix der Eingabezeichenfolge in dieser Reihenfolge bestehen, die zum Erhöhen der Anzahl der Kuhglocken erforderlich sind.

Beispielsweise "bbbccceeelllllooowwwwwwwww"benötigt nur eine zusätzliche "l", um 3 Kuhglocken anstelle von 2 zu enthalten; das kürzeste Präfix, das das enthält, "l"ist "bbbccceeel". Wenn also der Eingang ist "bbbccceeelllllooowwwwwwwww", sollte der Ausgang sein "bbbccceeelllllooowwwwwwwwwbbbccceeel".

Technische Details

• Sie können davon ausgehen, dass die Eingabe nur druckbare ASCII-Zeichen enthält. Wenn ein oder zwei Zeichen für die Verarbeitung von Zeichenfolgen in Ihrer Sprache störend sind (z. B. Zeilenumbrüche oder \), können Sie davon ausgehen, dass die Eingabe diese Zeichen nicht enthält. Erwähnen Sie einfach diese Einschränkung.
• Sie können außerdem davon ausgehen, dass die alphabetischen Zeichen in der Eingabe entweder in Klein- oder in Großbuchstaben eingegeben werden. Wenn Sie keine davon annehmen, zählen Sie die Kuhglocken ohne Berücksichtigung der Groß- und Kleinschreibung.
• Sie übernehmen kann ferner , dass die Eingabe mindestens eine Kopie von jedem der Zeichen enthält b, c, e, l, o, und w. Dies entspricht der Annahme, dass ein Präfix der Zeichenfolge mit dieser verknüpft werden kann, um eine Zeichenfolge mit mehr Cowbell zu erstellen. (Beachten Sie, dass die Eingabezeichenfolge selbst keine Kuhglocke enthalten muss.)
• Wenn deine Sprache ein eingebautes Programm hat, das dieses Problem löst, dann benutze es total, ernsthaft, wie großartig ist das?

Vergoldete Windeln

Da die Aufnahmezeit im Studio teuer ist, muss Ihr Code so kurz wie möglich sein. Der Eintrag mit den wenigsten Bytes ist der Gewinner!

Testfälle

( Pastebin-Link zum leichteren Kopieren / Einfügen)

Testeingang 1: "christopher walken begs for more cowbell!"

Testausgang 1: "christopher walken begs for more cowbell!christopher wal"

Testeingang 2: "the quick brown fox jumps over the lazy dog"

Testausgang 2: "the quick brown fox jumps over the lazy dogthe quick brown fox jumps over the l"

Testeingang 3: "cowbell"

Testausgang 3: "cowbellcowbell"

Testeingang 4: "cowbell cowbell cowbell"

Testausgang 4: "cowbell cowbell cowbellcowbell"

Testeingang 5: "cowbell cowbell cowbel"

Testausgang 5: "cowbell cowbell cowbelcowbel"

Testeingang 6: "bcelow"

Testausgang Nr. 6: "bcelowbcel"

Testeingang Nr. 7: "abcdefghijklmnopqrstuvwxyz"

Testausgang Nr. 7: "abcdefghijklmnopqrstuvwxyzabcdefghijkl"

Testeingang 8: "cccowwwwbbeeeeelllll"

Testausgang 8: "cccowwwwbbeeeeelllllccco"

Testeingang 9: "be well, programming puzzles & code golf"

Testausgang 9: "be well, programming puzzles & code golfbe well, programming puzzles & c"

Testeingang Nr. 10: "lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. wow!"

Testausgang 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"

Testeingang Nr. 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!
"

Testausgang Nr. 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 Bytes

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

Übergeben Sie die Zeichenfolge als Befehlszeilenargument in Anführungszeichen, falls erforderlich. Probieren Sie es online!

Erläuterung

Ich werde dies in zwei Teilen erklären: der Kuhglockenfunktion und dem vollständigen Programm. Hier ist die Funktion, die die Menge der Kuhglocken in einer Zeichenfolge berechnet:

MN{_NaM"lcowbe"}//^2

{...}definiert eine Funktion. Viele Pip-Operatoren geben eine andere Funktion zurück, wenn sie auf eine Funktion angewendet werden. zum Beispiel -{a+1}ist das gleiche wie {-(a+1)}. Das obige ist also äquivalent zu

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

was wie folgt funktioniert:

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

Jetzt, da wir das haben, ist hier das vollständige Programm:

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

Probieren Sie es online aus

Lesbares Format + Erklärung:

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)

}

Einige unterhaltsame Tricks:

• Wenn ich Zeichen überprüfe, gebe ich 'w'für das Zeichen ein, das 3 Byte beträgt, aber für die Zeichen 'c'und 'b'ich können ihre ASCII-Werte 99 bzw. 98 eingeben, um jedes Mal ein Byte zu speichern. (Edit: Dank @Titus kann ich dies mit allen COWBELL-Buchstaben tun, indem ich nur Großbuchstaben verwende, die alle 2 Bytes numerische ASCII-Werte sind.)

• r=~-l/2wird r=(l-1)/2mit bitshifts

• a[++i]Ich erhalte das Zeichen bei Index (i) und durchlaufe den Index alle gleichzeitig. Ich beginne einfach ibei i=-1anstatt i=0(ich mache dasselbe mit zund starte es z=i, um ein weiteres Byte zu speichern)

Python 2, 125 113 112 Bytes

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 zählt die Anzahl der Kuhglocken

-12 Bytes dank @Rod
-1 Bytes dank @Titus

Perl 6 , 91 Bytes

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

Übernimmt die Eingabe in Kleinbuchstaben.

Wie es funktioniert

Innerhalb des Lambdas ist ein weiteres Lambda zum Zählen der Anzahl der Kuhglocken in einer Kette so definiert:

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.

Der Rest des Codes verwendet dieses innere Lambda &c, um das Ergebnis wie folgt zu finden:

                     [\,](.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 Bytes

Dank der Idee von @ DLosc, die Template-Zeichenfolge lcowbeanstelle von zu verwenden, 1 Byte wenigercowbel

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

Eingabezeichen sind alle Kleinbuchstaben. Wenn die Eingabe Zeilenumbrüche enthält, muss das Zeilenumbruchszeichen als ASCII-Code eingegeben werden, der mit den normalen Zeichen verknüpft ist (siehe letzte Eingabe im Link zu allen Testfällen).

Probieren Sie es online! Oder überprüfen Sie alle Testfälle .

JavaScript (ES6), 106 107 113 126 141

Eine Javascript-Portierung der Pip-Antwort von @DLosc. Ich brauchte etwas Zeit, um es vollständig zu verstehen, und es ist genial.

Bearbeiten Sie -15 Bytes, indem Sie dem Hinweis von @Titus folgen, Zeichen direkt an die Eingabezeichenfolge anhängen aund eine vorzeitige Rückkehr vermeiden (also nein for/if).

Edit 2, das den Wert 6 für die Min-Funktion auflistet, speichert andere 13 Bytes

3 geänderte c-Funktion erneut bearbeiten . Ich dachte das wortreich lengthund splitwäre zu langwierig. Ich lag falsch.

Annahme von Kleinbuchstaben

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

Weniger golfen

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

Prüfung

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

Bash + Unix-Dienstprogramme, 184 Bytes

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

Probieren Sie es online!

Vielen Dank an @ AlbertRenshaw für das Golfen mit 2 Bytes weniger.

JavaScript (ES6), 124 114 Byte

Vielen Dank an Neil, der ein paar Bytes gespart hat

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

Da dies ganz anders ist als die bereits vorhandene JavaScript-Antwort und ich einige Zeit darauf verwendet habe, habe ich beschlossen, selbst eine Antwort zu erstellen.

Verwendungszweck

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

Ausgabe

"cowbellcowbell"

Oktave, 80 87 97 Bytes

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

Probieren Sie es online!

CJam, 37

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

Probieren Sie es online aus

Wenn ich die Zeichen "und ausschließen kann \, dann ...

35 Bytes

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

Probieren Sie es online aus

Erläuterung

Der Code hängt nacheinander jedes Zeichen der Zeichenfolge an die ursprüngliche Zeichenfolge an (von der ursprünglichen zur doppelten Zeichenfolge), bestimmt die Anzahl der Kuhglocken für jede Zeichenfolge (zählt die Anzahl der Vorkommen jedes Zeichens in "Kuhglocken" und dividiert das Zeichen für "l". durch 2, dann das Minimum nehmen), findet die Position der ersten Zeichenfolge, an der die Anzahl der Kuhglocken um 1 zunimmt, nimmt dann das entsprechende Präfix der Eingabe und setzt es hinter die Eingabezeichenfolge.

Um auch die ursprüngliche Zeichenfolge (ohne angehängte Zeichen) einzuschließen, wird der Zeichenfolge, die iteriert wird, ein neutrales Zeichen vorangestellt. Die erste Version stellt ein Leerzeichen voran und die zweite Version verwendet die Zeichenfolgendarstellung, dh die Zeichenfolge zwischen doppelten Anführungszeichen.

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 Bytes

Ein PHP-Port von @ edc65s JavaScript-Port von DLoscs Pip-Antwort.

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;

Übernimmt die Eingabe in Kleinbuchstaben vom Befehlszeilenargument. Laufen Sie mit -nr.

Nervenzusammenbruch

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