假设您要在项链，手链，鞋带或其他物品上串一串Froot Loops。有6层环的颜色：- [R编，ö范围，ÿ ellow，克颖，b略，和p urple。您希望您的线束从最左边的红色开始，以彩虹顺序向右循环，以紫色结束。就是说，您想要这样做，以便您的链可以由roygbp重复多次（可能为0）的字符串表示。

问题是，您已经串起了循环，没有按任何特定的顺序进行。您应该吃还是不吃哪个循环，以便最大程度地增加从左到右的正确彩虹循环次数，第一个循环为红色，最后一个循环为紫色？

编写一个程序或函数，该程序或函数接受任意字符串，roygbp并打印或返回相同长度的字符串，e以代替要吃的循环和不吃东西n的循环。

例如，如果您的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即为false。.D接受字符串和索引列表，并删除这些索引处的元素。所以.D"abcd",1 3是"ac"。由于.D返回的列表（实际情况并非如此，将在以后的Pyth版本中修复），因此我使用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个实际命令，其中许多命令可能是不必要的镜像（或添加为取消）从交叉路径发出命令）。

尽管有明显的线性关系，但代码实际上是二维的：Hexagony会将其重新排列为规则的六边形（这也是有效的代码，但是在Hexagony中所有空格都是可选的）。这是展开的代码的全部...嗯，我不想说“ beauty”：

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

说明

我什至不会尝试开始解释这个高尔夫球版本中所有复杂的执行路径，但是算法和总体控制流程与此非高尔夫球版本相同，在我对算法进行解释之后，对于真正好奇的人可能更容易研究：

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

老实说，在第一段中，我只是在开玩笑。实际上，我们处理六个元素的周期实际上是一个很大的帮助。六边形的内存模型是一个无限的六边形网格，其中网格的每个边都包含一个有符号的任意精度整数，该整数初始化为零。

这是我在该程序中使用的内存布局图：

左侧的长直位用作a与字母r关联的任意大小的0终止字符串。其他字母上的虚线表示相同类型的结构，每个结构旋转60度。最初，内存指针指向标记为1的边，朝北。

代码的第一个线性位将边的内部“星号” roygbp设置为字母，并将初始边设置为1，以便我们知道循环的结束/起点（p和之间r）：

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

之后，我们回到标记为1的边缘。

现在，该算法的总体思路是：

1. 对于循环中的每个字母，请继续从STDIN读取字母，如果它们与当前字母不同，则将它们附加到与该字母关联的字符串中。
2. 当我们阅读我们正在寻找的字母时，我们e在标记为？的边中存储一个。，因为只要周期还没有结束，我们就必须假设我们也必须吃掉这个角色。之后，我们将在环上移动到循环中的下一个字符。
3. 有两种方法可以中断此过程：
   • 要么我们已经完成了循环。在这种情况下，我们将在循环中进行下一轮快速替换，替换？中的所有那些e。边加上s，因为现在我们希望该循环保留在项链上。然后我们继续打印代码。n
   • 或者我们点击EOF（我们将其识别为负字符代码）。在这种情况下，我们将负值写入？中。当前字符的边缘（以便我们可以轻松地将其与e和区别开n）。然后，在移至打印代码之前，搜索1边（以跳过可能不完整的循环的其余部分）。
4. 打印代码再次经过该循环：对于循环中的每个字符，它会在打印e每个字符时清除存储的字符串。然后它移动到了？与角色关联的边缘。如果结果是否定的，我们只需终止程序即可。如果是正数，我们只需打印它，然后移至下一个字符。完成周期后，我们将返回第2步。

另一件可能有趣的事情是我如何实现任意大小的字符串（因为这是我第一次在Hexagony中使用无边界内存）。

试想一下，我们在某个地步，我们还在读书的角色- [R （所以我们可以使用图原样）和一个[0]和一个1已经充满了字符（一切西北部他们仍然是零）。例如，也许我们刚刚og将输入的前两个字符读入这些边，现在正在读取y。

新字符被读入in边缘。我们用？边检查此字符是否等于r。（这里有一个巧妙的技巧：六边形只能轻松区分正数和非正数，因此通过减法检查相等性很烦人，并且至少需要两个分支。但是所有字母之间的相乘系数均小于2，因此我们可以通过取模来比较这些值，如果它们相等，它们只会给出零。）

由于y是从不同的r，我们向左移动的（未标记的）边缘中并复制y那里。现在，我们围绕六边形进一步移动，每次将字符复制到另一个边缘，直到在iny相对的边缘上。但是现在a [0]中已经有一个字符，我们不想覆盖它。相反，我们“拖”的周围跟旁边的六边形，检查一1。但是那里也有一个角色，所以我们进一步扩大了另一个六边形。现在a [2]仍为零，因此我们复制yy进去。现在，内存指针沿着字符串向内环移动。我们知道何时到达字符串的开头，因为a [i]之间的（未标记）边全为零，而？是？是积极的。

一般而言，这可能是一种有用的技巧，可以用Hexagony编写非平凡的代码。

六边形，169字节

马丁·布特纳（MartinBüttner）的回答启发了我（这也是他的esolang），并决定我可以在8号尺码上做到这一点。（我坚信7号尺码也可以做到，但是这很困难。 -停止。）

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读取的字符。
• %：我们使用这个边缘上（从标准输入读取的字符进行模运算in）和当前的“有效”字符（r，o，等），这将是0，如果他们是平等的。我从马丁·布特纳（MartinBüttner）的答案中窃取了这个技巧，但是程序的其余部分是不同的。
• #：只要我们读“无效”字符（即我们需要吃的颜色），我们就会增加该边缘。因此，该边记住了e我们以后需要输出多少s。
• r?：总是（红色部分0除外r）。这告诉我们何时完成一个周期。

程序因此进行：

• 继续阅读字符。如果不是我们当前要查找的字符，请递增#。否则，请按顺时针顺序移至内存的下一段。
• 进入下一个细分市场时，如果r?肯定的话，我们已经进行了一次完整的革命。进行完整的回合并输出# es和n每段1 。这会将每个设置#回0。（将e放置在未标记的边缘上，但是由于n我们不恰当#地0使用了边缘，之后我们将其设置为使用*（乘法），这是可行的，因为我们知道此时所有%边缘均为零。）
• 读取一个字符时，如果它不是正数（即EOF），请向后旋转圆圈并输出#+1 es，直到回到r?正数位置，然后退出。

完成运行后，该存储器最后看上去大致如下。您会注意到包含的边缘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>

其中...对应于任意复杂的模式。这与要替换的字符匹配.，然后开始向后看（应该从右到左阅读）。后向捕捉将直到匹配字符的所有内容捕获到一个组中prefix。然后切换到向前看，现在从字符串的开头开始，可以包含一个复杂的模式。在我们要在该模式中替换的字符之后，我们在后面放了一个可选的外观，该外观检查prefix组是否在此处匹配。如果是这样，它将捕获一个空字符串到flag组。如果不是，则因为它是可选的，所以它根本不会影响正则表达式引擎的状态，因此将被忽略。最后，一旦成功匹配了前瞻，则仅\k<flag>剩下末端的，只有在计算过程中将标记设置为某个点时，末端才匹配。

现在，通过使用命名组和freespacing模式，使长的正则表达式略微松开：

.
(?<=
  (?=
    (?:
      (?=
        .*#
        (?<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现在，只需使用重复执行这些步骤（查找循环中的下一个，搜索下一个出现的位置，如果合适的话设置标志）+。

找到循环子序列实际上就是所有这些，但是我们还需要确保以结尾p。这相当简单：只需使用来检查当前存储在其中的值是否与字符串末尾的char匹配。这也确保了我们的查找字符串不会用于完成不完整的循环，因为我们需要此检查的结尾。p.*\k<char>$p

Python 2中，133个130 126 121字节

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

第一个循环获得循环，第二个循环除去不完整的循环

通过JF和DLosc节省了3个字节，节省了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``")

小提琴在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);}

• 第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彩虹类型！

较小的限制：机器必须具有带符号的字符（一般情况下），并且字符串必须相当短。\n为清晰起见，输出尾随。

尽管版本2值得商。，但版本1是唯一明确满足要求的版本。版本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