Supposons que vous enfilez une chaîne de Froot Loops pour un collier, un bracelet, un lacet ou autre chose. Il y a 6 couleurs en boucle: r ed, o gamme, y ellow, g reen, b Lue, et p urple. Vous voulez que votre brin commence avec le rouge à l'extrême gauche et effectue un cycle dans l'ordre arc-en-ciel allant vers la droite, se terminant par le violet. C'est-à-dire que vous voulez que votre brin soit représenté par la chaîne roygbprépétée un certain nombre de fois (éventuellement 0).

Le problème est que vous avez déjà bouclé vos boucles, et non dans un ordre particulier. Quelles boucles devez-vous manger et ne pas manger pour pouvoir maximiser le nombre de cycles arc-en-ciel corrects allant de gauche à droite, avec la toute première boucle rouge et la dernière boucle violette?

Ecrivez un programme ou une fonction qui prend une chaîne arbitraire de caractères roygbpet affiche ou renvoie une chaîne de même longueur avec eà la place des boucles à manger et nà la place des boucles à ne pas manger.

Par exemple, si votre fil Froot Loop ressemblait à

l'entrée serait

gorboypbgbopyroybbbogppbporyoygbpr

et de gauche à droite, nous pouvons trouver 3 roygbpséquences complètes d' arc-en-ciel, mais certaines boucles doivent être rongées. Ainsi, la sortie serait

eenenneennenennneeeeneennenennnnne

résultant en un cycle parfait de 3 cycles:

S'il n'y a pas de cycles complets d'arc-en-ciel dans l'entrée, la sortie sera tout eet le brin se termine sans boucle. Par exemple, l'entrée proygba une sortie eeeeee. Inversement, proygbpa sortie ennnnnn.

Vous pouvez supposer que tous les brins d’entrée ont au moins une boucle.

Le code le plus court en octets gagne.

Pyth, 31 octets

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

Incroyablement inefficace, explication à venir.

yUlzgénère tous les sous-ensembles possibles de tous les indices possibles de z(l'entrée) dans l'ordre. Par exemple, si l'entrée est abc:

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

Puis hf!trouve le premier Tdans la liste ci-dessus tel que :jk.DzT"roygbp"kfaux. .Dprend une chaîne et une liste d’index et supprime les éléments de ces index. Ainsi l' .D"abcd",1 3est "ac". Depuis .Drenvoie une liste (ce qui ne devrait pas être le cas, corrigera dans les futures versions de Pyth), je utilise jk( kest "") pour le joindre ensemble dans une chaîne. La :_"roygbp"kpièce remplace chaque instance d'un cycle par la chaîne vide.

Étant donné que la chaîne vide est fausse, les paragraphes ci-dessus expliquent comment trouver le plus petit ensemble d'indices nécessaire pour obtenir une chaîne composée uniquement de cycles.

:*lz\n_\etransforme ensuite cette liste d’index en nnnneeennenechaîne.

Hexagony , 920 722 271 octets

Six types de boucles de fruits, vous dites? C'est pour cela que Hexagony a été conçu .

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

Ok, ça ne l'était pas. Oh mon Dieu, qu'est-ce que je me suis fait ...

Ce code est maintenant un hexagone de côté 10 (il a commencé à 19). Cela pourrait probablement être joué un peu plus, peut-être même à la taille 9, mais je pense que mon travail est fait ici ... Pour référence, il y a 175 commandes réelles dans la source, dont beaucoup sont des miroirs potentiellement inutiles (ou ont été ajoutées pour annuler une commande depuis un passage à niveau).

Malgré l'apparente linéarité, le code est en fait à deux dimensions: Hexagony le réorganisera en un hexagone normal (qui est également un code valide, mais tous les espaces sont facultatifs dans Hexagony). Voici le code non plié dans tous ses aspects ... eh bien, je ne veux pas dire "beauté":

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

Explication

Je n'essaierai même pas de commencer à expliquer tous les chemins d'exécution compliqués de cette version golfée, mais l'algorithme et le flux de contrôle global sont identiques à cette version non golfée, qui pourrait être plus facile à étudier pour les plus curieux après avoir expliqué l'algorithme:

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

Honnêtement, dans le premier paragraphe, je ne plaisantais qu'à moitié. Le fait que nous ayons affaire à un cycle de six éléments était en fait une aide précieuse. Le modèle de mémoire de Hexagony est une grille hexagonale infinie où chaque bord de la grille contient un entier signé à précision arbitraire, initialisé à zéro.

Voici un schéma de la disposition de la mémoire que j'ai utilisée dans ce programme:

Le long bit droit à gauche est utilisé comme une chaîne ade taille arbitraire terminée par 0 qui est associée à la lettre r . Les lignes pointillées sur les autres lettres représentent le même type de structure, chacune pivotée de 60 degrés. Initialement, le pointeur de la mémoire pointe vers le bord étiqueté 1 , face au nord.

Le premier bit linéaire du code définit "l'étoile" intérieure des arêtes sur les lettres roygbpet définit l'arête initiale sur 1, de sorte que nous sachions où se termine / commence le cycle (entre pet r):

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

Après cela, nous sommes de retour sur le bord étiqueté 1 .

Maintenant, l’idée générale de l’algorithme est la suivante:

1. Pour chaque lettre du cycle, continuez à lire les lettres de STDIN et, si elles sont différentes de la lettre actuelle, ajoutez-les à la chaîne associée à cette lettre.
2. Lorsque nous lisons la lettre que nous recherchons actuellement, nous stockons un elibellé dans le bord ? , parce que tant que le cycle n’est pas terminé, nous devons supposer que nous devrons aussi manger ce personnage. Ensuite, nous nous déplacerons dans l'anneau jusqu'au prochain caractère du cycle.
3. Ce processus peut être interrompu de deux manières:
   • Soit nous avons terminé le cycle. Dans ce cas, nous faisons un autre tour rapide dans le cycle, en remplaçant tous ces es dans le ? bords avec ns, parce que maintenant nous voulons que ce cycle reste sur le collier. Ensuite, nous passons à l’impression de code.
   • Ou nous frappons EOF (que nous reconnaissons comme un code de caractère négatif). Dans ce cas, nous écrivons une valeur négative dans le ? bord du caractère actuel (afin que nous puissions facilement le distinguer des deux eet n). Ensuite, nous recherchons l’ arête 1 (pour ignorer le reste d’un cycle potentiellement incomplet) avant de passer également à l’impression de code.
4. Le code d'impression répète le cycle: pour chaque caractère du cycle, il efface la chaîne enregistrée lors de l'impression d'un epour chaque caractère. Ensuite, il passe à la ? bord associé au personnage. Si c'est négatif, nous terminons simplement le programme. Si c'est positif, nous l'imprimons simplement et passons au caractère suivant. Une fois le cycle terminé, nous revenons à l’étape 2.

Une autre chose qui pourrait être intéressante est la façon dont j'ai implémenté les chaînes de taille arbitraire (car c'est la première fois que j'utilise de la mémoire non limitée dans Hexagony).

Imaginez que nous sommes à un moment où nous sommes encore la lecture des caractères pour r (afin que nous puissions utiliser le schéma comme est) et un [0] et un 1 ont déjà été rempli de personnages (tout au nord-ouest d'entre eux est toujours zéro ) Par exemple, nous venons peut-être de lire les deux premiers caractères ogde l'entrée dans ces bords et nous lisons maintenant un y.

Le nouveau caractère est lu dans le en bord. Nous utilisons le ? bord pour vérifier si ce caractère est égal à r. (Il y a un truc astucieux ici: Hexagony ne peut faire la distinction que entre positif et non positif, donc vérifier l’égalité par soustraction est ennuyeux et nécessite au moins deux branches. Mais toutes les lettres sont moins qu’un facteur 2 les unes des autres, donc on peut comparer les valeurs en prenant le modulo, qui ne donnera zéro que si elles sont égales.)

Parce que yest différent r, on déplace le (non marqué) bord gauche de dans et copier le ylà. Nous allons maintenant plus loin dans l’hexagone, en copiant le caractère d’un bord à chaque fois, jusqu’à ce que nous ayons yle bord opposé de dans . Mais maintenant, il y a déjà un caractère dans un [0] que nous ne voulons pas écraser. Au lieu de cela, nous "glissons" yautour du prochain hexagone et vérifions un 1 . Mais il y a aussi un personnage là-bas, alors nous allons un autre hexagone plus loin. Maintenant, un [2] est toujours égal à zéro, nous copions donc leydans ça. Le pointeur de mémoire se déplace maintenant le long de la chaîne vers l'anneau intérieur. Nous savons quand nous avons atteint le début de la chaîne, car les arêtes (non étiquetées) entre les a [i] sont toutes égales à zéro alors que ? est positif.

Ce sera probablement une technique utile pour écrire du code non trivial dans Hexagony en général.

Hexagonie , 169 octets

La réponse de Martin Büttner m'a inspiré (c'est aussi son esolang) et j'ai décidé de le faire en taille 8. (Je suis convaincu que c'est aussi possible en taille 7, mais c'est très difficile. J'ai déjà passé quatre jours -stop sur ce point.)

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

Disposé en hexagone:

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

Le programme n'utilise pas réellement l' #instruction. J'ai donc utilisé ce caractère pour indiquer les cellules réellement inutilisées. De plus, chaque cellule non-op qui est traversée dans une seule direction est un miroir (par exemple, _si elle est horizontale), vous savez donc que tous les .caractères sont parcourus dans plus d'une direction.

Explication

Au début, nous exécutons la séquence d'instructions r''o{{y''g{{b''p"")". Celles-ci sont éparpillées un peu au hasard dans le code car je les ai insérées après avoir écrit tout le reste. J'ai l'habitude ]de passer plusieurs fois au pointeur d'instruction suivant; De cette façon, je peux me téléporter essentiellement dans un autre coin de l'hexagone. Le reste du programme est exécuté par le point d'instruction n ° 3.

La mémoire ressemble maintenant à ce qui suit, avec les bords importants étiquetés avec les noms que je vais utiliser dans cette explication:

Les bords étiquetés signifient ce qui suit:

• in: Nous utilisons ce bord pour stocker un caractère lu à partir de STDIN.
• %: Nous utilisons ce bord pour effectuer une opération modulo sur le caractère lu sur stdin ( in) et le caractère « valide » en cours ( r, o, etc.), qui seront 0si elles sont égales. J'ai volé cette astuce à la réponse de Martin Büttner, mais le reste du programme est différent.
• #: Tant que nous lisons des caractères "non valides" (c'est-à-dire des couleurs que nous devons manger), nous incrémentons ce bord. Ainsi, ce bord se souvient du nombre de es que nous devons sortir plus tard.
• r?: Toujours 0sauf là où se trouve la partie r(rouge). Cela nous indique quand nous avons terminé un cycle.

Le programme procède ainsi:

• Continuez à lire les caractères. Si ce n'est pas le personnage que nous recherchons actuellement, incrémentez-vous #. Sinon, passez au segment suivant de la mémoire dans le sens des aiguilles d'une montre.
• En passant au segment suivant, si r?c'est positif, nous avons fait toute une révolution. Faites un tour complet et une sortie # es et 1 npar segment. Cela #ramène chacun à 0. (Le eest placé sur un bord non étiqueté, mais pour le ndétournement #, nous avons opté pour 0une *multiplication par la suite, ce qui fonctionne, car nous savons que tous les %bords sont nuls à ce moment.)
• Lors de la lecture d'un caractère, s'il n'est pas positif (c.-à-d. EOF), revenez en arrière dans le cercle et restituez #+1 es jusqu'à ce que vous retourniez à où r?est positif, puis quittez.

Après une exécution complète, la mémoire se présente approximativement comme suit à la fin. Vous remarquerez les arêtes contenant 101(le code ASCII de e); l'un des inbords est -1(EOF); tous les #bords sont à 0; et le pointeur de mémoire se termine au r?bord positif .

Retina , 148 85 79 octets

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

[^n]
e

Vous pouvez l'exécuter à partir d'un seul fichier source avec l' -sindicateur interpréteur.

Explication

Commençons par les choses simples:

$
#roygbp

S'ajoute #roygbpà la fin de la chaîne, que nous utiliserons pour calculer le cycle de lettres de manière dynamique.

La prochaine (longue) étape consiste à déterminer les boucles à conserver et à les remplacer n. Nous verrons dans quelques instants comment cela fonctionne.

#.*
<empty>

Cela supprime notre assistant de recherche à la fin de la chaîne.

[^n]
e

Ceci remplace tous les caractères qui n'ont pas été remplacés dans la deuxième étape par e, complétant la transformation.

Revenons maintenant à la deuxième étape.

La structure de base utilise une astuce que j'ai découverte il y a quelques mois pour remplacer les caractères sélectionnés dans une correspondance globale:

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

où ...correspond à un motif arbitrairement complexe. Cela correspond au caractère à remplacer ., puis commence une recherche (à lire de droite à gauche). Le lookbehind capture tout dans le groupe correspondant au personnage correspondant prefix. Ensuite, il se tourne vers un regard vers l' avant , qui commence maintenant depuis le début de la chaîne et peut contenir un motif complexe. Après le caractère que nous souhaitons remplacer dans ce modèle, nous mettons un regard facultatif derrière , qui vérifie si le prefixgroupe correspond ici. Si c'est le cas, il capture une chaîne vide dans leflaggroupe. Si ce n'est pas le cas, car il est facultatif, cela n'affecte en rien l'état du moteur des expressions rationnelles et est ignoré. Enfin, une fois que le préfixe a été mis en correspondance avec succès, il ne reste que la \k<flag>fin, qui ne correspond que si le drapeau a été défini à un moment donné pendant le calcul.

Maintenant déverrouillons un peu la longue expression rationnelle en utilisant les groupes nommés et le mode freespacing:

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

J'espère que vous reconnaissez le plan général présenté ci-dessus. Il suffit donc de regarder ce que j'ai rempli ....

Nous voulons capturer le prochain caractère du cycle dans le groupe char. Nous faisons cela en nous rappelant également la chaîne allant #du caractère actuel dans cycle. Pour obtenir le caractère suivant, nous utilisons un préfixe pour rechercher le #. Maintenant, nous essayons de faire correspondre cycleet ensuite correspondre le caractère suivant dans char. Ce sera généralement possible, sauf s'il chars'agit du dernier caractère p. Dans ce cas, \k<cycle>correspondra au reste de la chaîne et il ne restera plus aucun caractère à capturer char. Ainsi, le moteur effectue un retour arrière, omet la référence arrière cycleet correspond simplement au premier caractère r.

Maintenant que nous avons le caractère suivant dans le cycle char, nous recherchons la prochaine occurrence possible de ce caractère avec .*?\k<char>. Ce sont les caractères que nous voulons remplacer, alors nous mettons la prefixvérification après. Ces étapes (recherche de la prochaine étape chardu cycle, recherche de la prochaine occurrence, définition éventuelle de l'indicateur) sont maintenant simplement répétées avec a +.

C'est en fait tout ce qu'il y a à trouver la sous-séquence cyclique, mais nous devons également nous assurer de terminer par un p. C’est assez simple: vérifiez que la valeur actuellement stockée charcorrespond pà la fin de la chaîne .*\k<char>$. Cela garantit également que notre chaîne de recherche n'est pas utilisée pour terminer un cycle incomplet, car nous avons besoin de la fin ppour cette vérification.

Python 2, 133 130 126 121 octets

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

La première boucle obtient des cycles et la seconde supprime un cycle incomplet

3 octets sauvés grâce à JF et 5 de DLosc

Perl 5, 76 65 octets

Une pincée d'expressions régulières pures et non diluées.
Trouve d'abord ce qui ne devrait pas être mangé. Ce qui reste est mangeable.

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

Tester

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

Lua, 101 octets

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

Utilise les motifs Lua de façon créative; Je pense que c'est une approche intéressante.

Il remplace tous les caractères non consommés par "*", remplace tous les caractères alphanumériques par "e", puis remplace tous les "*" s par "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 testé dans Firefox. J'entends maintenant que Chrome prend en charge les fonctions de flèche, mais je ne l'ai pas encore testé avec Chrome.

Ungolfed:

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

Construit le modèle de recherche "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"et le remplacement "\\1n\\2n\\3n\\4n\\5n\\6n". Après ce remplacement, tout ce qui est déclaré nourriture ("e") est déclaré, cela ne fait pas partie d'un arc-en-ciel complet.

Cette combinaison garantit automatiquement qu'aucun arc-en-ciel ne sera blessé pendant cette opération et qu'aucun arc-en-ciel coupé ne se présentera à la fin.

Pyth, 42 octets

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

Essayez-le en ligne: démonstration

CJam, 41 octets

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

Une approche de force brute qui essaie toutes les variations manger / ne pas manger et sélectionne celle qui donne le collier le plus long et le plus valide.

Essayez-le en ligne dans l' interprète CJam .

CJam, 50 octets

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

Essayez-le en ligne

C'est un peu plus long que certaines des autres soumissions, mais c'est très efficace avec une complexité linéaire. Il balaye la chaîne d'entrée et fait correspondre les caractères un par un.

La partie centrale de l’algorithme est en réalité assez compacte. Environ la moitié du code sert à supprimer le cycle incomplet à la fin.

C90, 142-146 octets (jusqu'à 119, en fonction)

Fonctionne en temps linéaire pour manger efficacement ces boucles de fruits qui ne peuvent pas faire partie d'un joli arc-en-ciel. Ensuite, un post-traitement supprime toute boucle partielle à la fin.

Voici quatre versions:

• Version 1 (146 octets), appelez avec [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 octets), appel avec [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);}
  Ceci vous permet de définir votre propre commande arc-en-ciel avec les couleurs de votre choix tant qu'elles ne le sont pas nou e. Cela raccourcit le code!

• Version 3 (123 octets), appelez comme la version 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);}
  Celle-ci vous donne le maximum de votre arc-en-ciel! Les arcs-en-ciel de fuite incomplets sont prometteurs! Nous ne devrions pas les manger!

• Version 4 (119 octets), appelez comme la version 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);}
  Identique à la version 3, mais MOAR RAINBOW TYPES!

Limitation mineure: la machine doit avoir des caractères signés (le cas général) et la chaîne doit être assez courte. Affiche un message \nde fin pour plus de clarté.

La version 1 est la seule qui réponde clairement aux exigences, bien que la version 2 puisse être discutée. Les versions 3 et 4 donnent une interprétation moins correcte (mais toujours amusante) de la question.

Pyth, 38 octets

Je sais que c'est beaucoup plus long que la réponse de orlp, mais celle-ci fonctionne en temps linéaire: o)

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

Essayez-le ici .

En bref, ce programme remplace tous les caractères après le dernier "p" par des espaces, puis effectue une itération sur chaque caractère de la chaîne résultante. Si le caractère est le suivant dans la séquence 'roygbp', imprimez 'n', sinon indiquez '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

J'ai eu du mal à trouver un moyen plus rapide de traiter la chaîne d'entrée. _>_zJen particulier se sent maladroit, mais <Jzne donne pas la chaîne requise quand J == 0, c'est-à-dire quand l'entrée se termine par un 'p'.

Haskell, 138 octets

g le fait

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 octets

La règle "le collier doit se terminer par un violet" était à l’origine un grand obstacle, faisant passer mon score de 66 à 125, mais j’ai trouvé un moyen plus rapide de le surmonter (heureusement!).

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

Explication:

Ce code parcourt chaque caractère de l'entrée et les remplace par rou eavec cette logique:

• Si la position du personnage est <= la dernière position de p, ET si le personnage est le suivant dans l'arc-en-ciel, conservez-le (remplacez-le par n).
• Sinon, mangez-le (remplacez-le par e).

Ungolfed:

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

Suggestions bienvenues!

Python 2, 254 octets

Boucles!

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

Excusez le jeu de mots. : P