Bruce Dickenson이 Blue Öyster Cult 레코딩 세션을 생성 할 때 기술 지원을 제공하고 있습니다. 그가 더 많은 cowbell 을 요청할 때 , 당신은 그에게 그것을 줄 수 있습니다.

당신의 작업

문자열을 입력으로 사용하거나 하나 이상의 cowbell을 포함하는 관련 문자열을 출력하는 프로그램 또는 함수를 작성하십시오.

현에는 몇 개의 cowbell이 포함되어 있습니까?

문자열에 포함 된 카우벨의 수는 문자열의 문자를 치환하여 얻을 수있는 "카우벨"의 최대 고유 사본 수와 같습니다. 예를 들어, "bbbccceeellllllooowwwwwwwww"3 개의 cowbell을 포함 "bbccceeellllllooowwwwwwwww"하고 "bbbccceeelllllooowwwwwwwww"각각은 2 개의 cowbell을 "cowbel"포함하며 0 개의 cowbell을 포함합니다.

출력은 입력과 어떻게 관련되어야합니까?

출력은 입력 문자열과 카우벨의 수를 늘리는 데 필요한 입력 문자열의 가장 짧은 접두사로이 순서대로 연결되어야합니다.

예를 들어, 2 개 대신 3 개의 카우벨을 포함 "bbbccceeelllllooowwwwwwwww"하려면 1 개만 추가 "l"하면됩니다. 포함 된 가장 짧은 접두어 "l"는 "bbbccceeel"입니다. 따라서 입력이 "bbbccceeelllllooowwwwwwwww"이면 출력은이어야합니다 "bbbccceeelllllooowwwwwwwwwbbbccceeel".

기술

• 입력에 인쇄 가능한 ASCII 문자 만 포함되어 있다고 가정 할 수 있습니다. 언어의 문자열 처리에 성가신 하나 또는 두 개의 문자가있는 경우 (예 : 개행 또는 \) 입력에 해당 문자 가 포함되어 있지 않다고 가정 할 수 있습니다.이 제한 사항 만 언급하십시오.
• 입력의 알파벳 문자가 모두 소문자이거나 모두 대문자라고 가정 할 수도 있습니다. 이 중 하나를 사용하지 않기로 선택하면 대소 문자를 구분하지 않고 계산합니다.
• 당신은 더 입력이 문자의 각각의 적어도 하나 개의 사본 포함되어 있다고 가정 할 수있다 b, c, e, l, o,와 w. 이는 문자열의 일부 접두어를 연결하여 더 많은 cowbell을 포함하는 문자열을 생성 할 수 있다고 가정하는 것과 같습니다. (입력 문자열 자체에 카우벨이 포함될 필요는 없습니다.)
• 만약 당신의 언어가이 문제를 해결하는 내장을 가지고 있다면, 그것을 심각하게 사용하십시오.

금도금 기저귀

레코딩 스튜디오 시간이 비싸므로 코드는 가능한 짧아야합니다. 가장 적은 바이트를 가진 항목이 승자입니다!

테스트 사례

( 더 쉬운 복사 / 붙여 넣기를위한 pastebin 링크 )

테스트 입력 # 1 : "christopher walken begs for more cowbell!"

테스트 출력 # 1 : "christopher walken begs for more cowbell!christopher wal"

테스트 입력 # 2 : "the quick brown fox jumps over the lazy dog"

테스트 출력 # 2 : "the quick brown fox jumps over the lazy dogthe quick brown fox jumps over the l"

테스트 입력 # 3 : "cowbell"

테스트 출력 # 3 : "cowbellcowbell"

테스트 입력 # 4 : "cowbell cowbell cowbell"

테스트 출력 # 4 : "cowbell cowbell cowbellcowbell"

테스트 입력 # 5 : "cowbell cowbell cowbel"

테스트 출력 # 5 : "cowbell cowbell cowbelcowbel"

테스트 입력 # 6 : "bcelow"

테스트 출력 # 6 : "bcelowbcel"

테스트 입력 # 7 : "abcdefghijklmnopqrstuvwxyz"

테스트 출력 # 7 : "abcdefghijklmnopqrstuvwxyzabcdefghijkl"

테스트 입력 # 8 : "cccowwwwbbeeeeelllll"

테스트 출력 # 8 : "cccowwwwbbeeeeelllllccco"

테스트 입력 # 9 : "be well, programming puzzles & code golf"

테스트 출력 # 9 : "be well, programming puzzles & code golfbe well, programming puzzles & c"

테스트 입력 # 10 : "lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. wow!"

테스트 출력 # 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"

테스트 입력 # 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!
"

테스트 출력 # 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"

핍 , 50 42 38 바이트

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

필요한 경우 인용 된 문자열을 명령 행 인수로 전달하십시오. 온라인으로 사용해보십시오!

설명

이것을 cowbell 기능과 전체 프로그램의 두 부분으로 설명하겠습니다. 먼저, 문자열에서 cowbell의 양을 계산하는 함수는 다음과 같습니다.

MN{_NaM"lcowbe"}//^2

{...}함수를 정의합니다. 많은 Pip 연산자는 함수에 적용될 때 다른 함수를 반환합니다. 예를 -{a+1}들어와 같습니다 {-(a+1)}. 위의 내용은

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

다음과 같이 작동합니다.

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

이제 우리는 그것을 가지고 있습니다. 전체 프로그램은 다음과 같습니다.

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

온라인으로 사용해보십시오

읽을 수있는 형식 + 설명 :

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)

}

몇 가지 재미있는 트릭 사용 :

• 문자를 확인해볼 때 내가 입력 'w'3 바이트 인 승 숯불에 대한,하지만, 문자 'c'와 'b'나는 바이트 각 시간을 절약하기 위해 각각 자신의 ASCII 값 99 및 98을 입력 할 수 있습니다. (편집 : @Titus 덕분에 대문자로만 2 바이트 숫자의 ASCII 값을 사용하여 모든 COWBELL 문자 로이 작업을 수행한다는 것을 알고 있습니다)

•이 r=~-l/2됩니다 r=(l-1)/2bitshifts를 사용하여

• a[++i]index (i)에서 문자를 가져오고 동시에 색인을 모두 반복합니다. 난 단지 시작 i에 i=-1대신 i=0(내가 함께 동일한 작업을 수행 z하고로 시작하는 z=i다른 바이트에 저장하기)

파이썬 2 125 113 112 바이트

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 cowbells의 수를 센다

@Rod 덕분에 -12 바이트 @Titus 덕분에
-1 바이트

펄 6 , 91 바이트

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

소문자 입력을 가정합니다.

작동 원리

람다 안에서 문자열의 카우벨 수를 세는 람다는 다음과 같이 정의됩니다.

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.

나머지 코드는이 내부 람다 &c를 사용하여 다음 과 같이 결과를 찾습니다.

                     [\,](.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 바이트

@DLosc의 아이디어 덕분에 템플릿 문자열 lcowbe대신 1 바이트 오프cowbel

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

입력 문자는 모두 소문자입니다. 입력에 줄 바꿈이 포함 된 경우 줄 바꿈 문자는 일반 문자와 연결된 ASCII 코드로 입력해야합니다 (모든 테스트 사례 링크의 마지막 입력 참조).

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

자바 스크립트 (ES6) 106 107 113 126 141

@DLosc의 Pip 답변의 자바 스크립트로 포팅. 나는 그것을 완전히 이해하기 위해 약간의 시간이 필요했고, 그것은 천재입니다.

@Titus의 힌트에 따라 -15 바이트를 편집 하여 입력 문자열에 직접 문자를 추가 a하고 조기 반환을 피하십시오 (아니오 for/if)

Min 함수의 6 값을 열거 한 Edit 2 는 다른 13 바이트를 절약합니다.

변경된 3 개의 c 함수를 다시 편집 하십시오. 나는 자세한 생각 length하고 split너무 긴 것입니다. 내가 틀렸어.

소문자 입력 가정

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

덜 골프

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

테스트

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 유틸리티, 184 바이트

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

온라인으로 사용해보십시오!

2 바이트를 골프로 해준 @AlbertRenshaw에게 감사합니다.

자바 스크립트 (ES6) 124 114 바이트

몇 바이트를 절약 해준 Neil에게 감사합니다

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

이것은 이미 존재하는 JavaScript 답변과는 상당히 다르기 때문에 꽤 시간을 들여 답변을 직접 작성하기로 결정했습니다.

용법

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

산출

"cowbellcowbell"

옥타브, 80 87 97 바이트

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

온라인으로 사용해보십시오!

CJam, 37

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

온라인으로 사용해보십시오

"및 \문자를 제외 할 수 있다면 ...

35 바이트

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

온라인으로 사용해보십시오

설명

이 코드는 문자열의 각 문자를 초기 문자열에 연속적으로 추가하고 (원본에서 두 배로 이동) 각 문자열에 대한 카우벨 수를 결정합니다 ( "cowbel"에서 각 문자의 발생 횟수를 세고 'l'에 대한 문자 구분) 2를 곱한 다음 최소값을 가져옴)은 cowbell의 수가 1 씩 증가하는 첫 번째 문자열의 위치를 ​​찾은 다음 입력의 해당 접두사를 가져 와서 입력 문자열 뒤에 놓습니다.

원래 문자열도 포함하기 위해 (문자가 추가되지 않은) 코드는 반복되는 문자열에 중립 문자를 추가합니다. 첫 번째 버전은 공백을 추가하고 두 번째 버전은 문자열 표현, 즉 큰 따옴표 사이의 문자열을 사용합니다.

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 바이트

DLosc의 Pip 답변의 @ edc65의 JavaScript 포트의 PHP 포트.

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;

명령 행 인수에서 소문자 입력을받습니다. 로 실행하십시오 -nr.

고장

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