ネックレス、ブレスレット、靴ひもなどのために、フルートループのストランドをつなげているとします。6つのループの色がありますRの ED、O範囲、Y ellow、グラム REEN、Bの LUE、及びPの urpleは。ストランドを一番左の赤から開始し、虹の順序で右に循環し、紫で終了するようにします。つまりroygbp、何回か（おそらく0）繰り返される文字列でストランドを表すことができるようにする必要があります。

問題は、特定の順序ではなく、すでにループを張っているということです。一番最初のループを赤、一番最後のループを紫にして、左から右に進む正しいレインボーサイクルの数を最大化できるように、どのループを食べて食べるべきではありませんか？

任意の文字列を取り込んで、食べるループの場所と食べないループの場所にroygbp同じ長さの文字列を出力または返すプログラムまたは関数を作成します。en

たとえば、Froot Loopストランドが次のように見える場合

入力は

gorboypbgbopyroybbbogppbporyoygbpr

そして、左から右に進むと、3つの完全なroygbpレインボーシーケンスを見つけることができますが、ループのいくつかを食いつぶす必要があります。したがって、出力は次のようになります

eenenneennenennneeeeneennenennnnne

完全な3サイクルストランドになります。

入力に完全なレインボーサイクルがない場合、出力はすべてにeなり、ストランドはループなしになります。例えば、入力にproygbはoutputがありますeeeeee。逆に、proygbpoutputがありますennnnnn。

すべての入力ストランドに少なくとも1つのループがあると仮定できます。

バイト単位の最短コードが優先されます。

Pyth、31バイト

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

信じられないほど非効率的、説明はすぐに来る。

yUlzz（入力）のすべての可能なインデックスのすべての可能なサブセットを順番に生成します。たとえば、入力がabc次の場合：

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

次にhf!、falseであるTような上記のリストの最初を見つけ:jk.DzT"roygbp"kます。.D文字列とインデックスのリストを受け取り、それらのインデックスの要素を削除します。そう.D"abcd",1 3です"ac"。.Dリストを返すので（そうではないはずですが、Pythの将来のバージョンで修正される予定です）、jk（kis ""）を使用してリストを結合して文字列に戻します。:_"roygbp"k一部には、空の文字列とのサイクルのすべてのインスタンスを置き換えます。

空の文字列はfalseであるため、上記の段落では、サイクルのみで構成される文字列を取得するために必要なインデックスの最小セットを見つける方法について説明しています。

:*lz\n_\e次に、そのインデックスのリストをnnnneeennene文字列に変換します。

Hexagony、920の 722 271バイト

6種類のフルーツループ、と言いますか？それは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 { { < > { < .
          . . = " < . > . . /

説明

このゴルフバージョンのすべての複雑な実行パスを説明しようとはしませんが、アルゴリズムと全体的な制御フローはこのアルゴリズムなしと同じです。

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

正直なところ、最初の段落では、私は半分冗談を言っていました。6つの要素のサイクルを扱っているという事実は、実際に大きな助けになりました。Hexagonyのメモリモデルは無限の六角形グリッドで、グリッドの各エッジにはゼロに初期化された符号付き任意精度整数が含まれます。

このプログラムで使用したメモリのレイアウトの図を次に示します。

左側の長い直線ビットaは、文字rに関連付けられている任意のサイズの0で終わる文字列として使用されます。他の文字の破線は同じ種類の構造を表し、それぞれが60度回転しています。最初に、メモリポインターは、北を向いた1というラベルの付いたエッジを指します。

コードの最初の、線形のビットは、内部文字の縁の「星」を設定roygbpならびに初期エッジを設定し1、我々はここで、サイクル終了/（間始まる知っているように、pそしてr：）

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

この後、1というラベルの付いたエッジに戻ります。

アルゴリズムの一般的な考え方は次のとおりです。

1. サイクル内の各文字について、STDINからの文字を読み続け、現在の文字と異なる場合は、その文字に関連付けられている文字列に追加します。
2. 現在探している文字を読むと、？eというラベルの付いたエッジにを格納します。サイクルが完全でない限り、このキャラクターも食べなければならないと仮定する必要があるためです。その後、サイクル内の次のキャラクターにリングを移動します。
3. このプロセスを中断するには、次の2つの方法があります。
   • いずれかのサイクルを完了しました。この場合、サイクルの別のクイックラウンドを作成eし、？のすべてのを置き換えます。エッジnsが、今はそのサイクルがネックレスに残りたいので。次に、コードの印刷に進みます。
   • または、 EOFをヒットします（これは負の文字コードとして認識されます）。この場合、負の値を？に書き込みます。現在の文字の端（eとの両方から簡単に区別できるようにn）。次に、印刷コードに移動する前に、1つのエッジを検索します（潜在的に不完全なサイクルの残りをスキップします）。
4. 印刷コードは再びサイクルを通過します。サイクル内のe各文字について、各文字の印刷中に保存された文字列をクリアします。次に、？に移動します。キャラクターに関連付けられたエッジ。否定的な場合は、単にプログラムを終了します。肯定的な場合は、単に印刷して次の文字に進みます。サイクルが完了したら、ステップ2に戻ります。

もう1つ興味深いのは、任意のサイズの文字列を実装した方法です（Hexagonyで無制限のメモリを使用したのは初めてだからです）。

ある時点でrの文字を読み続けており（図をそのまま使用できる）、a [0]とa 1がすでに文字で埋められていることを想像してください（それらの北西はすべてゼロです） ）。たとえばog、入力の最初の2文字をこれらのエッジに読み込んで、現在aを読み込んでいる可能性がありyます。

新しい文字がに読み込まれている中のエッジ。？を使用します この文字がに​​等しいかどうかを確認するためのエッジr。（ここには巧妙なトリックがあります：六角形は正と非正を簡単に区別できるため、減算による同等性のチェックは厄介で、少なくとも2つのブランチが必要です。しかし、すべての文字は互いに2倍未満です。モジュロを取ることで値を比較できます。モジュロは、等しい場合にのみゼロを返します。

yとは異なるためr、（ラベルのない）エッジをinの左に移動し、yそこにコピーします。ここで、六角形の周りをさらに移動して、inのy反対側のエッジにあるまで、文字を1エッジずつコピーします。ただし、a [0]には既に上書きしたくない文字が既にあります。代わりに、y次の六角形の周りを「ドラッグ」して1をチェックします。しかし、そこにもキャラクターがいるので、さらに六角形を進めます。これでa [2]はまだゼロなので、コピーしますyそれに。メモリポインタは、文字列に沿って内側のリングに向かって戻ります。a [i]の間の（ラベルのない）エッジはすべてゼロであるのに対し、？ポジティブです。

これはおそらく、一般的にHexagonyで自明でないコードを書くのに役立つテクニックでしょう。

六角形、169バイト

私はMartinBüttnerの答えに触発され（それは彼のエソランでもあります）、サイズ8でそれができると決めました（サイズ7でも可能であると確信していますが、それは非常に難しいです。私はすでに4日間過ごしました-これでやめて。）

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

六角形にレイアウト：

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

プログラムは実際に#命令を使用しないため、実際に使用されていないセルを示すためにその文字を使用しました。さらに、一方向にのみ移動するすべてのノーオペレーションセルはミラーであるため（_水平方向に移動する場合など）、すべての.文字が複数の方向に移動することがわかります。

説明

最初に、一連の命令を実行しますr''o{{y''g{{b''p"")"。これらは、他のすべてを書いた後にそれらを絞ったので、コードに少し無計画に散らばっています。]次の命令ポインターに数回切り替えるために使用します。このようにして、本質的に六角形の別のコーナーにテレポートできます。プログラムの残り全体は、命令ポインター＃3によって実行されます。

メモリは次のようになります。重要なエッジには、この説明で使用する名前がラベル付けされています。

ラベルの付いたエッジの意味は次のとおりです。

• in：このエッジを使用して、STDINから読み取った文字を格納します。
• %：私たちは、STDINから読み込む文字の剰余演算（実行するには、このエッジを使用in）し、現在の「有効」の文字（r、oになる、など）、0それらが等しい場合を。MartinBüttnerの答えからこのトリックを盗みましたが、プログラムの残りの部分は異なります。
• #：「無効な」文字（つまり、食べる必要のある色）を読み取る限り、このエッジを増やします。したがって、このエッジは、e後で出力する必要があるの数を記憶しています。
• r?：（赤い）部分がある0場所を除いて常にr。これにより、サイクルが完了したことがわかります。

プログラムは次のように進みます。

• 文字を読み続けます。現在探しているキャラクターではない場合、インクリメントします#。それ以外の場合は、時計回りの順序でメモリの次のセグメントに移動します。
• 次のセグメントに移行する場合r?、肯定的であれば、私たちは完全な革命を起こしました。完全なラウンドおよび出力# esを作成し、nセグメントごとに1を作成します。これにより、それぞれがに#戻り0ます。（eはラベルのないエッジに配置されますがn、#エッジを不正に0使用する*ため、後で（乗算）を使用するように設定し%ます。これは、現時点ではすべてのエッジがゼロであることがわかっているため機能します。）
• 文字を読み取るときに、正でない（つまりEOF）場合は、円を逆方向に移動し、正の位置に戻るまで#+1 を出力しeてからr?終了します。

完全に実行すると、メモリは最後に次のようになります。101（のASCIIコードe）を含むエッジに気付くでしょう。inエッジの1つは-1（EOF）です。すべての#エッジは0です。また、メモリポインタはポジティブr?エッジで終了します。

網膜、148 85 79バイト

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

[^n]
e

-sインタープリターフラグを使用して、単一のソースファイルからこれを実行できます。

説明

最初に邪魔にならないように簡単なものを取得しましょう。

$
#roygbp

#roygbp文字列の末尾に追加します。これを使用して、文字のサイクルを動的に計算します。

次の（長い）ステップでは、保持するループを特定し、それらを置き換えますn。これがどのように機能するかを少し見ていきます。

#.*
<empty>

これにより、文字列の最後にあるルックアップヘルパーが削除されます。

[^n]
e

これにより、2番目のステップで置き換えられなかったすべての文字がに​​置き換えられe、変換が完了します。

それでは、2番目のステップに戻りましょう。

基本的な構造では、数か月前に発見したトリックを使用して、グローバルマッチで選択した文字を置き換えます。

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

は...、任意の複雑なパターンに対応します。これは、置き換えられる文字と一致し.、後読みを開始します（右から左に読む必要があります）。後読みは、マッチしたキャラクターまでのすべてをグループにキャプチャしますprefix。次に、先読みに切り替えます。これは、文字列の先頭から始まり、複雑なパターンを含むことができます。そのパターンで置き換えたい文字の後に、オプションのlook behindを配置し、prefixグループがここで一致するかどうかを確認します。存在する場合、空の文字列をキャプチャしますflagグループ。そうでない場合、オプションであるため、正規表現エンジンの状態にはまったく影響せず、無視されます。最後に、先読みが正常に一致する\k<flag>と、最後の部分のみが残ります。これは、計算中のある時点でフラグが設定された場合にのみ一致します。

それでは、名前付きグループとフリースペースモードを使用して、長い正規表現を少しだけ試しましょう。

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

上記の一般的な概要をご理解いただければ幸いです。したがって、私が記入した内容のみを確認する必要があります...。

サイクルの次のキャラクターをグループに取り込みたいですchar。これは、の文字​​列をから#現在の文字まで記憶することでも行いますcycle。次の文字を取得するには、先読みを使用してを検索します#。次に、の一致を試みてからcycle、次の文字を一致させcharます。これは通常char、最後の文字でない限り可能pです。この場合、\k<cycle>は文字列の残り全体と一致し、にキャプチャする文字が残りませんchar。そのため、エンジンはバックトラックをcycle行い、後方参照を省略し、r代わりに最初の文字に一致します。

サイクルの次の文字を取得しました。次にchar、その文字の次の出現をで検索し.*?\k<char>ます。これらは置換したい文字なので、prefixその後にチェックを入れます。これらのステップ（charサイクル内の次を見つけ、次の出現を検索し、必要に応じてフラグを設定する）は、で繰り返されます+。

実際には、循環サブシーケンスを見つけることはこれですべてですが、aで終了することも確認する必要がありpます。これは非常に簡単です。現在格納されている値が、文字列の末尾のにchar一致することを確認するだけです。また、このチェックの末尾が必要なので、ルックアップ文字列が不完全なサイクルを終了するために使用されないようにします。p.*\k<char>$p

Python 2、133 130126121バイト

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

最初のループはサイクルを取得し、2番目のループは不完全なサイクルを削除します

JFとDLoscの5のおかげで3バイト節約

Perl 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

Lua、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」に置き換えます。

Javascript（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``
")

gawk、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%

オンラインで試す

これは、他のサブミッションよりも少し長くなりますが、線形の複雑さで非常に効率的です。入力文字列をスキャンし、文字を1つずつ照合します。

アルゴリズムの中核部分は実際にはかなりコンパクトです。コードの約半分は、最後に不完全なサイクルを削除するためのものです。

C90、142-146バイト（119まで、依存）

直線的な時間で動作し、きれいな虹の一部ではないフルーツループを効率的に食べます。次に、ポストプロセスは最後に部分的なループをすべて終了します。

4つのバージョンがあります。

• バージョン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);}

• バージョン2（142バイト）、次で呼び出す[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わかりやすくするために末尾を出力します。

バージョン1のみが要件を明確に満たしていますが、バージョン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特に、気まずい感じが<Jzしますが、必要な文字列を指定しませんJ == 0。つまり、入力が「p」で終わる場合。

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

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

提案を歓迎します！

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

失礼します。：P