Supponiamo che tu stia mettendo insieme un filo di Froot Loops per una collana, un braccialetto, un laccio o qualsiasi altra cosa. Ci sono 6 colori ciclo: r ed, o gamma, y ellow, g reen, b lue, e p urple. Vuoi che il tuo filo inizi con il rosso all'estrema sinistra e cicla nell'ordine dell'arcobaleno andando a destra, finendo con il viola. Cioè, vuoi farlo in modo che il tuo filo possa essere rappresentato dalla stringa roygbpripetuta un numero di volte (possibilmente 0).

Il problema è che hai già messo i loop e non in un ordine particolare. Quali cicli dovresti mangiare e non mangiare in modo da poter massimizzare il numero di cicli arcobaleno corretti che vanno da sinistra a destra, con il primo ciclo rosso e l'ultimo ciclo viola?

Scrivi un programma o una funzione che accetta una stringa arbitraria di caratteri roygbpe stampa o restituisce una stringa della stessa lunghezza con eal posto dei cappi da mangiare e nal posto dei cappi da non mangiare.

Ad esempio, se il tuo filo Froot Loop sembrava

l'input sarebbe

gorboypbgbopyroybbbogppbporyoygbpr

e andando da sinistra a destra possiamo trovare 3 roygbpsequenze arcobaleno complete , ma alcuni dei loop devono essere divorati. Quindi l'output sarebbe

eenenneennenennneeeeneennenennnnne

risultante in un perfetto filamento a 3 cicli:

Se non ci sono cicli arcobaleno completi nell'input, allora l'output sarebbe tutto ee il filo finisce senza loop. ad es. l'ingresso proygbha emesso eeeeee. Al contrario, proygbpha un output ennnnnn.

Puoi presumere che tutti i fili di input abbiano almeno un loop.

Vince il codice più breve in byte.

Pyth, 31 byte

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

Incredibilmente inefficiente, spiegazione in arrivo.

yUlzgenera tutti i possibili sottoinsiemi di tutti i possibili indici di z(input) in ordine. Ad esempio, se l'input è abc:

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

Quindi hf!trova il primo Tnell'elenco sopra tale che :jk.DzT"roygbp"kè falso. .Dprende una stringa e un elenco di indici ed elimina gli elementi in quegli indici. Così .D"abcd",1 3è "ac". Dal momento che .Drestituisce un elenco (che non dovrebbe essere il caso, risolverà nelle versioni future di Pyth), io uso jk( kè "") per unirlo nuovamente in una stringa. La :_"roygbp"kparte sostituisce ogni istanza di un ciclo con la stringa vuota.

Poiché la stringa vuota è falsa, i paragrafi precedenti spiegano come trovo il più piccolo insieme di indici necessari per mangiare per ottenere una stringa composta solo da cicli.

:*lz\n_\epoi gira quella lista di indici in una nnnneeennenestringa.

Esagonia , 920 722 271 byte

Sei diversi tipi di anelli di frutta, dici? Questo è ciò per cui Hexagony è stato creato .

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

Ok, non lo era. Oddio, cosa ho fatto a me stesso ...

Questo codice ora è un esagono di lunghezza laterale 10 (iniziato a 19). Probabilmente potrebbe essere golfato ancora un po ', forse anche alla taglia 9, ma penso che il mio lavoro sia svolto qui ... Per riferimento, ci sono 175 comandi effettivi nella fonte, molti dei quali sono mirror potenzialmente inutili (o sono stati aggiunti per annullare fuori un comando da un percorso di attraversamento).

Nonostante l'apparente linearità, il codice è in realtà bidimensionale: Hexagony lo riorganizzerà in un esagono regolare (che è anche un codice valido, ma tutto lo spazio bianco è facoltativo in Hexagony). Ecco il codice spiegato in tutte le sue ... beh, non voglio dire "bellezza":

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

Spiegazione

Non proverò nemmeno a iniziare a spiegare tutti i percorsi di esecuzione contorti in questa versione golfata, ma l'algoritmo e il flusso di controllo complessivo sono identici a questa versione non golfata che potrebbe essere più facile da studiare per i davvero curiosi dopo aver spiegato l'algoritmo:

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

Onestamente, nel primo paragrafo stavo solo scherzando a metà. Il fatto che abbiamo a che fare con un ciclo di sei elementi è stato di grande aiuto. Il modello di memoria di Hexagony è una griglia esagonale infinita in cui ogni bordo della griglia contiene un intero con segno di precisione arbitraria, inizializzato su zero.

Ecco un diagramma del layout della memoria che ho usato in questo programma:

Il bit lungo rettilineo a sinistra viene utilizzato come stringa con terminazione 0 adi dimensione arbitraria associata alla lettera r . Le linee tratteggiate sulle altre lettere rappresentano lo stesso tipo di struttura, ognuna ruotata di 60 gradi. Inizialmente, il puntatore della memoria punta sul bordo etichettato 1 , rivolto a nord.

Il primo bit lineare del codice imposta la "stella" interna dei bordi sulle lettere roygbpe imposta il bordo iniziale su 1, in modo tale che sappiamo dove finisce / inizia il ciclo (tra pe r):

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

Dopo questo, siamo di nuovo sul bordo con l'etichetta 1 .

Ora l'idea generale dell'algoritmo è questa:

1. Per ogni lettera nel ciclo, continua a leggere le lettere da STDIN e, se sono diverse dalla lettera corrente, aggiungile alla stringa associata a quella lettera.
2. Quando leggiamo la lettera che stiamo attualmente cercando, ne memorizziamo una esul bordo con l'etichetta ? , perché finché il ciclo non è completo, dobbiamo presumere che dovremo mangiare anche questo personaggio. Successivamente, ci sposteremo sul ring per il personaggio successivo nel ciclo.
3. Esistono due modi in cui questo processo può essere interrotto:
   • O abbiamo completato il ciclo. In questo caso, facciamo un altro giro veloce attraverso il ciclo, sostituendo tutte quelle es nel ? bordi con ns, perché ora vogliamo che quel ciclo rimanga sulla collana. Quindi passiamo al codice di stampa.
   • Oppure colpiamo EOF (che riconosciamo come un codice carattere negativo). In questo caso, scriviamo un valore negativo nel ? bordo del personaggio attuale (in modo che possiamo facilmente distinguerlo da entrambi ee n). Quindi cerchiamo il bordo 1 (per saltare il resto di un ciclo potenzialmente incompleto) prima di passare anche al codice di stampa.
4. Il codice di stampa attraversa nuovamente il ciclo: per ogni carattere del ciclo cancella la stringa memorizzata mentre stampa un eper ogni carattere. Quindi passa al ? bordo associato al personaggio. Se è negativo, terminiamo semplicemente il programma. Se è positivo, lo stampiamo semplicemente e passiamo al personaggio successivo. Una volta completato il ciclo torniamo al passaggio 2.

Un'altra cosa che potrebbe essere interessante è il modo in cui ho implementato stringhe di dimensioni arbitrarie (perché è la prima volta che utilizzo la memoria illimitata in Hexagony).

Immagina di essere a un certo punto in cui stiamo ancora leggendo i caratteri per r (quindi possiamo usare il diagramma così com'è) e uno [0] e un 1 sono già stati riempiti di caratteri (tutto a nord-ovest di loro è ancora zero ). Ad esempio, forse abbiamo appena letto i primi due caratteri ogdell'input in quei bordi e ora stiamo leggendo a y.

Il nuovo personaggio viene letto nel bordo interno. Usiamo il ? bordo per verificare se questo personaggio è uguale a r. (C'è un trucco ingegnoso qui: l'esagonia può facilmente distinguere tra positivo e non positivo, quindi controllare l'uguaglianza tramite sottrazione è fastidioso e richiede almeno due rami. Ma tutte le lettere sono meno di un fattore 2 l'una dall'altra, quindi possiamo confrontare i valori prendendo il modulo, che darà zero solo se sono uguali.)

Perché yè diverso da r, spostiamo il bordo (senza etichetta) a sinistra di in e copiamo ylì. Ora ci spostiamo ulteriormente intorno all'esagono, copiando il personaggio un bordo ogni volta ulteriormente, fino a quando non abbiamo yil bordo sul lato opposto di dentro . Ma ora c'è già un personaggio in uno [0] che non vogliamo sovrascrivere. Invece, "trasciniamo" yattorno all'esagono successivo e controlliamo un 1 . Ma c'è anche un personaggio lì, quindi andiamo più avanti un altro esagono. Ora un [2] è ancora zero, quindi copiamo il fileydentro. Il puntatore della memoria ora si sposta indietro lungo la corda verso l'anello interno. Sappiamo quando abbiamo raggiunto l'inizio della stringa, perché i bordi (senza etichetta) tra a [i] sono tutti zero mentre ? è positivo.

Questa sarà probabilmente una tecnica utile per scrivere codice non banale in Hexagony in generale.

Esagonia , 169 byte

Sono stato ispirato dalla risposta di Martin Büttner (è anche il suo esolang) e ho deciso che posso farlo nella taglia 8. (Sono convinto che sia possibile anche nella taglia 7, ma è molto difficile. Ho già trascorso quattro giorni non -stop su questo.)

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

Disposto esagonalmente:

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

Il programma non utilizza effettivamente l' #istruzione, quindi ho usato quel carattere per mostrare quali celle non sono effettivamente utilizzate. Inoltre, ogni cella non operativa attraversata in una sola direzione è uno specchio (ad esempio _se attraversata in senso orizzontale), quindi tutti i .personaggi vengono attraversati in più di una direzione.

Spiegazione

All'inizio, eseguiamo la sequenza di istruzioni r''o{{y''g{{b''p"")". Questi sono sparsi un po 'a casaccio nel codice perché li ho inseriti dopo aver scritto tutto il resto. Uso ]per passare al puntatore dell'istruzione successiva alcune volte; in questo modo posso essenzialmente teletrasportarmi in un altro angolo dell'esagono. L'intero resto del programma viene eseguito dal puntatore istruzioni # 3.

La memoria ora appare come segue, con i bordi importanti etichettati con nomi che userò in questa spiegazione:

I bordi etichettati indicano quanto segue:

• in: Usiamo questo bordo per memorizzare un personaggio letto da STDIN.
• %: Usiamo questo bordo per eseguire un'operazione di modulo sul carattere letto da STDIN ( in) e il carattere di “valido” ( r, oecc), che sarà 0se sono uguali. Ho rubato questo trucco dalla risposta di Martin Büttner, ma il resto del programma è diverso.
• #: Fintanto che leggiamo caratteri "non validi" (ovvero i colori che dobbiamo mangiare), aumentiamo questo margine. Pertanto, questo margine ricorda quanti es abbiamo bisogno di produrre in seguito.
• r?: Sempre 0tranne dove si trova la parte r(rossa). Questo ci dice quando abbiamo completato un ciclo.

Il programma procede così:

• Continua a leggere i personaggi. Se non è il personaggio che stiamo cercando, incrementa #. In caso contrario, passare al segmento successivo della memoria in senso orario.
• Passando al segmento successivo, se r?è positivo, abbiamo fatto un'intera rivoluzione. Fare un giro completo e produrre # es e 1 nper segmento. Questo riporta ciascuno #a 0. ( eViene posizionato su un bordo senza etichetta, ma per nappropriazione indebita del #bordo, che in seguito impostiamo 0utilizzando una *(moltiplicazione), che funziona perché sappiamo che tutti i %bordi sono zero in questo momento.)
• Quando leggi un personaggio, se non è positivo (ad es. EOF), vai indietro nel cerchio e fai #+1 es finché non torni a dove r?è positivo, quindi esci.

Dopo una corsa completa, la memoria appare approssimativamente come segue alla fine. Noterai i bordi contenenti 101(il codice ASCII di e); uno dei inbordi è -1(EOF); tutti i #bordi sono a 0; e il puntatore della memoria termina sul r?bordo positivo .

Retina , 148 85 79 byte

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

[^n]
e

Puoi eseguirlo da un singolo file sorgente con il -sflag interprete.

Spiegazione

Prima di tutto togliamo le cose semplici:

$
#roygbp

Si aggiunge #roygbpalla fine della stringa, che useremo per calcolare dinamicamente il ciclo di lettere.

Il prossimo (lungo) passo determina quali anelli mantenere e li sostituisce n. Vedremo come funziona tra poco.

#.*
<empty>

Questo elimina il nostro aiutante di ricerca alla fine della stringa.

[^n]
e

Questo sostituisce tutti i caratteri che non sono stati sostituiti nel secondo passaggio con e, completando la trasformazione.

Ora torniamo al secondo passaggio.

La struttura di base utilizza un trucco, che ho scoperto alcuni mesi fa per sostituire i personaggi selezionati in una partita globale:

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

dove ...corrisponde a un modello arbitrariamente complesso. Questo corrisponde al personaggio da sostituire .e quindi avvia un lookbehind (che dovresti leggere da destra a sinistra). Il lookbehind cattura tutto fino al personaggio abbinato in un gruppo prefix. Quindi passa a uno sguardo al futuro , che ora inizia dall'inizio della stringa e può contenere un modello complesso. Dopo il personaggio che vogliamo sostituire in quello schema, mettiamo uno sguardo opzionale dietro , che controlla se il prefixgruppo corrisponde qui. In tal caso, acquisisce una stringa vuota nel fileflaggruppo. In caso contrario, poiché è facoltativo, non influisce affatto sullo stato del motore regex e viene ignorato. Infine, una volta che il lookahead è stato abbinato correttamente, rimane solo la \k<flag>fine che corrisponde solo se il flag è stato impostato in qualche punto durante il calcolo.

Ora ungolf un po 'il regex lungo usando gruppi nominati e modalità freespacing:

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

Spero che riconoscerai il profilo generale dall'alto, quindi dobbiamo solo guardare a ciò che ho compilato ....

Vogliamo catturare il personaggio successivo nel ciclo nel gruppo char. Lo facciamo ricordando anche la stringa dal #carattere corrente in cycle. Per ottenere il prossimo personaggio, usiamo un lookahead per cercare #. Ora proviamo ad abbinare cyclee quindi abbinare il personaggio successivo in char. Questo sarà di solito possibile, a meno che non charsia l'ultimo personaggio p. In questo caso, \k<cycle>corrisponderà all'intero resto della stringa e non ci sarà più un personaggio da catturare char. Quindi il motore esegue il backtracking, omette il backreference cyclee corrisponde solo al primo carattere r.

Ora abbiamo il prossimo personaggio nel ciclo char, cerchiamo la prossima occorrenza possibile di quel personaggio con .*?\k<char>. Questi sono i personaggi che vogliamo sostituire, quindi eseguiamo il prefixcontrollo. Questi passaggi (trova il prossimo charnel ciclo, cerca la prossima occorrenza di esso, imposta il flag se appropriato) ora sono semplicemente ripetuti con a +.

Questo è in realtà tutto ciò che serve per trovare la sottosequenza ciclica, ma dobbiamo anche assicurarci di finire con un p. Questo è abbastanza semplice: basta controllare che il valore attualmente memorizzato charcorrisponda pa alla fine della stringa con .*\k<char>$. Ciò garantisce anche che la nostra stringa di ricerca non venga utilizzata per completare un ciclo incompleto, poiché pper questo controllo è necessario il trailing .

Python 2, 133 130 126 121 byte

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

Il primo ciclo ottiene cicli e il secondo rimuove un ciclo incompleto

Salvato 3 byte grazie a JF e 5 da DLosc

Perl 5, 76 65 byte

Un pizzico di espressioni regolari pure non diluite.
In primo luogo trova ciò che non dovrebbe essere mangiato. Ciò che rimane è commestibile.

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

Test

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

Lua, 101 byte

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

Usa i modelli Lua in modo creativo; Penso che sia un approccio interessante.

Sostituisce tutti i caratteri non consumati con "*", sostituisce tutti i caratteri alfanumerici con "e", quindi sostituisce tutti "*" con "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 testato in Firefox. Ho sentito che Chrome supporta le funzioni freccia ora, ma non l'ho ancora testato su 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

Crea il modello di ricerca "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"e la sostituzione "\\1n\\2n\\3n\\4n\\5n\\6n". Dopo quella sostituzione dichiara tutto il cibo ("e"), che non fa parte di un arcobaleno completo.

Questa combinazione assicura automaticamente che durante questa operazione non vengano danneggiati gli arcobaleni e che alla fine non si presentino arcobaleni recisi.

Pyth, 42 byte

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

Provalo online: dimostrazione

CJam, 41 byte

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

Approccio a forza bruta che prova tutte le variazioni di mangia / non mangia e seleziona quello che risulta nella collana più lunga e valida.

Provalo online nell'interprete CJam .

CJam, 50 byte

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

Provalo online

Questo è un po 'più lungo di alcuni degli altri contributi, ma è molto efficiente con complessità lineare. Esegue la scansione della stringa di input e abbina i caratteri uno alla volta.

La parte centrale dell'algoritmo è in realtà abbastanza compatta. Circa la metà del codice serve per rimuovere il ciclo incompleto alla fine.

C90, 142-146 byte (fino a 119, a seconda)

Funziona in tempo lineare per mangiare in modo efficiente quei loop di frutta che non possono far parte di un grazioso arcobaleno. Quindi, un postprocess uccide qualsiasi loop parziale alla fine.

Ecco quattro versioni:

• Versione 1 (146 byte), chiamare 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);}

• Versione 2 (142 byte), chiama 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);}
  Questo ti consente di definire il tuo ordine arcobaleno con tutti i colori che desideri finché non lo sono no e. Questo in realtà rende il codice più breve!

• Versione 3 (123 byte), chiama come la versione 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);}
  questa ti dà più arcobaleno possibile! Gli arcobaleni finali incompleti mostrano una promessa! Non dovremmo mangiarli!

• Versione 4 (119 byte), chiama come la versione 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);}
  uguale alla versione 3, ma MOAR RAINBOW TYPES!

Limitazione minore: la macchina deve avere caratteri firmati (il caso generale) e la stringa deve essere piuttosto corta. Emette un finale \nper maggiore chiarezza.

La versione 1 è l'unica che soddisfa chiaramente i requisiti, sebbene la versione 2 sia discutibile. Le versioni 3 e 4 sono interpretazioni meno corrette (ma comunque divertenti) della domanda.

Pyth, 38 byte

So che questo è significativamente più lungo della risposta di orlp, ma questo funziona in tempo lineare: o)

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

Provalo qui .

In breve, questo programma sostituisce tutti i caratteri dopo la 'p' finale con spazi, quindi scorre ogni carattere della stringa risultante. Se il personaggio è il prossimo nella sequenza 'roygbp', stampa 'n', altrimenti stampa '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

Ho faticato a trovare un modo più breve per elaborare la stringa di input. _>_zJin particolare sembra imbarazzante, ma <Jznon fornisce la stringa richiesta quando J == 0, cioè quando l'input termina con una 'p'.

Haskell, 138 byte

g lo fa.

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 byte

La regola "la collana deve finire in un viola" era originariamente un grande ostacolo, aumentando il mio punteggio da 66 a 125, ma ho trovato un modo più breve su di esso (per fortuna!).

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

Spiegazione:

Questo codice scorre attraverso ogni carattere nell'input e sostituisce ciascuno con ro econ questa logica:

• Se la posizione del personaggio è <= l'ultima posizione di p, E il personaggio è il prossimo nell'arcobaleno, tienilo (sostituiscilo con n).
• Altrimenti, mangiarlo (sostituirlo con 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;
}

Suggerimenti benvenuti!

Python 2, 254 byte

Loops!

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

Scusa il gioco di parole. : P