Misalkan Anda merangkai untaian Froot Loops untuk kalung, gelang, tali sepatu, atau apa pun. Ada 6 warna lingkaran: r ed, o range, y ellow, g reen, b lue, dan p urple. Anda ingin untai Anda mulai dengan warna merah di bagian paling kiri dan siklus dalam urutan pelangi ke kanan, berakhir dengan warna ungu. Artinya, Anda ingin membuatnya sehingga untai Anda dapat diwakili oleh string yang roygbpdiulang beberapa kali (mungkin 0).

Masalahnya adalah, Anda sudah menggantungkan loop Anda, dan tidak dalam urutan tertentu. Loop mana yang harus Anda makan dan tidak makan sehingga Anda dapat memaksimalkan jumlah siklus pelangi yang benar dari kiri ke kanan, dengan loop merah pertama dan loop ungu terakhir?

Tulis program atau fungsi yang mengambil string karakter acak roygbpdan mencetak atau mengembalikan string dengan panjang yang sama dengan edi tempat loop untuk makan dan ndi tempat loop untuk tidak makan.

Misalnya, jika untai Froot Loop Anda terlihat seperti

inputnya akan

gorboypbgbopyroybbbogppbporyoygbpr

dan dari kiri ke kanan kita dapat menemukan 3 roygbpurutan pelangi lengkap , tetapi beberapa loop perlu dimakan. Dengan demikian hasilnya akan

eenenneennenennneeeeneennenennnnne

menghasilkan untai 3 siklus sempurna:

Jika tidak ada siklus pelangi lengkap dalam input maka output akan menjadi semua edan untai berakhir tanpa loop. misalnya input proygbmemiliki output eeeeee. Sebaliknya, proygbpmemiliki output ennnnnn.

Anda dapat mengasumsikan semua untai input memiliki setidaknya satu loop.

Kode terpendek dalam byte menang.

Pyth, 31 byte

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

Sangat tidak efisien, penjelasan segera hadir.

yUlzmenghasilkan semua himpunan bagian yang mungkin dari semua indeks yang mungkin z(input) secara berurutan. Misal jika inputnya adalah abc:

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

Kemudian hf!temukan yang pertama Tdalam daftar di atas sedemikian rupa sehingga :jk.DzT"roygbp"ksalah. .Dmengambil string dan daftar indeks, dan menghapus elemen pada indeks tersebut. Begitu .D"abcd",1 3juga "ac". Karena .Dmengembalikan daftar (yang seharusnya tidak terjadi, akan diperbaiki dalam versi Pyth yang akan datang), saya menggunakan jk( kis "") untuk bergabung bersama kembali ke sebuah string. Bagian ini :_"roygbp"kmenggantikan setiap instance dari siklus dengan string kosong.

Karena string kosong itu salah, paragraf di atas menjelaskan bagaimana saya menemukan kumpulan indeks terkecil yang diperlukan untuk dimakan untuk mendapatkan string yang hanya terdiri dari siklus.

:*lz\n_\ekemudian mengubah daftar indeks menjadi nnnneeennenestring.

Hexagony , 920 722 271 byte

Enam jenis buah loop, menurut Anda? Untuk itulah Hexagony dibuat .

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

Oke, tidak. Ya Tuhan, apa yang saya lakukan pada diri saya sendiri ...

Kode ini sekarang merupakan segi enam dengan panjang sisi 10 (dimulai pada 19). Mungkin bisa di-golf lagi, mungkin bahkan sampai ukuran 9, tapi saya pikir pekerjaan saya selesai di sini ... Untuk referensi, ada 175 perintah aktual di sumbernya, banyak di antaranya berpotensi mirror yang tidak perlu (atau ditambahkan untuk membatalkan perintah dari persimpangan jalan).

Terlepas dari linearitas yang tampak, kode ini sebenarnya dua dimensi: Hexagony akan mengatur ulang menjadi segi enam reguler (yang juga merupakan kode yang valid, tetapi semua spasi putih adalah opsional dalam Hexagony). Berikut adalah kode yang tidak dilipat dalam semua ... yah saya tidak ingin mengatakan "cantik":

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

Penjelasan

Saya bahkan tidak akan mencoba dan mulai menjelaskan semua jalur eksekusi yang berbelit-belit dalam versi golf ini, tetapi algoritme dan alur kontrol keseluruhannya identik dengan versi yang tidak diklik ini yang mungkin lebih mudah dipelajari untuk orang yang benar-benar penasaran setelah saya menjelaskan algoritme:

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

Jujur saja, di paragraf pertama aku hanya setengah bercanda. Fakta bahwa kita sedang berurusan dengan siklus enam elemen sebenarnya sangat membantu. Model memori Hexagony adalah kisi heksagonal tak terbatas di mana setiap tepi kisi berisi integer presisi sewenang-wenang yang ditandatangani, diinisialisasi ke nol.

Berikut adalah diagram tata letak memori yang saya gunakan dalam program ini:

Bit lurus panjang di sebelah kiri digunakan sebagai string diakhiri 0 dengan aukuran sewenang-wenang yang dikaitkan dengan huruf r . Garis putus-putus pada huruf-huruf lain mewakili jenis struktur yang sama, masing-masing diputar 60 derajat. Awalnya, penunjuk memori menunjuk pada tepi berlabel 1 , menghadap ke utara.

Bit linier pertama dari kode mengatur "bintang" tepi pada huruf-huruf roygbpserta mengatur tepi awal 1, sehingga kita tahu di mana siklus berakhir / dimulai (antara pdan r):

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

Setelah ini, kita kembali ke tepi berlabel 1 .

Sekarang ide umum dari algoritma ini adalah ini:

1. Untuk setiap huruf dalam siklus, terus membaca surat dari STDIN dan, jika berbeda dari surat saat ini, tambahkan ke string yang terkait dengan surat itu.
2. Ketika kita membaca surat yang sedang kita cari, kita menyimpan huruf etepi yang berlabel ? , karena selama siklus tidak lengkap, kita harus mengasumsikan bahwa kita harus memakan karakter ini juga. Setelah itu, kami akan bergerak di sekitar cincin ke karakter berikutnya dalam siklus.
3. Ada dua cara proses ini dapat terganggu:
   • Entah kita sudah menyelesaikan siklus. Dalam hal ini, kami melakukan putaran cepat melalui siklus, menggantikan semua yang ada edalam ? tepi dengan ns, karena sekarang kami ingin siklus yang tetap pada kalung itu. Kemudian kita beralih ke kode pencetakan.
   • Atau kami menekan EOF (yang kami kenali sebagai kode karakter negatif). Dalam hal ini, kami menulis nilai negatif ke dalam ? tepi karakter saat ini (sehingga kita dapat dengan mudah membedakannya dari keduanya edan n). Kemudian kami mencari tepi 1 (untuk melewati sisa siklus yang berpotensi tidak lengkap) sebelum pindah ke kode pencetakan juga.
4. Kode pencetakan melewati siklus lagi: untuk setiap karakter dalam siklus itu membersihkan string yang disimpan saat mencetak euntuk setiap karakter. Lalu pindah ke ? edge terkait dengan karakter. Jika negatif, kami cukup menghentikan program. Jika positif, kami cukup mencetaknya dan beralih ke karakter berikutnya. Setelah kami menyelesaikan siklus, kami kembali ke langkah 2.

Hal lain yang mungkin menarik adalah bagaimana saya menerapkan string ukuran sewenang-wenang (karena ini adalah pertama kalinya saya menggunakan memori tidak terbatas dalam Hexagony).

Bayangkan kami di beberapa titik di mana kita masih membaca karakter untuk r (sehingga kita dapat menggunakan diagram seperti) dan sebuah [0] dan sebuah 1 telah diisi dengan karakter (segala sesuatu utara-barat dari mereka masih nol ). Misalnya mungkin kita baru saja membaca dua karakter pertama ogdari input ke tepi itu dan sekarang sedang membaca a y.

Karakter baru dibaca ke dalam tepi. Kami menggunakan ? edge untuk memeriksa apakah karakter ini sama dengan r. (Ada trik yang bagus di sini: Hexagony hanya dapat membedakan antara positif dan non-positif dengan mudah, jadi memeriksa kesetaraan melalui pengurangan itu menjengkelkan dan membutuhkan setidaknya dua cabang. Tetapi semua huruf kurang dari faktor 2 dari satu sama lain, jadi kita dapat membandingkan nilai dengan mengambil modulo, yang hanya akan memberikan nol jika sama.)

Karena yberbeda dari r, kami memindahkan (unlabelled) tepi kiri di dan salin ysana. Kita sekarang bergerak lebih jauh di sekitar segi enam, menyalin karakter salah satu ujung lanjut setiap kali, sampai kami memiliki ydi seberang tepi di . Tapi sekarang sudah ada karakter dalam [0] yang tidak ingin kita timpa. Sebaliknya, kita "drag" yang ysekitar segi enam berikutnya dan memeriksa sebuah 1 . Tapi ada karakter di sana juga, jadi kita pergi segi enam lebih jauh. Sekarang [2] masih nol, jadi kami salinyke dalamnya. Penunjuk memori sekarang bergerak kembali di sepanjang tali menuju cincin bagian dalam. Kita tahu kapan kita telah mencapai awal string, karena tepi (tidak berlabel) antara a [i] semuanya nol sedangkan ? positif.

Ini mungkin akan menjadi teknik yang berguna untuk menulis kode non-sepele dalam Hexagony secara umum.

Hexagony , 169 byte

Saya terinspirasi oleh jawaban Martin Büttner (ini esolang-nya juga) dan memutuskan saya bisa melakukannya dalam ukuran 8. (Saya yakin itu mungkin juga dalam ukuran 7, tetapi sangat sulit. Saya sudah menghabiskan empat hari tanpa -Hentikan ini.)

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

Ditata secara heksagon:

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

Program tidak benar-benar menggunakan #instruksi, jadi saya telah menggunakan karakter itu untuk menunjukkan sel mana yang sebenarnya tidak digunakan. Selain itu, setiap sel no-op yang dilalui hanya dalam satu arah adalah cermin (misalnya _jika dilintasi secara horizontal), sehingga Anda tahu semua .karakter dilintasi lebih dari satu arah.

Penjelasan

Pada awalnya, kami menjalankan urutan instruksi r''o{{y''g{{b''p"")". Ini berserakan sedikit sembarangan di kode karena saya meremasnya setelah saya menulis segalanya. Saya menggunakan ]untuk beralih ke penunjuk instruksi berikutnya beberapa kali; dengan cara ini saya pada dasarnya bisa teleport ke sudut lain segi enam. Seluruh program dijalankan oleh penunjuk instruksi # 3.

Memori sekarang terlihat sebagai berikut, dengan ujung-ujung penting yang berlabel nama yang akan saya gunakan dalam penjelasan ini:

Tepi berlabel berarti sebagai berikut:

• in: Kami menggunakan tepi ini untuk menyimpan karakter yang kita baca dari STDIN.
• %: Kami menggunakan tepi ini untuk melakukan operasi modulo pada karakter dibaca dari STDIN ( in) dan saat ini karakter “valid” ( r, o, dll), yang akan 0jika mereka sama. Saya mencuri trik ini dari jawaban Martin Büttner, tetapi program lainnya berbeda.
• #: Selama kita membaca karakter "tidak valid" (yaitu warna yang perlu kita makan), kita menambah keunggulan ini. Jadi, edge ini mengingat berapa banyak yang eperlu kita hasilkan nanti.
• r?: Selalu 0kecuali di mana bagian r(merah) berada. Ini memberitahu kita ketika kita telah menyelesaikan suatu siklus.

Program ini menghasilkan sebagai berikut:

• Terus membaca karakter. Jika bukan karakter yang saat ini kita cari, increment #. Jika tidak, pindah ke segmen memori berikutnya dalam urutan searah jarum jam.
• Ketika pindah ke segmen berikutnya, jika r?positif, kami telah membuat seluruh revolusi. Buat putaran lengkap dan hasilkan # es dan 1 nper segmen. Ini mengatur masing-masing #kembali ke 0. ( eLetaknya ditempatkan pada tepi yang tidak berlabel, tetapi untuk nkami menyalahgunakan #ujungnya, yang kami atur 0menggunakan *(perkalian) setelahnya, yang berfungsi karena kami tahu bahwa semua %tepinya nol pada saat ini.)
• Saat membaca karakter, jika tidak positif (yaitu, EOF), mundurlah ke lingkaran dan beri #+1 ehingga Anda kembali ke tempat r?yang positif, lalu keluar.

Setelah selesai berjalan, memori terlihat kira-kira sebagai berikut di akhir. Anda akan melihat tepi berisi 101(kode ASCII e); salah satu inujungnya adalah -1(EOF); semua #tepi berada pada 0; dan penunjuk memori berakhir di r?tepi positif .

Retina , 148 85 79 byte

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

[^n]
e

Anda dapat menjalankan ini dari file sumber tunggal dengan -sbendera juru bahasa.

Penjelasan

Mari kita dapatkan hal-hal sederhana terlebih dahulu:

$
#roygbp

Tambahkan #roygbpke akhir string, yang akan kita gunakan untuk menghitung siklus huruf secara dinamis.

Langkah (panjang) berikutnya mencari tahu loop mana yang harus disimpan dan menggantikannya n. Kami akan melihat bagaimana ini bekerja sedikit.

#.*
<empty>

Ini menghilangkan helper pencarian kami di akhir string.

[^n]
e

Ini menggantikan semua karakter yang tidak diganti pada langkah kedua dengan e, menyelesaikan transformasi.

Sekarang mari kita kembali ke langkah kedua.

Struktur dasar menggunakan trik, yang saya temukan beberapa bulan lalu untuk mengganti karakter yang dipilih dalam pertandingan global:

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

di mana ...sesuai dengan pola kompleks yang sewenang-wenang. Ini cocok dengan karakter yang akan diganti .dan kemudian mulai melihat ke belakang (yang harus Anda baca dari kanan ke kiri). Tampilan di balik menangkap semuanya hingga karakter yang cocok ke dalam grup prefix. Kemudian beralih ke tampilan depan , yang sekarang dimulai dari awal string dan dapat berisi pola yang kompleks. Setelah karakter yang ingin kami ganti dalam pola itu, kami menempatkan tampilan opsional di belakang , yang memeriksa apakah prefixgrup cocok di sini. Jika ya, itu menangkap string kosong ke dalamflagkelompok. Jika tidak, karena itu opsional, itu tidak mempengaruhi keadaan mesin regex sama sekali dan diabaikan. Akhirnya, setelah lookahead berhasil dicocokkan, hanya \k<flag>bagian ujung yang tersisa yang hanya cocok jika bendera ditetapkan pada beberapa titik selama perhitungan.

Sekarang mari ungolf regex panjang sedikit dengan menggunakan kelompok bernama dan mode freespacing:

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

Saya harap Anda mengenali garis besar umum dari atas, jadi kita hanya perlu melihat apa yang saya isi ....

Kami ingin menangkap karakter berikutnya dalam siklus ke grup char. Kami melakukan ini dengan juga mengingat string dari #ke karakter saat ini di cycle. Untuk mendapatkan karakter berikutnya, kami menggunakan lookahead untuk mencari #. Sekarang kami mencoba untuk mencocokkan cycledan kemudian mencocokkan karakter berikutnya di char. Ini biasanya dimungkinkan, kecuali charkarakter terakhir p. Dalam hal ini, \k<cycle>akan cocok dengan seluruh sisa string dan tidak akan ada karakter yang tersisa untuk ditangkap char. Jadi backtracks engine, menghilangkan referensi-balik ke cycledan hanya cocok dengan karakter pertama rsebagai gantinya.

Sekarang kita memiliki karakter berikutnya dalam siklus char, kita mencari kemungkinan kemunculan berikutnya dari karakter itu .*?\k<char>. Ini adalah karakter yang ingin kami ganti, jadi kami beri tanda prefixcentang setelahnya. Langkah-langkah ini (temukan yang berikutnya chardalam siklus, cari kejadian selanjutnya, tetapkan flag jika sesuai) sekarang cukup diulangi dengan a +.

Itulah sebenarnya yang ada untuk menemukan urutan siklik, tetapi kita juga perlu memastikan bahwa kita berakhir pada a p. Ini cukup mudah: cukup periksa bahwa nilai yang saat ini disimpan dalam charcocok dengan pdi akhir string .*\k<char>$. Ini juga memastikan bahwa string pencarian kami tidak digunakan untuk menyelesaikan siklus yang tidak lengkap, karena kami memerlukan trailing puntuk pemeriksaan ini.

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

Loop pertama mendapat siklus, dan yang kedua menghapus siklus yang tidak lengkap

Disimpan 3 byte berkat JF dan 5 dari DLosc

Perl 5, 76 65 byte

Sejumput ekspresi reguler murni murni.
Pertama menemukan apa yang tidak boleh dimakan. Apa yang tersisa bisa dimakan.

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

Uji

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

Menggunakan pola Lua secara kreatif; Saya pikir ini pendekatan yang menarik.

Ia mengganti semua karakter yang tidak dimakan dengan "*", menggantikan semua karakter alfanumerik dengan "e", lalu mengganti semua "*" dengan "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``")

Biola diuji di Firefox. Saya mendengar Chrome mendukung fungsi panah sekarang, tetapi saya belum mengujinya di Chrome.

Tidak Disatukan:

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``
")

melongo, 96

{for(;c=substr("roygbp",++i,1);r=r"\\"i"n")p=p"([^"c"]*)"c;$0=gensub(p,r,"g");gsub(/[^n]/,"e")}1

Membangun pola pencarian "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"dan penggantian "\\1n\\2n\\3n\\4n\\5n\\6n". Setelah penggantian itu menyatakan semua makanan ("e"), itu bukan bagian dari pelangi lengkap.

Kombinasi ini secara otomatis memastikan, bahwa tidak ada pelangi akan dirugikan selama operasi ini, dan tidak ada pelangi yang terputus muncul di akhir.

Pyth, 42 byte

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

Cobalah online: Demonstrasi

CJam, 41 byte

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

Pendekatan brute-force yang mencoba semua variasi makan / tidak makan dan memilih salah satu yang menghasilkan kalung terpanjang dan valid.

Cobalah online di juru bahasa CJam .

CJam, 50 byte

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

Cobalah online

Ini sedikit lebih lama dari beberapa kiriman lainnya, tetapi sangat efisien dengan kompleksitas linier. Memindai melalui string input, dan mencocokkan karakter satu per satu.

Bagian inti dari algoritma ini sebenarnya cukup kompak. Sekitar setengah dari kode adalah untuk menghapus siklus tidak lengkap di akhir.

C90, 142-146 byte (hingga 119, tergantung)

Beroperasi dalam waktu linier untuk memakan loop buah secara efisien yang tidak dapat menjadi bagian dari pelangi yang cantik. Kemudian, sebuah postprocess membunuh semua loop parsial di bagian akhir.

Berikut ini empat versi:

• Versi 1 (146 byte), panggilan dengan [name] [string]:
  main(int a,char**b){char*v=b[1],*s="roygbp",i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';while(k-->0)v[--i]='e';puts(v);}

• Versi 2 (142 byte), panggil dengan [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);}
  Ini memungkinkan Anda untuk menentukan pesanan pelangi Anda sendiri dengan warna apa pun yang Anda inginkan asalkan tidak natau tidak e. Ini sebenarnya membuat kode lebih pendek!

• Versi 3 (123 byte), sebut seperti versi 1: Yang
  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);}
  ini memberi Anda pelangi sebanyak mungkin! Pelangi trailing tidak lengkap menunjukkan janji! Kita seharusnya tidak memakannya!

• Versi 4 (119 byte), panggilan seperti versi 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);}
  Sama seperti versi 3, tetapi JENIS RAINBOW MOAR!

Batasan kecil: mesin harus memiliki karakter yang sudah ditandatangani (case umum), dan string harus cukup pendek. Menghasilkan jejak \nuntuk kejelasan.

Versi 1 adalah satu-satunya yang jelas melewati persyaratan, meskipun versi 2 dapat diperdebatkan. Versi 3 dan 4 adalah interpretasi pertanyaan yang kurang benar (tapi masih menyenangkan).

Pyth, 38 byte

Saya tahu ini jauh lebih lama dari jawaban orlp, tetapi yang ini berjalan dalam waktu linier: o)

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

Cobalah di sini .

Secara singkat, program ini menggantikan semua karakter setelah 'p' akhir dengan spasi, lalu beralih ke setiap karakter dalam string yang dihasilkan. Jika karakter adalah yang berikutnya dalam urutan 'roygbp', cetak 'n', jika tidak cetak '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

Saya kesulitan menemukan cara yang lebih singkat untuk memproses string input. _>_zJkhususnya terasa canggung, tetapi <Jztidak memberikan string yang diperlukan saat J == 0, yaitu ketika input berakhir dengan 'p'.

Haskell, 138 byte

g melakukannya.

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

Aturan "kalung harus diakhiri dengan ungu" pada awalnya merupakan rintangan besar, meningkatkan skor saya dari 66 menjadi 125, tetapi saya menemukan cara yang lebih singkat untuk itu (untungnya!).

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

Penjelasan:

Kode ini memotong setiap karakter dalam input dan menggantikan masing-masing dengan ratau edengan logika ini:

• Jika posisi karakter adalah <= posisi terakhir dari p, DAN karakter adalah yang berikutnya dalam pelangi, simpan (ganti dengan n).
• Kalau tidak, makanlah (ganti dengan e).

Tidak Disatukan:

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

Saran diterima!

Python 2, 254 byte

Loop!

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

Permisi permainan kata-kata. : P