Bir kolye, bilezik, ayakkabı bağı ya da her neyse, Froot Loops teli kullandığınızı varsayalım . 6 çevrim renk vardır: r ed O aralığında, y ellow, g reen, b lue ve p urple. İplikinizin en solda kırmızı ile başlamasını ve sağda olacak şekilde gökkuşağı düzeninde dönerek mor ile bitmesini istiyorsunuz. Diğer bir deyişle, iplikçikinizin roygbpbirkaç kez tekrarlanan dizeyle gösterilebilmesi için bunu yapmak istiyorsunuz (muhtemelen 0).

Sorun şu ki, döngülerinizi çoktan gerdirdiniz ve belirli bir sırada değil. İlk döngü kırmızı ve son döngü mor ile, soldan sağa doğru giden doğru gökkuşağı döngüsü sayısını en üst düzeye çıkarmak için hangi döngüleri yemelisiniz ve yememelisiniz?

Karakterlerin rastgele roygbpbir dizgisini alan ve aynı uzunlukta bir dizgiyi e, yenilecek ilmeklerin yer aldığı ve yememek için ilmeklerin yerine basan veya döndüren bir program veya işlev yazın n.

Örneğin, Froot Loop sarmalınız benziyorsa

giriş olurdu

gorboypbgbopyroybbbogppbporyoygbpr

ve soldan sağa doğru 3 tam roygbpgökkuşağı dizisi bulabiliriz , ancak bazı ilmeklerin yenilmesi gerekir. Böylece çıktı

eenenneennenennneeeeneennenennnnne

Mükemmel bir 3 çevrim teli elde edilir:

eGirdide tam bir gökkuşağı döngüsü yoksa, çıktı her şey olur ve iplikçik döngüsüz olarak sona erer. örneğin girişin proygbçıkışı vardır eeeeee. Tersine, proygbpçıktı var ennnnnn.

Tüm giriş tellerinin en az bir döngüye sahip olduğunu varsayabilirsiniz.

Bayt cinsinden en kısa kod kazanır.

Pyth, 31 bayt

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

İnanılmaz derecede verimsiz, açıklama çok yakında.

yUlzz(giriş) olası tüm endekslerinin olası tüm altkümelerini sırayla oluşturur. Örneğin eğer giriş abc:

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

Daha sonra yukarıdaki listede hf!birinci olanı yanlış bulur . bir dize ve dizin listesi alır ve bu dizinlerdeki öğeleri siler. Yani bir . Yana getiri listesi, ben kullanım (durum olmamalıdır, Pyth gelecekteki sürümlerinde çözecektir) ( olduğu ) birlikte tekrar bir dizeye katılmak. Bölüm boş dize ile bir döngüsünün her örneğini değiştirir.T:jk.DzT"roygbp"k.D.D"abcd",1 3"ac".Djkk"":_"roygbp"k

Boş dize yanlış olduğundan, yukarıdaki paragraflar yalnızca çevrimlerden oluşan bir dize elde etmek için yemek için gereken en küçük indeks kümesini nasıl bulduğumu açıklar.

:*lz\n_\edaha sonra bu dizin listesini bir nnnneeennenedizeye dönüştürür .

Altıgen , 920 722 271 bayt

Altı farklı tipte meyve halkaları dedin mi? Yani Hexagony buydu yapılmış için.

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

Tamam değildi. Tanrım, kendime ne yaptım?

Bu kod şimdi yan uzunluğu 10 olan altıgen şeklindedir (19'da başladı). Muhtemelen biraz daha golf oynayabilirdi, belki 9 bedene bile olabilir, ama sanırım işim burada bitti. geçiş yolundan bir komut çıkar).

Görünen doğrusallığa rağmen, kod aslında iki boyutludur: Hexagony normal bir altıgene yeniden düzenleyecektir (aynı zamanda geçerli koddur, ancak tüm boşluklar Hexagony'de isteğe bağlıdır). İşte tüm içindeki katlanmamış kod ... peki "güzellik" demek istemiyorum:

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

açıklama

Bu golf versiyonundaki tüm kıvrımlı çalıştırma yollarını açıklamaya bile çalışmayacağım, ancak algoritma ve genel kontrol akışı algoritmayı açıkladıktan sonra gerçekten meraklı için çalışmayı kolaylaştırabilen bu sürümsüz sürümle aynıdır:

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

Dürüst olmak gerekirse, ilk paragrafta sadece yarı şaka yapıyordum. Altı element döngüsüyle uğraştığımız gerçeği aslında çok yardımcı oldu. Hexagony'in bellek modeli, gridin her bir kenarının sıfıra başlatılmış, işaretli bir isteğe bağlı tamsayı içerdiği sonsuz bir altıgen ızgaradır.

Bu programda kullandığım hafızanın yerleşim şemasını aşağıda bulabilirsiniz:

Soldaki uzun düz bit, ra harfi ile ilişkilendirilmiş, 0 sonlu bir isteğe bağlı boyut dizisi olarak kullanılır . Diğer harfler üzerindeki kesik çizgiler, her biri 60 derece döndürülen aynı yapı tipini temsil eder. Başlangıçta, bellek işaretçisi kuzeye bakan 1 etiketli kenarı işaret eder .

Kodun ilk, doğrusal biti, kenarların iç "yıldızını" harflerin roygbpyanı sıra, başlangıç ​​kenarını da ayarlayarak 1, döngünün nerede bittiğini / başladığını ( pve arasında r) bildiğimiz şekilde ayarlar :

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

Bundan sonra, 1 olarak etiketlenen kenara döndük .

Şimdi algoritmanın genel fikri şudur:

1. Döngüdeki her harf için, STDIN'den gelen harfleri okumaya devam edin ve geçerli harflerden farklıysa, bunları o harfle ilişkilendirilen dizeye ekleyin.
2. Şu anda aradığımız mektubu okuduğumuzda, eetiketli bir kenarda saklıyoruz . Çünkü döngü tamamlanmadığı sürece, bu karakteri de yemek zorunda kalacağımızı varsaymalıyız. Daha sonra, halkanın etrafında dönerek bir sonraki karaktere geçeceğiz.
3. Bu işlemin yarıda kesilmesinin iki yolu vardır:
   • Ya biz de döngüyü tamamladık. Bu durumda, biz tüm bu yerine döngüsü boyunca başka hızlı tur yapmak eiçinde s ? ns ile kenarları , çünkü şimdi bu döngünün kolyede kalmasını istiyoruz. Sonra baskı koduna geçiyoruz.
   • Veya EOF'ye (negatif karakter kodu olarak tanıdığımız) çarptık. Bu durumda, negatif bir değer yazıyoruz ? mevcut karakter kenarı (bu nedenle kolay hem de ayırt olabilir eve n). Ardından , baskı koduna geçmeden önce 1 kenarı (potansiyel olarak tamamlanmamış bir döngünün kalanını atlamak için) ararız.
4. Yazdırma kodu tekrar döngüden geçer: döngüdeki her karakter için, her karakter için bir sayı yazdırırken depolanan dizgiyi siler e. Sonra o taşır ? karakterle ilişkilendirilmiş kenar. Olumsuzsa, programı sonlandırırız. Olumluysa, basitçe yazdırır ve bir sonraki karaktere geçeriz. Döngüyü tamamladığımızda 2. adıma geri döneriz.

İlginç olabilecek başka bir şey, isteğe bağlı boyutta dizeleri nasıl uyguladığımdır (çünkü Hexagony'de sınırsız belleği ilk kez kullanıyorum).

Biz hala karakterleri okuyorsanız bir noktada olduğunu hayal r (olduğu gibi biz diyagramı kullanabilmesi) ve bir [0] ve bir 1 zaten bunların her şey kuzey batısında hala sıfırdır (karakterlerle doldurulmuş ). Örneğin og, girişin ilk iki karakterini bu kenarlara okuduk ve şimdi a y.

Yeni bir karakter haline okunur içinde kenarına. Kullanıyoruz mu? Kenar bu karakter eşit olup olmadığını kontrol etmek için r. (Burada çok güzel bir numara var: Altıgen sadece pozitif ve pozitif olmayanları kolayca ayırt edebilir, bu yüzden eşitliği çıkarma yoluyla kontrol etmek can sıkıcıdır ve en az iki dal gerektirir. değerleri, sadece eşit olduklarında sıfıra verecek olan modulo alarak karşılaştırabiliriz.)

Çünkü yfarklıdır r, biz sol (işaretsiz) ile kenar hareket içinde ve kopyalama yorada. Elimizdeki kadar biz şimdi, daha da her zaman karakter bir kenara kopyalama, altıgen etrafında daha fazla hareket ykenarı karşısındaki üzerinde de . Ama şimdi [0] da zaten üzerine yazmak istemediğimiz bir karakter var . Bunun yerine, "sürükleme" yve bir sonraki altıgen etrafında kontrol bir 1 . Ama orada da bir karakter var, bu yüzden başka bir altıgen çizeriz. Şimdi bir [2] hala sıfır, bu yüzden kopyalarızybunun içine. Bellek işaretçisi şimdi tel boyunca geriye doğru iç halkaya doğru hareket eder. Arasında (etiketsiz) kenarları, çünkü biz dize başlangıcını ulaştınız zaman bilmek [i] a oysa tüm sıfırdır ? olumlu.

Bu muhtemelen Hexagony'de genel olarak önemsiz olmayan bir kod yazmak için faydalı bir teknik olacaktır.

Altıgen , 169 bayt

Martin Büttner'ın cevabından ilham aldım (onun da esolang'sı) ve 8 bedeninde yapabileceğime karar verdim (7 boyutunda da mümkün olabileceğine ikna oldum, ama çok zor. Zaten dört gün geçirdim -Bunu kes.)

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

Altıgen olarak yerleştirilmiş:

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

Program aslında #talimatı kullanmıyor, bu yüzden hangi hücrelerin kullanılmadığını göstermek için bu karakteri kullandım. Ayrıca, sadece bir yönde hareket eden her bir op olmayan hücre bir aynadır (örneğin _, yatay olarak çapraz yerleştirilmişse), böylece tüm .karakterlerin birden fazla yönde geçtiğini biliyorsunuzdur .

açıklama

Başlangıçta, talimat dizisini uygularız r''o{{y''g{{b''p"")". Bunlar kod boyunca biraz şaşırıp kalmış çünkü diğer her şeyi yazdıktan sonra onları sıkıştırdım. Bir ]sonraki komut göstericisine birkaç kez geçmek için kullanıyorum ; bu şekilde, esasen altıgenin başka bir köşesine ışınlanabiliyorum. Programın geri kalanının tamamı talimat işaretçisi # 3 ile gerçekleştirilir.

Hafıza şimdi bu açıklamada kullanacağım isimlerle işaretlenmiş önemli kenarlarla birlikte şu şekilde görünüyor:

Etiketli kenarlar aşağıdakileri ifade eder:

• in: Bu kenarı STDIN'den okuduğumuz bir karakteri saklamak için kullanıyoruz.
• %: Biz STDIN'den okunan karakteri üzerinde bir modül işlemi (gerçekleştirmek için bu kenar kullanmak in) ve akım “geçerli” karakter ( r, oolacak, vs.), 0eşit iseler. Bu numarayı Martin Büttner'ın cevabından çaldım, ancak programın geri kalanı farklı.
• #: “Geçersiz” karakterleri okuduğumuz sürece (yani, yememiz gereken renkler), bu kenarı arttırırız. Bu nedenle, bu kenar edaha sonra ne kadar çıktı vermemiz gerektiğini hatırlar .
• r?: Her zaman (kırmızı) kısmın 0nerede olduğu hariç r. Bu bize bir işlemi ne zaman tamamladığımızı söyler.

Program böylece devam eder:

• Karakterleri okumaya devam et. Şu anda aradığımız karakter değilse, artış #. Aksi halde, saatin sırasıyla sırasıyla bir sonraki hafızasına gidin.
• Bir sonraki bölüme geçerken, eğer r?pozitifse, tam bir devrim yaptık. Tam bir tur ve çıkış # es ve nsegment başına 1 yapın . Bu her birini #geri ayarlar 0. ( eBir etiketsiz kenarına yerleştirilen, ancak için nbiz misappropriate #biz ayarlı kenarı, 0bir kullanarak *bunu hepimiz biliyoruz, çünkü çalışır sonradan) (çarpma, %kenarları şu anda sıfır değildir.)
• Bir karakteri okurken, pozitif değilse (yani, EOF), dairenin içinden geriye doğru gidin ve pozitif olana geri dönene kadar #+1 es r?çıkın, sonra çıkın.

Tam bir çalışmadan sonra, bellek sonunda yaklaşık olarak aşağıdaki gibi görünür. İçerdiği kenarları göreceksiniz 101(ASCII kodu e); biri inkenarları olan -1(EOF); tüm #kenarlar 0'dadır; ve hafıza işaretçisi pozitif r?kenarda sona ermektedir .

Retina , 148 85 79 bayt

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

[^n]
e

-sTercüman bayrağı ile tek bir kaynak dosyadan bunu çalıştırabilirsiniz .

açıklama

İlk önce basit şeyleri çıkaralım:

$
#roygbp

#roygbpHarflerin döngüsünü dinamik olarak hesaplamak için kullanacağımız dizgenin sonuna eklenir .

Bir sonraki (uzun) adım, hangi halkaların tutulacaklarını ve yerini alacaklarını belirler n. Bunun nasıl çalıştığını biraz inceleyeceğiz.

#.*
<empty>

Bu, ipin sonundaki arama yardımcımızdan kurtulur.

[^n]
e

Bu, ikinci adımda değiştirilmemiş tüm karakterleri değiştirerek edönüşümü tamamlar.

Şimdi ikinci adıma geri dönelim.

Temel yapı, birkaç ay önce keşfettiğim bir numarayı, global bir maçta seçilen karakterleri değiştirmek için kullanır :

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

burada ...karmaşık olan rasgele bir desene karşılık gelir. Bu, değiştirilecek karakterle eşleşir .ve ardından bir sağdan sola okumanız gereken bir aramaya başlar. Lookbehind, eşleşen karaktere kadar her şeyi bir grup halinde yakalar prefix. Sonra , dizenin başından itibaren başlayan ve karmaşık bir desen içerebilen ileriye doğru bir görünüme geçer . Bu düzende değiştirmek istediğimiz karakterden sonra , grubun burada eşleşip eşleşmediğini kontrol eden isteğe bağlı bir arkasına koyuyoruz prefix. Varsa, içine boş bir dize yakalar.flaggrubudur. Olmazsa, isteğe bağlı olduğu için, regex motorunun durumunu hiçbir şekilde etkilemez ve göz ardı edilir. Son olarak, bakış açısı başarılı bir şekilde eşleştirildikten sonra, yalnızca \k<flag>bayrak hesaplama sırasında bir noktaya ayarlanmışsa eşleşen sonunda kalır.

Şimdi uzun regex'i biraz adlandırılmış gruplar ve serbest bırakma modunu kullanarak çözelim:

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

Umarım genel taslağı yukarıdan tanırsınız, bu yüzden sadece doldurduğum şeye bakmamız yeterli ....

Döngüdeki bir sonraki karakteri gruba çekmek istiyoruz char. Bunu ayrıca dizgeyi #içindeki karakterden hatırlayarak da yapıyoruz cycle. Bir sonraki karakteri almak için, aramak için bir bakış açısı kullanırız #. Şimdi eşleştirmeye cycleve ardından bir sonraki karakteri eşleştirmeye çalışırız char. Bu char, son karakter olmadığı sürece , genellikle mümkün olacaktır p. Bu durumda, \k<cycle>dizginin kalanının tamamı ile eşleşecek ve yakalanacak bir karakter kalmayacaktır char. Böylece motor geriye doğru hareket eder, geri tepmeyi ihmal eder ve bunun yerine cycleilk karaktere karşılık gelir r.

Şimdi, döngüdeki bir sonraki karaktere charsahibiz, o karakterin bir sonraki olası oluşumunu ararız .*?\k<char>. Bunlar değiştirmek istediğimiz karakterler, bu yüzden prefixçeki ondan sonra koyarız . Bu adımlar (bir sonraki charçevrimi bulun, bir sonraki oluşumunu arayın, uygunsa bayrağı ayarlayın) şimdi a ile tekrarlanır +.

Aslında döngüsel alt diziyi bulmak için hepsi bu kadar, ama aynı zamanda sonunu yaptığımızdan da emin olmalıyız p. Bu oldukça kolaydır: sadece o anda depolanan değerin dizenin sonundaki ile chareşleştiğini kontrol etmeniz yeterlidir . Bu ayrıca arama dizgimizin eksik bir çevrimi bitirmek için kullanılmamasını sağlar, çünkü bu kontrol için izlememiz gerekir .p.*\k<char>$p

Python 2, 133 130 126 121 bayt

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

İlk döngü çevrimleri alır, ikincisi eksik çevrimi kaldırır

JF ve DLosc'tan 5 sayesinde 3 bayt kaydedildi

Perl 5, 76 65 bayt

Bir tutam saf seyreltilmemiş düzenli ifadeler.
İlk önce ne yenmemesi gerektiğini bulur. Kalan ne yenebilir.

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

Ölçek

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

Lua, 101 bayt

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

Lua desenlerini yaratıcı bir şekilde kullanır; Bence ilginç bir yaklaşım.

Yenilmeyen tüm karakterleri "*" s ile değiştirir, tüm alfanümerik karakterleri "e" s ile değiştirir, sonra "*" s ile "n" s değiştirir.

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'ta test edildi. Chrome'un şimdi ok işlevlerini desteklediğini duyuyorum ancak bunu henüz Chrome'da test etmedim.

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

Arama düzenini "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"ve değişimini kurar "\\1n\\2n\\3n\\4n\\5n\\6n". Bu değişimden sonra her şeyi yiyecek ("e") ilan eder, bu tam bir gökkuşağının parçası değildir.

Bu kombinasyon otomatik olarak, bu işlem sırasında hiçbir gökkuşağının zarar görmemesini ve sonunda kopmuş gökkuşağının ortaya çıkmamasını sağlar.

Pyth, 42 bayt

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

Çevrimiçi deneyin: Gösteri

CJam, 41 bayt

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

Her şeyi yiyip yemediğiniz varyasyonları deneyen kaba kuvvet yaklaşımı ve en uzun, geçerli kolye ile sonuçlanan birini seçer.

CJam tercümanında çevrimiçi olarak deneyin .

CJam, 50 bayt

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

Çevrimiçi deneyin

Bu, diğer sunumların bazılarından biraz daha uzun, ancak doğrusal karmaşıklıkla çok verimli. Giriş dizgisini tarar ve karakterleri birer birer eşleştirir.

Algoritmanın çekirdek kısmı aslında oldukça küçüktür. Kodun yaklaşık yarısı, sonunda tamamlanmamış çevrimi kaldırmak içindir.

C90, 142-146 bayt (bağlı olarak, 119'a kadar)

Güzel bir gökkuşağının parçası olamayan meyve halkalarını verimli bir şekilde yemek için lineer zamanda çalışır. Ardından, bir postprocess sonunda herhangi bir kısmi döngüyü öldürür.

İşte dört versiyon:

• Sürüm 1 (146 bayt), şununla [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);}

• Sürüm 2 (142 bayt), şununla arayın [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);}
  Bu, kendi gökkuşağı siparişinizi istediğiniz renkte nveya istediğiniz sürece tanımlamanıza olanak tanır e. Bu aslında kodu kısaltır!

• Sürüm 3 (123 byte), sürüm 1 gibi çağrı yapın:
  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);}
  Bu, size mümkün olan en fazla gökkuşağı sağlar Tamamlanmamış izleyen gökkuşağı söz veriyor! Onları yememeliyiz!

• Sürüm 4 (119 bayt), sürüm 2 gibi çağrı:
  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);}
  Sürüm 3 ile aynı, ancak MOAR RAINBOW TYPES!

Küçük sınırlamalar: Makine işaretli karakterleri (genel durum) işaretlemeli ve string oldukça kısa olmalıdır. \nNetlik için bir iz çıkarır.

Sürüm 1 tartışılabilir olmasına rağmen, açıkça gereksinimleri geçen tek versiyondur. 3. ve 4. sürümler sorunun daha az doğru olmasına rağmen (yine de eğlencelidir).

Pyth, 38 bayt

Bunun orlp'in cevabından önemli ölçüde daha uzun olduğunu biliyorum, ancak bu doğrusal zamanda çalışıyor: o)

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

Burada dene .

Kısaca, bu program son 'p' sonrasındaki tüm karakterleri boşluklarla değiştirir, ardından sonuçtaki dizgede her karakter üzerinde yinelenir. Karakter, 'roygbp' sekansındaki sıradaki ise, 'n' yaz, aksi takdirde 'e' yaz.

                                          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

Giriş dizesini işlemek için daha kısa bir yol bulmakta zorlandım. _>_zJözellikle garip hissettirir, ancak girdi bir 'p' ile bittiğinde <Jzgerekli dizgiyi vermez J == 0.

Haskell, 138 bayt

g yapar.

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 bayt

"Kolye morla bitmeli" kuralı aslen büyük bir engeldi, puanımı 66'dan 125'e çıkardım, ama bunun üzerinde daha kısa bir yol buldum (Neyse ki!).

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

Açıklama:

Bu kod girişteki her karakter arasında dolaşır ve her birini bu mantıkla rveya eile değiştirir :

• Karakterin konumu <= son konumu ise pVE, karakterin gökkuşağı içindeki sıradaki karakteri ise, onu sakla (ile değiştir n).
• Aksi takdirde, yiyin (ile değiştirin 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;
}

Önerilerinizi bekliyoruz!

Python 2,254 bayt

Döngüler!

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

Afedersiniz pardon. : P