목걸이, 팔찌, 신발 끈 등을 위해 Froot Loops 를 묶고 있다고 가정하십시오 . 6 루프 색깔이있다 : R의 ED, 출력 범위, Y ellow, g의 재 N, B의 루 및 P의 urple이. 스트랜드가 맨 왼쪽에서 빨간색으로 시작하고 무지개 순서대로 오른쪽에서 보라색으로 끝나기를 원합니다. 즉, 스트랜드가 roygbp몇 번 반복 되는 문자열로 표시되도록 할 수 있습니다 (아마도 0).

문제는 이미 특정 순서가 아닌 루프를 돌렸다는 것입니다. 첫 번째 루프 빨간색과 마지막 루프 자주색으로 왼쪽에서 오른쪽으로 이동하는 올바른 무지개주기 수를 최대화하기 위해 어떤 루프를 먹어야하고 먹지 않아야합니까?

임의의 문자 문자열을 가져와 먹을 루프 위치와 먹지 않는 루프 위치 roygbp와 같은 길이의 문자열을 인쇄하거나 반환 하는 프로그램이나 함수를 작성하십시오 .en

예를 들어, Froot Loop 스트랜드가

입력은

gorboypbgbopyroybbbogppbporyoygbpr

왼쪽에서 오른쪽으로 이동하면 3 개의 완전한 roygbp무지개 시퀀스를 찾을 수 있지만 일부 루프를 제거해야합니다. 따라서 출력은

eenenneennenennneeeeneennenennnnne

완벽한 3 사이클 스트랜드를 만듭니다.

입력에 완전한 레인보우 사이클이 없으면 출력은 모두 e가되고 스트랜드는 루프없는 상태가됩니다. 예를 들어 입력 proygb에 출력이 eeeeee있습니다. 반대로 proygbp출력이 ennnnnn있습니다.

모든 입력 스트랜드에 하나 이상의 루프가 있다고 가정 할 수 있습니다.

바이트 단위의 가장 짧은 코드가 이깁니다.

Pyth, 31 바이트

:*lz\nhf!:jk.DzT"roygbp"kyUlz\e

놀랍도록 비효율적 인 설명이 곧 나옵니다.

yUlzz(입력) 의 모든 가능한 인덱스의 모든 가능한 서브 세트를 순서대로 생성합니다. 예를 들어 입력이 abc다음과 같은 경우

[[], [0], [1], [2], [0, 1], [0, 2], [1, 2], [0, 1, 2]]

그런 다음 위 목록에서 hf!첫 번째 T를 찾은 다음 :jk.DzT"roygbp"k거짓입니다. .D문자열과 인덱스 목록을 가져와 해당 인덱스의 요소를 삭제합니다. 그래서 .D"abcd",1 3입니다 "ac". .DPyth의 향후 버전에서는 수정되지 않는 목록을 반환 하므로 jk( kis "")를 사용 하여 목록을 다시 문자열로 결합합니다. :_"roygbp"k부분은 빈 문자열과주기의 모든 인스턴스를 대체합니다.

빈 문자열이 거짓이므로 위의 단락은 사이클로 만 구성된 문자열을 얻는 데 필요한 가장 작은 인덱스 집합을 찾는 방법을 설명합니다.

:*lz\n_\e그런 다음 해당 인덱스 목록을 nnnneeennene문자열 로 바꿉니다 .

Hexagony , 920 (722) 271 바이트

여섯 가지 유형의 과일 고리가 있습니다. 즉 Hexagony가 된 것입니다 제작 을 위해.

){r''o{{y\p''b{{g''<.{</"&~"&~"&<_.>/{.\.....~..&.>}<.._...=.>\<=..}.|>'%<}|\.._\..>....\.}.><.|\{{*<.>,<.>/.\}/.>...\'/../==.|....|./".<_>){{<\....._>\'=.|.....>{>)<._\....<..\..=.._/}\~><.|.....>e''\.<.}\{{\|./<../e;*\.@=_.~><.>{}<><;.(~.__..>\._..>'"n{{<>{<...="<.>../

알았어 세상에, 내가 한 짓은 ...

이 코드는 이제 측면 길이 10의 육각형입니다 (19에서 시작). 아마 9 골드까지 골프를 쳤을지도 모르지만, 제 일이 여기에서 끝났다고 생각합니다 ... 참고로, 소스에 175 개의 실제 명령이 있습니다. 교차로에서 명령을 내림).

명백한 선형성에도 불구하고 코드는 실제로 2 차원입니다. Hexagony는이 코드를 일반 육각형으로 재 배열합니다 (유효한 코드이지만 모든 공백은 Hexagony에서 선택 사항 임). 여기에 펼쳐진 코드가 있습니다 ... 음 "아름다움"이라고 말하고 싶지 않습니다.

          ) { r ' ' o { { y \
         p ' ' b { { g ' ' < .
        { < / " & ~ " & ~ " & <
       _ . > / { . \ . . . . . ~
      . . & . > } < . . _ . . . =
     . > \ < = . . } . | > ' % < }
    | \ . . _ \ . . > . . . . \ . }
   . > < . | \ { { * < . > , < . > /
  . \ } / . > . . . \ ' / . . / = = .
 | . . . . | . / " . < _ > ) { { < \ .
  . . . . _ > \ ' = . | . . . . . > {
   > ) < . _ \ . . . . < . . \ . . =
    . . _ / } \ ~ > < . | . . . . .
     > e ' ' \ . < . } \ { { \ | .
      / < . . / e ; * \ . @ = _ .
       ~ > < . > { } < > < ; . (
        ~ . _ _ . . > \ . _ . .
         > ' " n { { < > { < .
          . . = " < . > . . /

설명

나는이 골프 버전에서 모든 복잡한 실행 경로를 설명하려고 시도하지는 않지만 알고리즘과 전반적인 제어 흐름은이 ungolfed 버전과 동일하므로 알고리즘을 설명한 후에 정말 궁금한 점을 연구하기가 더 쉽습니다.

                 ) { r ' ' o { { \ / ' ' p { . . .
                . . . . . . . . y . b . . . . . . .
               . . . . . . . . ' . . { . . . . . . .
              . . . . . . . . \ ' g { / . . . . . . .
             . . . . . . . . . . . . . . . . . . . . .
            . . . . . . . . . . . . . . . . . . . . . .
           . . . . . . . . > . . . . < . . . . . . . . .
          . . . . . . . . . . . . . . > . . ) < . . . . .
         . . . . . . . . . . / = { { < . . . . ( . . . . .
        . . . . . . . . . . . ; . . . > . . . . . . . . . <
       . . . . . . . . . . . . > < . / e ; * \ . . . . . . .
      . . . . . . . . . . . . @ . } . > { } < . . | . . . . .
     . . . . . / } \ . . . . . . . > < . . . > { < . . . . . .
    . . . . . . > < . . . . . . . . . . . . . . . | . . . . . .
   . . . . . . . . _ . . > . . \ \ " ' / . . . . . . . . . . . .
  . . . . . . \ { { \ . . . > < . . > . . . . \ . . . . . . . . .
 . < . . . . . . . * . . . { . > { } n = { { < . . . / { . \ . . |
  . > { { ) < . . ' . . . { . \ ' < . . . . . _ . . . > } < . . .
   | . . . . > , < . . . e . . . . . . . . . . . . . = . . } . .
    . . . . . . . > ' % < . . . . . . . . . . . . . & . . . | .
     . . . . _ . . } . . > } } = ~ & " ~ & " ~ & " < . . . . .
      . . . \ . . < . . . . . . . . . . . . . . . . } . . . .
       . \ . . . . . . . . . . . . . . . . . . . . . . . < .
        . . . . | . . . . . . . . . . . . . . . . . . = . .
         . . . . . . \ . . . . . . . . . . . . . . . . / .
          . . . . . . > . . . . . . . . . . . . . . . . <
           . . . . . . . . . . . . . . . . . . . . . . .
            _ . . . . . . . . . . . . . . . . . . . . .
             . . . . . . . . . . . . . . . . . . . . .
              . . . . . . . . . . . . . . . . . . . .
               . . . . . . . . . . . . . . . . . . .
                . . . . . . . . . . . . . . . . . .
                 . . . . . . . . . . . . . . . . .

솔직히 첫 번째 단락에서 나는 반 농담이었습니다. 우리가 6 가지 요소의주기를 다루고 있다는 사실은 실제로 큰 도움이되었습니다. Hexagony의 메모리 모델은 무한 육각형 그리드로, 그리드의 각 가장자리에는 0으로 초기화 된 부호있는 임의 정밀도 정수가 포함됩니다.

이 프로그램에서 사용한 메모리의 레이아웃 다이어그램은 다음과 같습니다.

왼쪽의 긴 직선 비트 a는 문자 r 과 관련된 임의의 크기 의 0으로 끝나는 문자열로 사용됩니다 . 다른 문자의 파선은 같은 종류의 구조를 나타내며 각 구조는 60도 회전합니다. 처음에 메모리 포인터는 1 이라고 표시된 가장자리를 가리키고 북쪽을 향합니다.

코드의 첫 번째 선형 비트는 모서리의 내부 "별"을 문자 roygbp로 설정하고 초기 모서리를로 설정 1하여주기가 끝나고 시작되는 위치 ( p및 사이 r)를 알 수 있도록합니다.

){r''o{{y''g{{b''p{

그런 다음 1 이라고 표시된 가장자리로 돌아갑니다 .

이제 알고리즘의 일반적인 아이디어는 다음과 같습니다.

1. 주기의 각 문자에 대해 STDIN에서 문자를 계속 읽고 현재 문자와 다른 경우 해당 문자와 ​​연관된 문자열에 추가하십시오.
2. 현재 찾고있는 문자를 읽을 때 ?e 라고 표시된 모서리에를 저장합니다 . 사이클이 완료되지 않는 한이 캐릭터도 먹어야한다고 가정해야합니다. 그런 다음 고리 주위를 순환하면서 다음 문자로 이동합니다.
3. 이 프로세스가 중단 될 수있는 두 가지 방법이 있습니다.
   • 어느 쪽이든 우리는주기를 완료했습니다. 이 경우 싸이클을 통해 또 다른 빠른 라운드를 수행 e하여 ? 와 가장자리 n들, 이제 우리는 그주기가 목걸이에 남아 원하기 때문에. 그런 다음 인쇄 코드로 넘어갑니다.
   • 또는 EOF (음수 문자 코드로 인식)를 누르십시오. 이 경우 음수 값을 ? 현재 문자의 가장자리 (그래서 우리는 쉽게 모두 구별 할 수 e와 n). 그런 다음 인쇄 코드로 이동하기 전에 잠재적으로 불완전한 사이클의 나머지 부분을 건너 뛰기 위해 1 에지를 검색 합니다.
4. 인쇄 코드는주기를 다시 반복합니다.주기의 각 문자에 대해 문자를 인쇄하는 동안 저장된 문자열을 지 웁니다 e. 그런 다음 ?로 이동합니다 . 캐릭터와 관련된 가장자리. 그것이 부정적이라면, 우리는 단순히 프로그램을 종료합니다. 긍정적 인 경우 간단히 인쇄하여 다음 문자로 넘어갑니다. 주기를 마치면 2 단계로 돌아갑니다.

흥미로운 또 다른 점은 임의 크기의 문자열을 구현 한 방법입니다 (Hexagony에서 무제한 메모리를 사용한 것은 처음이기 때문입니다).

우리는 우리가 여전히에 대한 문자를 읽고 어떤 점에있어 상상 R (같이 우리가 그림을 사용할 수 있도록) 및 A [0] 과 1은 이미 그 모든 것을 북서 여전히 제로 (문자로 가득 차있다 ). 예를 들어 입력 의 처음 두 문자 를 해당 가장자리로 읽은 다음 이제는을 읽습니다 .ogy

새로운 문자는로 읽어 에서의 가장자리. 우리는 ? 에지는이 문자가 같은지 여부를 확인한다 r. (여기에는 멋진 트릭이 있습니다. Hexagony는 긍정적이고 비 긍정적으로 쉽게 구별 할 수 있으므로 빼기를 통해 평등을 확인하는 것은 성가 시며 적어도 두 개의 분기가 필요합니다. 그러나 모든 글자는 서로 2 배 미만입니다 모듈로를 사용하여 값을 비교할 수 있습니다. 모듈로가 같으면 0 만 제공합니다.)

때문에 y다른 r, 우리의 왼쪽 (라벨이없는) 가장자리 이동 의를 하고, 복사 y가. 우리가있을 때까지 우리는 이제 더 때마다 문자 하나 가장자리를 복사, 육각 주위에 더 이동 y의 에지 반대에 에서 . 그러나 이제는 [0] 에 덮어 쓰고 싶지 않은 문자가 이미 있습니다. 대신 y다음 육각형 주위를 "끌어" 1을 확인 합니다 . 그러나 거기에도 캐릭터가 있으므로 다른 육각형을 더 나아갑니다. 이제 a [2] 는 여전히 0이므로y그것에. 메모리 포인터는 이제 스트링을 따라 내부 링을 향해 뒤로 이동합니다. a [i] 사이의 (레이블이없는) 모서리 가 모두 0 인 반면 , 문자열의 시작 부분에 도달 한 시점을 알고 있습니다 . 긍정적입니다.

이것은 아마도 Hexagony에서 사소한 코드를 작성하는 데 유용한 기술 일 것입니다.

헥사 고니 , 169 바이트

나는 Martin Büttner의 답변 (그의 esolang이기도합니다) 에서 영감을 얻었으며 8 크기로도 할 수 있다고 결정했습니다. -그만해.)

r'.'o\|{##|_#{#>\_{b{"]_\..<>"<>\/><#y/''"_<.}]''/'\>)}}.\}}'{<"\\#_#/<|##|#@#"p><n'>"{,<##g#_/#'.\<\##'#{(.<#e;#"\##%\\(};/*#>.)\>##_/"{__\}#>}=\#>=<|>##)|###_'#\"{__\\

육각형으로 배치 :

       r ' . ' o \ | {
      # # | _ # { # > \
     _ { b { " ] _ \ . .
    < > " < > \ / > < # y
   / ' ' " _ < . } ] ' ' /
  ' \ > ) } } . \ } } ' { <
 " \ \ # _ # / < | # # | # @
# " p > < n ' > " { , < # # g
 # _ / # ' . \ < \ # # ' # {
  ( . < # e ; # " \ # # % \
   \ ( } ; / * # > . ) \ >
    # # _ / " { _ _ \ } #
     > } = \ # > = < | >
      # # ) | # # # _ '
       # \ " { _ _ \ \

이 프로그램은 실제로 #명령을 사용하지 않으므로 해당 문자를 사용하여 실제로 사용되지 않는 셀을 표시했습니다. 또한 한 방향으로 만 이동하는 모든 no-op 셀은 거울 _이므로 (예 : 수평으로 이동하는 경우) 모든 .문자가 한 방향 이상으로 이동 한다는 것을 알 수 있습니다 .

설명

처음에는 일련의 명령어를 실행합니다 r''o{{y''g{{b''p"")". 이것들은 코드 전체에 약간 우연히 퍼져 있습니다. ]다음 명령 포인터로 몇 번 전환하는 데 사용 합니다. 이 방법으로 본질적으로 육각형의 다른 구석으로 순간 이동할 수 있습니다. 프로그램의 나머지 전체는 명령어 포인터 # 3에 의해 실행됩니다.

메모리는 이제 다음과 같이 보입니다.이 설명에서 사용할 이름으로 표시된 중요한 모서리가 있습니다.

레이블이있는 가장자리는 다음을 의미합니다.

• in: 우리는이 가장자리를 사용하여 STDIN에서 읽은 문자를 저장합니다.
• %우리는 STDIN로부터 판독 된 문자에 대한 모듈로 연산 (수행이 에지를 사용하여 in) 현재 "유효한"문자 ( r, o것 등) 0가 동일한 경우를. Martin Büttner의 답변 에서이 트릭을 훔 쳤지 만 나머지 프로그램은 다릅니다.
• #: "유효하지 않은"문자 (예 : 먹어야하는 색상)를 읽는 동안이 가장자리를 증가시킵니다. 따라서이 가장자리는 e나중에 출력해야하는 개수를 기억합니다 .
• r?: 항상 (적색) 부분을 0제외하고 r. 이것은 우리가주기를 완료했을 때 알려줍니다.

프로그램은 다음과 같이 진행됩니다.

• 문자를 계속 읽으십시오. 현재 찾고있는 캐릭터가 아닌 경우 증가 #합니다. 그렇지 않으면 시계 방향으로 메모리의 다음 세그먼트로 이동하십시오.
• 다음 세그먼트로 넘어갈 때 r?긍정적 이라면 우리는 완전히 혁명을 일으켰습니다. 전체 라운드 및 출력 # es 및 n세그먼트 당 1을 만듭니다 . 이것은 각각을 #다시로 설정 합니다 0. (이 e레이블이없는 가장자리에 배치되지만 나중에 우리 는 (곱셈) 을 사용하여 설정 n한 #가장자리를 잘못 0사용합니다 .이 시점에서 *모든 %가장자리가 0 임을 알기 때문에 작동합니다 .)
• 문자를 읽을 때 양수가 아닌 경우 (예 : EOF) 원을 거꾸로 이동하여 양의 위치 로 돌아갈 때까지 #+1을 출력 한 다음 종료합니다.er?

완전한 실행 후, 메모리는 대략 다음과 같이 보입니다. 101(의 ASCII 코드 e)를 포함하는 모서리를 알 수 있습니다 . in가장자리 중 하나 는 -1(EOF)입니다. 모든 #모서리가 0에 있습니다. 메모리 포인터는 양의 r?가장자리 에서 끝난다 .

망막 , 148 85 79 바이트

$
#roygbp
.(?<=(?=((?=.*#(\2?(.))).*?\3(?<=^\5())?)+.*\3$)(.*))\4
n
#.*

[^n]
e

-s인터프리터 플래그를 사용하여 단일 소스 파일에서이를 실행할 수 있습니다 .

설명

간단한 것들을 먼저 풀어 보자.

$
#roygbp

#roygbp문자열의 끝에 추가 하여 문자의주기를 동적으로 계산하는 데 사용합니다.

다음 (긴) 단계는 어느 루프를 유지하고 대체 할 것인지를 결정 n합니다. 우리는 이것이 어떻게 작동하는지 살펴볼 것입니다.

#.*
<empty>

이것은 문자열 끝에서 조회 도우미를 제거합니다.

[^n]
e

이렇게하면 두 번째 단계에서 대체되지 않은 모든 문자가로 바뀌고 e변환이 완료됩니다.

이제 두 번째 단계로 돌아가 봅시다.

기본 구조는 트릭을 사용합니다. 트릭 은 몇 달 전에 선택한 문자를 전체 일치로 대체하기 위해 발견했습니다 .

.(?<=(?=...(?<=^\k<prefix>(?<flag>))?...)^(?<prefix>.*))\k<flag>

여기서 ...임의로 복잡한 패턴에 해당합니다. 이것은 대체 될 문자와 일치 한 .다음 lookbehind (오른쪽에서 왼쪽으로 읽어야 함)를 시작합니다. lookbehind는 일치하는 문자까지 모든 것을 그룹으로 캡처합니다 prefix. 그런 다음 미리 보기로 전환 하여 문자열의 처음부터 시작하여 복잡한 패턴을 포함 할 수 있습니다. 후에 우리가 그 패턴으로 대체하려는 문자, 우리는 선택적인 표정 넣어 뒤에 경우 수표, prefix그룹이 여기에 일치합니다. 그렇다면 빈 문자열을flag그룹. 그렇지 않으면 선택 사항이므로 정규식 엔진의 상태에 전혀 영향을 미치지 않으며 무시됩니다. 마지막으로, lookahead가 성공적으로 일치하면 마지막에 \k<flag>at 만 남게되며 이는 계산 중 플래그가 특정 지점에 설정된 경우에만 일치합니다.

이제 명명 된 그룹과 프리 스페이싱 모드를 사용하여 긴 정규 표현식을 조금 풀겠습니다.

.
(?<=
  (?=
    (?:
      (?=
        .*#
        (?<cycle>
          \k<cycle>?
          (?<char>)
        )
      )
      .*?
      \k<char>
      (?<=^\k<prefix>(?<flag>))?
    )+
    .*
    \k<char>$
  )
  (?<prefix>.*)
)
\k<flag>

위의 일반적인 개요를 알고 있기 때문에 내가 작성한 내용 만 살펴보기 만하면됩니다 ....

우리는 사이클에서 다음 캐릭터를 그룹으로 캡쳐하려고합니다 char. 또한에서 #의 현재 문자 까지의 문자열을 기억하여이 작업을 수행합니다 cycle. 다음 캐릭터를 얻기 위해 lookahead를 사용하여을 검색합니다 #. 이제 우리 cycle는의 다음 문자 를 일치 시키고 시도합니다 char. char마지막 문자가 아닌 한 일반적으로 가능 합니다 p. 이 경우 \k<cycle>문자열의 나머지 부분과 모두 일치하며로 캡처 할 문자가 남지 않습니다 char. 따라서 엔진 역 추적은 역 참조를 생략하고 대신 cycle첫 번째 문자와 일치합니다 r.

이제 사이클에서 다음 문자를 얻었습니다. 다음 char으로 해당 문자가 발생할 수 있는 다음 문자를 검색합니다 .*?\k<char>. 이것들은 우리가 바꾸고 싶은 문자이므로, 그 prefix뒤에 수표를 넣 습니다. 이 단계들 ( char사이클 에서 다음 단계를 찾고, 다음 단계를 검색하고, 적절한 경우 플래그를 설정) 단계는 이제 간단히로 반복됩니다 +.

그것이 순환 서브 시퀀스를 찾는 데 실제로 존재하는 전부이지만, 또한로 끝나는 지 확인해야합니다 p. 이것은 매우 쉽습니다. 현재 저장된 값 이 문자열 끝의 char와 일치 하는지 확인하십시오 . 또한 이 검사에 후행 이 필요하기 때문에 조회 문자열이 불완전한주기를 완료하는 데 사용되지 않도록 합니다.p.*\k<char>$p

파이썬 2, 133130126121 바이트

r=n=''
for c in input():r+='en'[c=='roygbp'[r.count('n')%6]]
for c in r:n+=['e',c][n.count('n')<r.count('n')/6*6]
print n

첫 번째 루프는 사이클을 얻고 두 번째 루프는 불완전한 사이클을 제거합니다

Jos와 DLosc에서 5 덕분에 3 바이트 절약

펄 5, 76 65 바이트

순수한 희석되지 않은 정규 표현식의 꼬집음.
먼저 먹지 말아야 할 것을 찾으십시오. 남아있는 것은 먹을 수 있습니다.

s/r(.*?)o(.*?)y(.*?)g(.*?)b(.*?)p/n$1n$2n$3n$4n$5n/g;s/[^n\s]/e/g

테스트

$ perl -p fruitloops.pl <<<gorboypbgbopyroybbbogppbporyoygbpr
eenenneennenennneeeeneennenennnnne

루아, 101 바이트

s=arg[1]:gsub("r(.-)o(.-)y(.-)g(.-)b(.-)p.-","*%1*%2*%3*%4*%5*"):gsub("%w","e"):gsub("*","n")print(s)

Lua 패턴을 창의적으로 사용합니다. 흥미로운 접근법이라고 생각합니다.

식사를하지 않은 모든 문자를 "*"로 바꾸고 모든 영숫자를 "e"로 바꾸고 모든 "*"를 "n"으로 바꿉니다.

자바 스크립트 (ES6), 118

a=>eval("b=[...a],d=0,e=b.map(f=>f=='roygbp'[d%6]?'n'[++d&0]:'e');for(i=e.length-1;i&&b[i]!='p';e[i--]='e');e.join``")

Fiddle 은 Firefox에서 테스트되었습니다. Chrome에서 화살표 기능을 지원한다고 들었지만 아직 Chrome에서 테스트하지 않았습니다.

언 골프 드 :

input=>eval("
    array = [...input],
    rainbow_index = 0,
    mapped = array.map( item=>
        item == 'roygbp'[rainbow_index%6] ? 'n'[++rainbow_index&0] : 'e'
        // when we encounter an item of the rainbow, do not eat and start using
        // the next rainbow item, otherwise eat
    );
    // go through backwards and eat until we find a 'p' indicating the last
    // complete loop
    for(i = mapped.length - 1; i && array[i]!='p'; mapped[i--] = 'e');

    mapped.join``
")

개크, 96

{for(;c=substr("roygbp",++i,1);r=r"\\"i"n")p=p"([^"c"]*)"c;$0=gensub(p,r,"g");gsub(/[^n]/,"e")}1

검색 패턴 "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"과 치환을 구축합니다 "\\1n\\2n\\3n\\4n\\5n\\6n". 교체 후 모든 음식 ( "e")을 선언하며 이는 완전한 무지개의 일부가 아닙니다.

이 조합은이 작업 중에 무지개가 해를 입지 않으며 끝에서 잘린 무지개가 나타나지 않도록 자동으로 보장합니다.

Pyth, 42 바이트

Jf-Z=+Zq@zT@"roygbp"ZUzs.e@"en"}k<J*6/lJ6z

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

CJam, 41 바이트

2r:R,m*{R.*s__,6/"roygbp"*=\,~*}$0="en"f=

모든 먹거나 먹지 않는 변형을 시도하고 가장 길고 유효한 목걸이를 선택하는 무차별 접근 방식.

CJam 통역사 에서 온라인으로 사용해보십시오 .

CJam, 50 바이트

l{"roygbp"T=={'nT):T;}{'e}?}%W%_'ne=6%{_'n#'et}*W%

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

이것은 다른 제출물보다 약간 길지만 선형 복잡성으로 매우 효율적입니다. 입력 문자열을 스캔하여 문자를 하나씩 일치시킵니다.

알고리즘의 핵심 부분은 실제로 상당히 작습니다. 코드의 약 절반은 끝에서 불완전한주기를 제거하기위한 것입니다.

C90, 142-146 바이트 (119에 따라 다름)

예쁜 무지개의 일부가 될 수없는 과일 고리를 효율적으로 먹기 위해 선형 시간으로 작동합니다. 그런 다음 포스트 프로세스는 마지막 부분 루프를 종료합니다.

다음은 네 가지 버전입니다.

• 버전 1 (146 바이트), 호출로 [name] [string]:
  main(int a,char**b){char*v=b[1],*s="roygbp",i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';while(k-->0)v[--i]='e';puts(v);}

• Version 2 (142 bytes), call with [name] [string] [rainbow order]:
  main(int a,char**b){char*v=b[1],*s=b[2],i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';while(k-->0)v[--i]='e';puts(v);}
  원하는 색상을 사용하지 n않거나 원하는 색상으로 자신의 무지개 순서를 정의 할 수 있습니다 e. 이것은 실제로 코드를 더 짧게 만듭니다!

• 버전 3 (123 바이트), 버전 1과 같이 호출하십시오.
  main(int a,char**b){char*v=b[1],*s="roygbp",i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';puts(v);}
  이것은 가능한 많은 무지개를 제공합니다! 불완전한 후행 무지개는 약속을 보여줍니다! 우리는 그들을 먹어서는 안됩니다!

• 버전 4 (119 바이트), 버전 2와 같이 호출합니다.
  main(int a,char**b){char*v=b[1],*s=b[2],i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';puts(v);}
  버전 3과 동일하지만 MOAR RAINBOW TYPES!

사소한 제한 : 기계에는 부호있는 문자 (일반적인 경우)가 있어야하며 문자열은 상당히 짧아야합니다. \n명확성을 위해 후행 을 출력합니다 .

버전 2는 논쟁의 여지가 있지만 요구 사항을 명확하게 통과하는 유일한 버전입니다. 버전 3과 4는 질문에 대한 정확하지 않은 (그러나 여전히 재미있는) 해석입니다.

Pyth, 38 바이트

나는 이것이 orlp의 대답보다 상당히 길다는 것을 알고 있지만, 이것은 선형 시간으로 실행됩니다 : o)

u+G?qH@"roygbp"/G\n\n\e+_>_zJx_z\p*Jdk

여기서 사용해보십시오 .

간단히 말해서,이 프로그램은 마지막 'p'뒤의 모든 문자를 공백으로 바꾼 다음 결과 문자열의 각 문자를 반복합니다. 문자가 'roygbp'순서의 다음 문자이면 'n'을 인쇄하고 그렇지 않으면 'e'를 인쇄하십시오.

                                          Implicit: z=input(), d=' ', k=''
                            Jx_z\p        Find number of chars after last p, store in J
                        _>_zJ             Take all but J chars of the input
                       +          *Jd     Append J spaces
u                                    k    Reduce on the above, starting with ''
               /G\n                       Count 'n' in output so far
      @"roygbp"                           Take relevant char from sequence string (modulus indexing)
   ?qH                                    Does the current char equal the above?
 +G                \n\e                   Select 'n' or 'e' as appropriate and append

입력 문자열을 처리하는 더 짧은 방법을 찾기 위해 고심했습니다. _>_zJ특히 어색한 느낌이 들지만 , 입력이 'p'로 끝나는 경우 <Jz필요한 문자열을 제공하지 않습니다 J == 0.

하스켈, 138 바이트

g 그렇습니다.

f(c:r)(h:t)|c==h='n':(f(r++[c])t)|0<1='e':(f(c:r)t)
f _""=""
z 'n' 'n'='n'
z a b='e'
r=reverse
g s=zipWith z(f"roygbp"s)(r$f"pbgyor"(r s))

자바 스크립트 (ES6), 85 82 바이트

"목걸이는 보라색으로 끝나야한다"라는 규칙은 원래 큰 장애물이었고, 점수는 66에서 125로 증가했지만 그보다 더 짧은 방법을 찾았습니다 (감사합니다!).

s=>(i=j=0,s.replace(/./g,x=>s.lastIndexOf`p`>=j++&x=='roygbp'[i%6]?(i++,'n'):'e'))

설명:

이 코드는 입력의 각 문자를 반복하고 각 문자 를이 논리 로 r또는 e이 논리로 바꿉니다 .

• 캐릭터의 위치가 <=의 마지막 위치이고 p레인보우의 다음 캐릭터 인 경우 유지하십시오 (로 교체하십시오 n).
• 그렇지 않으면 먹습니다 (로 교체 e).

언 골프 드 :

function a(s) {
  var i=0, j=0, r='';
  t = t.replace(/./g, function (x) {
    if (s.lastIndexOf('p') >= j++ && x == 'roygbp'.charAt(i)) {
      i++;
      i %= 6;
      return 'n';
    } else {
      return 'e';
    }
  });
  return r;
}

제안을 환영합니다!

파이썬 2, 254 바이트

루프!

i=raw_input();r='roygbp';l='r';d=''
for n in i:
 if n==l:d+='n';l=r[(r.index(l)+1)%6]
 else:d+='e'
d=list(d)[::-1];p=(r.index(l)+1)%6;
for s in range(len(d)):
 if d[s]=='n'and p-1:d[s]='e';p-=1
if d.count('n')<6:print'e'*len(d)
else:print''.join(d[::-1])

실례합니다. :피