Припустимо, ви нанизуєте пасмо Froot Loops для намиста, браслета, шнурка або іншого. Є 6 кольорів циклу: r ed, o range, y ellow, g reen, b lue і 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

Неймовірно неефективне, скоро пояснення.

yUlzгенерує всі можливі підмножини всіх можливих індексів z(введення) у порядку. Наприклад, якщо вхід abc:

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

Потім hf!знаходить першим Tу наведеному списку таке, що :jk.DzT"roygbp"kє помилковим. .Dприймає рядок і список індексів і видаляє елементи цих індексів. Так і .D"abcd",1 3є "ac". Оскільки .Dповернення списку (що не повинно бути виправданим у наступних версіях Pyth), я використовую jk( kє ""), щоб з'єднати його разом у рядок. :_"roygbp"kЧастина замінює кожен екземпляр циклу з нового рядка.

Оскільки порожній рядок помилковий, наведені вище пункти пояснюють, як я знаходжу найменший набір індексів, необхідних для поїдання, щоб отримати рядок, що складається лише з циклів.

:*lz\n_\eпотім перетворює цей список індексів у nnnneeenneneрядок.

Гексагонія , 920 722 271 байт

Скажете, шість різних типів фруктових петель? Саме для цього був створений Гексагоній.

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

Гаразд, не було. О боже, що я зробив собі ...

Цей код тепер є шестикутником довжини сторони 10 (він почався в 19). Можливо, це може бути гольф ще трохи, можливо, навіть до розміру 9, але я думаю, моя робота тут виконана ... Для довідки, у джерелі є 175 фактичних команд, багато з яких є потенційно непотрібними дзеркалами (або додані для скасування команда з шляху перетину).

Незважаючи на очевидну лінійність, код насправді є двовимірним: шестикутник переставить його в звичайний шестикутник (що також є дійсним кодом, але пробіл у шестикутнику необов’язковий). Ось розгорнутий код у всіх його ... ну я не хочу сказати "краса":

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

Пояснення

Я навіть не спробую розпочати пояснення всіх контузних шляхів виконання у цій версії для гольфу, але алгоритм та загальний потік управління ідентичні цій версії, що не використовується для гольфу, що може бути легше вивчити для справді цікавих після того, як я пояснив алгоритм:

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

Чесно кажучи, у першому пункті я лише наполовину жартував. Те, що ми маємо справу з циклом із шести елементів, насправді була великою підмогою. Модель пам'яті шестикутника - це нескінченна шестикутна сітка, де кожен край сітки містить підписане ціле число довільної точності, ініційоване на нуль.

Ось схема компонування пам'яті, яку я використовував у цій програмі:

Довгий прямий біт ліворуч використовується як 0-кінцевий рядок aдовільного розміру, який асоціюється з літерою r . Штрихові лінії на інших літерах являють собою такий же тип будови, кожен з яких повертається на 60 градусів. Спочатку вказівник пам'яті вказує на край, позначений 1 , звернений на північ.

Перший лінійний біт коду задає внутрішню "зірку" ребер буквам roygbp, а також встановлення початкового краю 1таким чином, щоб ми знали, де цикл закінчується / починається (між pі r):

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

Після цього ми знову на краю, позначеному 1 .

Тепер загальна ідея алгоритму така:

1. Для кожної літери циклу читайте букви STDIN і, якщо вони відрізняються від поточної літери, додайте їх до рядка, пов'язаного з цією буквою.
2. Коли ми читаємо лист, який ми шукаємо в даний час, ми зберігаємо eкраєчку з написом ? , оскільки поки цикл не завершений, ми повинні припустити, що нам доведеться з'їсти і цього персонажа. Після цього ми перейдемо навколо рингу до наступного символу циклу.
3. Існує два способи перервати цей процес:
   • Або ми закінчили цикл. У цьому випадку ми робимо ще один швидкий обхід циклу, замінюючи всі ці es у ? країв з ns, тому що зараз ми хочемо, щоб цей цикл залишився на намисті. Потім переходимо до друку коду.
   • Або ми потрапляємо на EOF (який ми визнаємо як негативний код символів). У цьому випадку ми записуємо від'ємне значення у ? край поточного символу (щоб ми могли легко його відрізнити від обох eі n). Потім ми шукаємо 1 край (щоб пропустити залишок потенційно неповного циклу), перш ніж перейти до друку коду.
4. Код друку знову проходить цикл: для кожного символу циклу він очищає збережений рядок, друкуючи а eдля кожного символу. Потім він переходить до ? край, пов'язаний з персонажем. Якщо це негативно, ми просто припиняємо програму. Якщо він позитивний, ми просто роздруковуємо його та переходимо до наступного символу. Після завершення циклу ми повертаємось до кроку 2.

Інша річ, яка може бути цікавою, - це те, як я реалізував рядки довільного розміру (тому що це перший раз, коли я використовував необмежену пам’ять у Hexagony).

Уявіть собі , що ми в якому - то момент , коли ми по- , як і раніше читаємо символи для г (так що ми можемо використовувати схему як є) і а [0] і 1 вже заповнені з персонажами (всі північний захід від них по - , як і раніше дорівнює нулю ). Наприклад, ми щойно прочитали перші два символи введення в ці краї і зараз читаємо .ogy

Новий персонаж зачитується в край. Ми використовуємо ? краю, щоб перевірити, чи дорівнює цей символ r. (Тут є чудовий трюк: Гексагонія може легко розрізнити лише позитивне та непозитивне, тому перевірка рівності за допомогою віднімання дратує і вимагає принаймні двох гілок. Але всі літери менше ніж коефіцієнт 2 один від одного, тож ми можемо порівняти значення, взявши модуль, який дасть нуль лише у тому випадку, якщо вони рівні.)

Тому що yвідрізняються від r, ми переміщаємо (немаркований) край зліва від в і скопіювати yтуди. Тепер ми рухаємося далі навколо шестикутника, копіювання символів один краю додатково кожен раз, поки ми не маємо yна край протилежної в . Але тепер у [0] вже є символ, який ми не хочемо переписувати. Замість цього ми «тягати» yнавколо наступного шестикутника і перевірити з 1 . Але там є і характер, тому ми вирушаємо ще один шестикутник далі. Тепер [2] все ще дорівнює нулю, тому ми копіюємоyв це. Покажчик пам’яті тепер рухається назад по рядку до внутрішнього кільця. Ми знаємо, коли ми дійшли до початку рядка, тому що (без маркування) ребра між [i] всі нульові, тоді як ? є позитивним.

Це, мабуть, буде корисною технікою для написання нетривіального коду в гексагонії взагалі.

Шестикутник , 169 байт

Мене надихнула відповідь Мартіна Бюттнера (це теж його езоланг) і вирішила, що я можу це зробити в розмірі 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.
• %Ми використовуємо цей край , щоб виконати операцію по модулю на характер читання з STDIN ( in) і поточний «правильний» характер ( r, oі т.д.), який буде , 0якщо вони рівні. Я вкрав цю хитрість з відповіді Мартіна Бюттнера, але решта програми інша.
• #: Поки ми читаємо "недійсні" символи (тобто кольори, які нам потрібно їсти), ми збільшуємо цей край. Таким чином, цей край запам'ятовує, скільки eс нам потрібно вивести пізніше.
• r?: Завжди, 0за винятком випадків, коли r(червона) частина. Це говорить нам, коли ми закінчили цикл.

Програма діє таким чином:

• Продовжуйте читати символів. Якщо це не той персонаж, якого ми зараз шукаємо, приріст #. В іншому випадку перейдіть до наступного сегмента пам'яті за годинниковою стрілкою.
• Переходячи до наступного сегменту, якщо r?це позитивно, ми зробили цілу революцію. Складіть повний раунд і виведіть # es і 1 nна сегмент. Це встановлює кожен #назад 0. (The 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групи. Якщо це не так, тому що це необов’язково, він взагалі не впливає на стан двигуна регулярних виразів і ігнорується. Нарешті, після того, як lookahead вдало узгоджується, залишається лише той \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 +.

Це насправді все, що є для того, щоб знайти циклічну послідовність, але нам також потрібно переконатися, що ми закінчилися на a 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

Перший цикл отримує цикли, а другий видаляє незавершений цикл

Збережено 3 байти завдяки JF та 5 від DLosc

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

Луа, 101 байт

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

Творчо використовує шаблони Lua; Я думаю, що це цікавий підхід.

Він замінює всі не з'їдені символи на "*" s, замінює всі буквено-цифрові символи на "e" s, а потім замінює всі "*" s на "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 перевірена у 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". Після цього заміни він оголошує все, що є їжею ("е"), це не є частиною повної веселки.

Ця комбінація автоматично гарантує, що під час цієї операції не буде пошкоджено жодна веселка, а в кінці не з’явиться відірвана веселка.

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