Suponga que está ensartando un hilo de Froot Loops para un collar, pulsera, cordón de zapatos o lo que sea. Hay 6 colores de bucle: r ed, o range, y ellow, g reen , b lue y p urple. Desea que su hebra comience con rojo en el extremo izquierdo y realice un ciclo en el orden del arco iris hacia la derecha, terminando con púrpura. Es decir, desea hacerlo para que su cadena pueda ser representada por la cadena roygbprepetida varias veces (posiblemente 0).

El problema es que ya has conectado tus bucles, y no en ningún orden en particular. ¿Qué bucles debe comer y no comer para poder maximizar el número de ciclos de arco iris correctos de izquierda a derecha, con el primer bucle rojo y el último bucle púrpura?

Escriba un programa o función que tome una cadena arbitraria de los caracteres roygbpe imprima o devuelva una cadena de la misma longitud een lugar de bucles para comer y nen lugar de bucles para no comer.

Por ejemplo, si su hebra de Froot Loop se parecía a

la entrada sería

gorboypbgbopyroybbbogppbporyoygbpr

y de izquierda a derecha podemos encontrar 3 roygbpsecuencias de arcoíris completas , pero algunos de los bucles deben ser eliminados. Por lo tanto, la salida sería

eenenneennenennneeeeneennenennnnne

resultando en una cadena perfecta de 3 ciclos:

Si no hay ciclos de arco iris completos en la entrada, entonces la salida sería todo ey la cadena termina sin bucle. Por ejemplo, la entrada proygbtiene salida eeeeee. Por el contrario, proygbptiene salida ennnnnn.

Puede suponer que todos los hilos de entrada tienen al menos un bucle.

El código más corto en bytes gana.

Pyth, 31 bytes

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

Increíblemente ineficiente, la explicación llegará pronto.

yUlzgenera todos los subconjuntos posibles de todos los índices posibles de z(la entrada) en orden. Por ejemplo, si la entrada es abc:

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

Luego hf!encuentra el primero Ten la lista anterior, que :jk.DzT"roygbp"kes falso. .Dtoma una cadena y una lista de índices, y elimina los elementos en esos índices. Así .D"abcd",1 3es "ac". Como .Ddevuelve una lista (que no debería ser el caso, se solucionará en futuras versiones de Pyth), uso jk( kes "") para unirla nuevamente en una cadena. La :_"roygbp"kparte reemplaza cada instancia de un ciclo con la cadena vacía.

Como la cadena vacía es falsa, los párrafos anteriores explican cómo encuentro el conjunto más pequeño de índices necesarios para comer para obtener una cadena que consta solo de ciclos.

:*lz\n_\eluego convierte esa lista de índices en una nnnneeennenecadena.

Hexagony , 920 722 271 bytes

¿Seis tipos diferentes de bucles de fruta, dices? Para eso fue hecha Hexagony.

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

De acuerdo, no lo fue. Oh dios, que me hice a mi mismo ...

Este código ahora es un hexágono de longitud lateral 10 (comenzó en 19). Probablemente podría jugar un poco más, tal vez incluso hasta el tamaño 9, pero creo que mi trabajo se hace aquí ... Como referencia, hay 175 comandos reales en la fuente, muchos de los cuales son espejos potencialmente innecesarios (o se agregaron para cancelar un comando desde un cruce).

A pesar de la aparente linealidad, el código es en realidad bidimensional: Hexagony lo reorganizará en un hexágono regular (que también es un código válido, pero todo el espacio en blanco es opcional en Hexagony). Aquí está el código desplegado en todos sus ... bueno, no quiero decir "belleza":

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

Explicación

Ni siquiera intentaré comenzar a explicar todas las rutas de ejecución complicadas en esta versión de golf, pero el algoritmo y el flujo de control general son idénticos a esta versión sin golf que podría ser más fácil de estudiar para los realmente curiosos después de haber explicado el algoritmo:

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

Honestamente, en el primer párrafo solo bromeaba a medias. El hecho de que estemos lidiando con un ciclo de seis elementos fue realmente una gran ayuda. El modelo de memoria de Hexagony es una cuadrícula hexagonal infinita donde cada borde de la cuadrícula contiene un entero de precisión arbitraria con signo, inicializado a cero.

Aquí hay un diagrama del diseño de la memoria que he usado en este programa:

El bit recto largo de la izquierda se usa como una cadena terminada en 0 ade tamaño arbitrario que está asociada con la letra r . Las líneas discontinuas en las otras letras representan el mismo tipo de estructura, cada una rotada 60 grados. Inicialmente, el puntero de memoria apunta al borde con la etiqueta 1 , hacia el norte.

El primer bit lineal del código establece la "estrella" interna de los bordes en las letras roygbpy establece el borde inicial en 1, de modo que sepamos dónde termina / comienza el ciclo (entre py r):

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

Después de esto, volvemos al borde etiquetado como 1 .

Ahora la idea general del algoritmo es esta:

1. Para cada letra del ciclo, siga leyendo las letras de STDIN y, si son diferentes de la letra actual, agréguelas a la cadena asociada con esa letra.
2. Cuando leemos la carta que estamos buscando actualmente, almacenamos una een el borde con la etiqueta ? , porque mientras el ciclo no esté completo, debemos suponer que también tendremos que comer este personaje. Luego, nos moveremos alrededor del anillo hasta el siguiente personaje del ciclo.
3. Hay dos formas de interrumpir este proceso:
   • O hemos completado el ciclo. En este caso, hacemos otra ronda rápida a través del ciclo, reemplazando todos esos es en el ? bordes con ns, porque ahora queremos que ese ciclo permanezca en el collar. Luego pasamos a imprimir código.
   • O presionamos EOF (que reconocemos como un código de carácter negativo). En este caso, escribimos un valor negativo en el ? borde del carácter actual (para que podamos distinguirlo fácilmente de ambos ey n). Luego buscamos el borde 1 (para omitir el resto de un ciclo potencialmente incompleto) antes de pasar también al código de impresión.
4. El código de impresión vuelve a pasar por el ciclo: para cada carácter del ciclo, borra la cadena almacenada mientras imprime un epara cada carácter. Entonces se mueve a la ? borde asociado con el personaje. Si es negativo, simplemente terminamos el programa. Si es positivo, simplemente lo imprimimos y pasamos al siguiente personaje. Una vez que completamos el ciclo, volvemos al paso 2.

Otra cosa que puede ser interesante es cómo he implementado las cadenas de tamaño arbitrario (porque es la primera vez que uso memoria sin límites en Hexagony).

Imagine que estamos en algún punto en el que todavía estamos leyendo caracteres para r (para que podamos usar el diagrama tal como está) y un [0] y un 1 ya se han llenado de caracteres (todo el noroeste de ellos sigue siendo cero) ) Por ejemplo, quizás acabamos de leer los dos primeros caracteres ogde la entrada en esos bordes y ahora estamos leyendo a y.

El nuevo carácter se lee en el en el borde. Usamos el ? borde para verificar si este carácter es igual a r. (Aquí hay un truco ingenioso: la hexagonía solo puede distinguir entre positivo y no positivo fácilmente, por lo que verificar la igualdad por sustracción es molesto y requiere al menos dos ramas. Pero todas las letras son menos que un factor de 2 entre sí, por lo que podemos comparar los valores tomando el módulo, que solo dará cero si son iguales).

Debido a que yes diferente de r, movemos el borde (sin marcar) a la izquierda de adentro y copiamos yallí. Ahora nos movemos más alrededor del hexágono, copiando el personaje un borde más cada vez, hasta que tengamos yel borde opuesto a in . Pero ahora ya hay un carácter en un [0] que no queremos sobrescribir. En cambio, "arrastramos" yalrededor del siguiente hexágono y verificamos un 1 . Pero también hay un personaje allí, así que vamos a otro hexágono más lejos. Ahora un [2] sigue siendo cero, así que copiamos elyen ello. El puntero de memoria ahora retrocede a lo largo de la cuerda hacia el anillo interno. Sabemos cuándo hemos llegado al comienzo de la cadena, porque los bordes (no marcados) entre a a [i] son todos cero, mientras que ? es positivo.

Probablemente sea una técnica útil para escribir código no trivial en Hexagony en general.

Hexagonía , 169 bytes.

Me inspiró la respuesta de Martin Büttner (también es su esolang) y decidí que puedo hacerlo en la talla 8. (Estoy convencido de que también es posible en la talla 7, pero es muy difícil. Ya he pasado cuatro días sin -Detente en esto.)

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

Presentado hexagonalmente:

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

El programa en realidad no usa la #instrucción, así que he usado ese carácter para mostrar qué celdas están realmente sin usar. Además, cada celda no operativa que se atraviesa en una sola dirección es un espejo (por ejemplo, _si se atraviesa horizontalmente), por lo que sabe que todos los .caracteres se atraviesan en más de una dirección.

Explicación

Al principio, ejecutamos la secuencia de instrucciones r''o{{y''g{{b''p"")". Estos están esparcidos un poco al azar en el código porque los introduje después de escribir todo lo demás. Yo uso ]para cambiar al siguiente puntero de instrucción varias veces; de esta manera puedo teletransportarme esencialmente a otra esquina del hexágono. Todo el resto del programa se ejecuta mediante el puntero de instrucción # 3.

La memoria ahora se ve de la siguiente manera, con los bordes importantes etiquetados con nombres que usaré en esta explicación:

Los bordes etiquetados significan lo siguiente:

• in: Utilizamos este borde para almacenar un personaje que leemos de STDIN.
• %: Utilizamos este borde para realizar una operación de módulo en el carácter de stdin ( in) y el carácter actual “válida” ( r, o, etc.), los cuales serán 0si son iguales. Robé este truco de la respuesta de Martin Büttner, pero el resto del programa es diferente.
• #: Mientras leamos caracteres "inválidos" (es decir, colores que necesitamos comer), incrementaremos este borde. Por lo tanto, este borde recuerda cuántos es necesitamos generar más tarde.
• r?: Siempre 0excepto donde está la parte r(roja). Esto nos dice cuándo hemos completado un ciclo.

El programa procede así:

• Sigue leyendo personajes. Si no es el personaje que estamos buscando actualmente, incremente #. De lo contrario, pase al siguiente segmento de la memoria en el sentido de las agujas del reloj.
• Al pasar al siguiente segmento, si r?es positivo, hemos hecho una revolución completa. Realice una ronda completa y produzca # esy 1 npor segmento. Esto hace que cada uno #vuelva a 0. (El ese coloca en un borde sin etiquetar, pero para el nmal uso del #borde, que configuramos para 0usar después una *(multiplicación), lo que funciona porque sabemos que todos los %bordes son cero en este momento).
• Al leer un carácter, si no es positivo (es decir, EOF), retroceda a través del círculo y genere #+1 es hasta que regrese a donde r?es positivo, luego salga.

Después de una ejecución completa, la memoria se ve aproximadamente como sigue al final. Notará los bordes que contienen 101(el código ASCII de e); uno de los inbordes es -1(EOF); todos los #bordes están en 0; y el puntero de memoria termina en el r?borde positivo .

Retina , 148 85 79 bytes

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

[^n]
e

Puede ejecutar esto desde un único archivo fuente con el -sindicador de intérprete.

Explicación

Primero saquemos las cosas simples del camino:

$
#roygbp

Se agrega #roygbpal final de la cadena, que usaremos para calcular el ciclo de letras dinámicamente.

El siguiente paso (largo) determina qué bucles mantener y los reemplaza n. Veremos cómo funciona esto en un momento.

#.*
<empty>

Esto elimina nuestro asistente de búsqueda al final de la cadena.

[^n]
e

Esto reemplaza todos los personajes que no fueron reemplazados en el segundo paso con e, completando la transformación.

Ahora volvamos al segundo paso.

La estructura básica utiliza un truco, que descubrí hace unos meses para reemplazar los caracteres seleccionados en una coincidencia global:

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

donde ...corresponde a un patrón arbitrariamente complejo. Esto coincide con el carácter con el que se va a reemplazar .y luego comienza una mirada hacia atrás (que debe leer de derecha a izquierda). La mirada atrás captura todo, hasta el personaje coincidente, en un grupo prefix. Luego cambia a una mirada hacia adelante , que ahora comienza desde el principio de la cadena y puede contener un patrón complejo. Después del carácter que queremos reemplazar en ese patrón, colocamos una mirada opcional detrás , que verifica si el prefixgrupo coincide aquí. Si lo hace, captura una cadena vacía en elflaggrupo. Si no lo hace, porque es opcional, no afecta el estado del motor regex en absoluto y se ignora. Finalmente, una vez que la búsqueda anticipada coincide con éxito, solo queda el \k<flag>final, que solo coincide si la bandera se estableció en algún momento durante el cálculo.

Ahora eliminemos un poco la expresión regular larga utilizando grupos con nombre y el modo de espacio libre:

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

Espero que reconozca el esquema general de arriba, por lo que solo necesitamos ver lo que completé ....

Queremos capturar al siguiente personaje del ciclo en el grupo char. Hacemos esto también recordando la cadena desde #el carácter actual en cycle. Para obtener el siguiente personaje, usamos una búsqueda anticipada para buscar el #. Ahora intentamos unir cycley luego unir el siguiente personaje char. Esto generalmente será posible, a menos que charsea ​​el último personaje p. En este caso, \k<cycle>coincidirá con el resto de la cadena y no quedará ningún personaje para capturar char. Por lo tanto, el motor retrocede, omite la referencia cycley simplemente coincide con el primer carácter r.

Ahora que tenemos el siguiente personaje en el ciclo char, buscamos la próxima posible aparición de ese personaje con .*?\k<char>. Estos son los caracteres que queremos reemplazar, por lo que colocamos el prefixcheque después. Estos pasos (encontrar el siguiente charen el ciclo, buscar la próxima aparición del mismo, establecer la marca si es apropiado) ahora simplemente se repiten con a +.

En realidad, eso es todo para encontrar la subsecuencia cíclica, pero también debemos asegurarnos de que terminemos con a p. Esto es bastante fácil: solo verifique que el valor almacenado actualmente charcoincida pcon al final de la cadena con .*\k<char>$. Esto también asegura que nuestra cadena de búsqueda no se use para finalizar un ciclo incompleto, porque necesitamos el seguimiento pde esta verificación.

Python 2, 133 130 126 121 bytes

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

El primer ciclo obtiene ciclos, y el segundo elimina un ciclo incompleto.

Guardado 3 bytes gracias a JF y 5 de DLosc

Perl 5, 76 65 bytes

Una pizca de expresiones regulares puras sin diluir.
Primero encuentra lo que no se debe comer. Lo que queda es comestible.

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

Prueba

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

Lua, 101 bytes

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

Utiliza patrones de Lua de forma creativa; Creo que es un enfoque interesante.

Reemplaza todos los caracteres no comidos con "*" s, reemplaza todos los caracteres alfanuméricos con "e" s, luego reemplaza todos los "*" s con "n" s.

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 probado en Firefox. Escuché que Chrome admite funciones de flecha ahora, pero aún no lo he probado en Chrome.

Sin golf:

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

Construye el patrón de búsqueda "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"y el reemplazo "\\1n\\2n\\3n\\4n\\5n\\6n". Después de ese reemplazo, declara todo alimento ("e"), eso no es parte de un arco iris completo.

Esta combinación garantiza automáticamente que no se dañará ningún arco iris durante esta operación, y que no se muestre ningún arco iris cortado al final.

Pyth, 42 bytes

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

Pruébelo en línea: demostración

CJam, 41 bytes

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

Enfoque de fuerza bruta que prueba todas las variaciones de comer / no comer y selecciona la que da como resultado el collar más largo y válido.

Pruébelo en línea en el intérprete de CJam .

CJam, 50 bytes

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

Pruébalo en línea

Esto es un poco más largo que algunas de las otras presentaciones, pero es muy eficiente con la complejidad lineal. Escanea a través de la cadena de entrada y coincide con los caracteres uno por uno.

La parte central del algoritmo es en realidad bastante compacta. Aproximadamente la mitad del código es para eliminar el ciclo incompleto al final.

C90, 142-146 bytes (hasta 119, dependiendo)

Opera en tiempo lineal para comer eficientemente esos bucles de frutas que no pueden ser parte de un bonito arco iris. Luego, un postproceso mata cualquier bucle parcial al final.

Aquí hay cuatro versiones:

• Versión 1 (146 bytes), llame con [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);}

• Versión 2 (142 bytes), llame con [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);}
  Esto le permite definir su propio orden de arco iris con los colores que desee, siempre que no lo sean no e. ¡Esto realmente hace que el código sea más corto!

• Versión 3 (123 bytes), llame como la versión 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);}
  Esta le brinda la mayor cantidad posible de su arco iris! ¡Los arcoíris finales incompletos muestran promesa! ¡No debemos comerlos!

• Versión 4 (119 bytes), llamada como la versión 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);}
  Igual que la versión 3, pero TIPOS DE ARCO IRIS!

Limitación menor: la máquina debe tener caracteres firmados (el caso general) y la cadena debe ser bastante corta. Emite un final \npara mayor claridad.

La versión 1 es la única que claramente pasa los requisitos, aunque la versión 2 es discutible. Las versiones 3 y 4 son una interpretación menos correcta (pero aún divertida) de la pregunta.

Pyth, 38 bytes

Sé que esto es significativamente más largo que la respuesta de orlp, pero esta se ejecuta en tiempo lineal: o)

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

Pruébalo aquí .

En resumen, este programa reemplaza todos los caracteres después de la 'p' final con espacios, luego itera sobre cada carácter en la cadena resultante. Si el personaje es el siguiente en la secuencia 'roygbp', imprima 'n', de lo contrario imprima '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

Me costó encontrar una forma más corta de procesar la cadena de entrada. _>_zJen particular se siente incómodo, pero <Jzno da la cadena requerida cuando J == 0, es decir, cuando la entrada termina con una 'p'.

Haskell, 138 bytes

g lo hace.

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 bytes

La regla "el collar debe terminar en púrpura" fue originalmente un gran obstáculo, ya que aumentó mi puntaje de 66 a 125, pero encontré un camino más corto (¡afortunadamente!).

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

Explicación:

Este código recorre cada carácter en la entrada y reemplaza cada uno con ro econ esta lógica:

• Si la posición del personaje es <= la última posición de p, Y el personaje es el siguiente en el arco iris, manténgalo (reemplácelo con n).
• De lo contrario, cómelo (reemplázalo con e).

Sin golf:

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

Sugerencias bienvenidas!

Python 2, 254 bytes

Bucles!

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

Disculpe el juego de palabras. :PAGS