Giả sử bạn đang xâu chuỗi một vòng Froot Loops cho vòng cổ, vòng tay, dây giày hoặc bất cứ thứ gì. Có 6 màu vòng lặp: r ed, o phạm vi, y ellow, g reen, b lue và p urple. Bạn muốn chuỗi của bạn bắt đầu với màu đỏ ở bên trái và chu kỳ theo thứ tự cầu vồng sẽ sang phải, kết thúc bằng màu tím. Đó là, bạn muốn làm cho nó để chuỗi của bạn có thể được biểu diễn bằng chuỗi roygbplặp đi lặp lại một số lần (có thể là 0).

Vấn đề là, bạn đã xâu chuỗi các vòng lặp của mình và không theo bất kỳ thứ tự cụ thể nào. Những vòng lặp nào bạn nên ăn và không ăn để bạn có thể tối đa hóa số chu kỳ cầu vồng chính xác đi từ trái sang phải, với vòng lặp đầu tiên màu đỏ và vòng lặp cuối cùng màu tím?

Viết chương trình hoặc hàm lấy một chuỗi ký tự tùy ý roygbpvà in hoặc trả về một chuỗi có cùng độ dài với evị trí các vòng lặp để ăn và nở vị trí các vòng không ăn.

Ví dụ: nếu chuỗi Froot Loop của bạn trông giống như

đầu vào sẽ là

gorboypbgbopyroybbbogppbporyoygbpr

và đi từ trái sang phải chúng ta có thể tìm thấy 3 roygbpchuỗi cầu vồng hoàn chỉnh , nhưng một số vòng lặp cần phải ăn đi. Do đó, đầu ra sẽ là

eenenneennenennneeeeneennenennnnne

dẫn đến một chuỗi 3 chu kỳ hoàn hảo:

Nếu không có chu kỳ cầu vồng hoàn chỉnh trong đầu vào thì đầu ra sẽ là tất cả evà chuỗi kết thúc không có vòng lặp. ví dụ đầu vào proygbcó đầu ra eeeeee. Ngược lại, proygbpcó đầu ra ennnnnn.

Bạn có thể giả sử tất cả các chuỗi đầu vào có ít nhất một vòng lặp.

Mã ngắn nhất tính bằng byte thắng.

Bình thường, 31 byte

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

Cực kỳ không hiệu quả, giải thích đến sớm.

yUlztạo ra tất cả các tập hợp con có thể của tất cả các chỉ số có thể có của z(đầu vào) theo thứ tự. Ví dụ: nếu đầu vào là abc:

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

Sau đó hf!tìm thấy đầu tiên Ttrong danh sách trên như vậy :jk.DzT"roygbp"klà sai. .Dlấy một chuỗi và danh sách các chỉ mục và xóa các phần tử tại các chỉ mục đó. Thế .D"abcd",1 3là xong "ac". Vì .Dtrả về một danh sách (không nên như vậy, sẽ sửa trong các phiên bản tương lai của Pyth), tôi sử dụng jk( kis "") để nối nó lại với nhau thành một chuỗi. Phần :_"roygbp"kthay thế mọi trường hợp của một chu kỳ bằng chuỗi rỗng.

Vì chuỗi rỗng là sai, các đoạn văn trên giải thích cách tôi tìm tập hợp các chỉ số nhỏ nhất cần ăn để có được chuỗi chỉ gồm các chu kỳ.

:*lz\n_\esau đó biến danh sách các chỉ số đó thành một nnnneeennenechuỗi.

Hexagony , 920 722 271 byte

Sáu loại vòng trái cây khác nhau, bạn nói gì? Đó là những gì Hexagony đã được thực hiện cho.

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

Được rồi, không phải vậy. Chúa ơi, tôi đã làm gì với chính mình ...

Mã này bây giờ là một hình lục giác có độ dài cạnh 10 (bắt đầu từ 19). Nó có thể có thể được đánh gôn nhiều hơn, thậm chí có thể tới cỡ 9, nhưng tôi nghĩ công việc của tôi đã được thực hiện ở đây ... Để tham khảo, có 175 lệnh thực tế trong nguồn, nhiều trong số đó là các gương không cần thiết (hoặc đã được thêm vào để hủy ra một lệnh từ một con đường cắt ngang).

Mặc dù tuyến tính rõ ràng, mã thực sự là hai chiều: Hexagony sẽ sắp xếp lại thành một hình lục giác thông thường (cũng là mã hợp lệ, nhưng tất cả các khoảng trắng là tùy chọn trong Hexagony). Đây là đoạn mã chưa được mở trong tất cả ... tôi không muốn nói "vẻ đẹp":

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

Giải trình

Tôi thậm chí sẽ không thử và bắt đầu giải thích tất cả các đường thực thi phức tạp trong phiên bản chơi gôn này, nhưng thuật toán và luồng điều khiển tổng thể giống hệt với phiên bản không được phép này có thể dễ nghiên cứu hơn cho người tò mò thực sự sau khi tôi giải thích thuật toán:

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

Thú thật, trong đoạn đầu tiên tôi chỉ nói đùa một nửa. Việc chúng ta xử lý một chu kỳ gồm sáu yếu tố thực sự là một sự trợ giúp tuyệt vời. Mô hình bộ nhớ của Hexagony là một lưới lục giác vô hạn trong đó mỗi cạnh của lưới chứa một số nguyên có độ chính xác tùy ý được ký, được khởi tạo về 0.

Dưới đây là sơ đồ bố trí bộ nhớ tôi đã sử dụng trong chương trình này:

Bit thẳng dài bên trái được sử dụng như một chuỗi 0 chấm dứt acó kích thước tùy ý được liên kết với chữ r . Các đường đứt nét trên các chữ cái khác đại diện cho cùng một loại cấu trúc, mỗi đường được xoay 60 độ. Ban đầu, con trỏ bộ nhớ trỏ vào cạnh có nhãn 1 , hướng về phía bắc.

Bit tuyến tính đầu tiên của mã đặt "ngôi sao" bên trong của các cạnh thành các chữ cái roygbpcũng như đặt cạnh ban đầu thành 1, để chúng ta biết nơi chu kỳ kết thúc / bắt đầu (giữa pvà r):

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

Sau này, chúng tôi trở lại trên cạnh có nhãn 1 .

Bây giờ ý tưởng chung của thuật toán là:

1. Đối với mỗi chữ cái trong chu trình, hãy tiếp tục đọc các chữ cái từ STDIN và, nếu chúng khác với chữ cái hiện tại, hãy thêm chúng vào chuỗi liên kết với chữ cái đó.
2. Khi chúng tôi đọc bức thư chúng tôi hiện đang tìm kiếm, chúng tôi có lưu trữ eở cạnh có nhãn không? , bởi vì miễn là chu trình chưa hoàn thành, chúng ta phải cho rằng chúng ta cũng sẽ phải ăn nhân vật này. Sau đó, chúng ta sẽ di chuyển vòng vòng đến nhân vật tiếp theo trong chu kỳ.
3. Có hai cách mà quá trình này có thể bị gián đoạn:
   • Hoặc là chúng tôi đã hoàn thành chu kỳ. Trong trường hợp này, chúng tôi thực hiện một vòng nhanh chóng khác trong chu kỳ, thay thế tất cả những người etrong ? cạnh với ns, bởi vì bây giờ chúng ta muốn chu kỳ đó vẫn còn trên vòng cổ. Sau đó, chúng tôi chuyển sang in mã.
   • Hoặc chúng tôi nhấn EOF (mà chúng tôi nhận ra là mã ký tự âm). Trong trường hợp này, chúng ta viết một giá trị âm vào ? cạnh của ký tự hiện tại (để chúng ta có thể dễ dàng phân biệt nó với cả hai evà n). Sau đó, chúng tôi tìm kiếm cạnh 1 (để bỏ qua phần còn lại của chu trình có khả năng chưa hoàn thành) trước khi chuyển sang in mã.
4. Mã in lại tiếp tục chu trình: đối với mỗi ký tự trong chu trình, nó sẽ xóa chuỗi được lưu trữ trong khi in một eký tự cho mỗi ký tự. Sau đó, nó di chuyển đến ? cạnh gắn liền với nhân vật. Nếu đó là tiêu cực, chúng tôi chỉ cần chấm dứt chương trình. Nếu nó tích cực, chúng tôi chỉ cần in nó và chuyển sang ký tự tiếp theo. Khi chúng tôi hoàn thành chu trình, chúng tôi quay lại bước 2.

Một điều thú vị khác là cách tôi triển khai các chuỗi có kích thước tùy ý (vì đây là lần đầu tiên tôi sử dụng bộ nhớ không giới hạn trong Hexagony).

Hãy tưởng tượng chúng ta đang ở một thời điểm nào mà chúng ta vẫn đang đọc ký tự cho r (vì vậy chúng tôi có thể sử dụng sơ đồ như là) và a [0] và một 1 đã được lấp đầy với các nhân vật (tất cả mọi thứ về phía tây bắc của họ vẫn là zero ). Ví dụ, có lẽ chúng ta vừa đọc hai ký tự đầu tiên ogcủa đầu vào vào các cạnh đó và hiện đang đọc a y.

Các nhân vật mới được đọc vào trong cạnh. Chúng tôi sử dụng ? cạnh để kiểm tra xem nhân vật này có bằng không r. (Có một mẹo nhỏ tiện lợi ở đây: Hexagony chỉ có thể dễ dàng phân biệt giữa tích cực và không tích cực, do đó, kiểm tra sự bình đẳng thông qua phép trừ là khó chịu và yêu cầu ít nhất hai nhánh. Nhưng tất cả các chữ cái đều nhỏ hơn 2 nhân tố với nhau, vì vậy chúng ta có thể so sánh các giá trị bằng cách lấy modulo, giá trị này sẽ chỉ bằng 0 nếu chúng bằng nhau.)

Bởi vì ykhác với r, chúng tôi di chuyển cạnh (không ghi nhãn) bên trái vào và sao chép yở đó. Bây giờ chúng ta di chuyển xa hơn xung quanh hình lục giác, sao chép nhân vật một cạnh hơn mỗi lần, cho đến khi chúng ta có ycạnh trên đối diện trong . Nhưng bây giờ đã có một ký tự trong [0] mà chúng ta không muốn ghi đè lên. Thay vào đó, chúng tôi "kéo" các yxung quanh hình lục giác tiếp theo và kiểm tra một 1 . Nhưng cũng có một nhân vật ở đó, vì vậy chúng tôi đi xa hơn một hình lục giác. Bây giờ [2] vẫn bằng không, vì vậy chúng tôi sao chépyvào nó Con trỏ bộ nhớ bây giờ di chuyển trở lại dọc theo chuỗi về phía vòng trong. Chúng tôi biết khi nào chúng tôi đạt đến điểm bắt đầu của chuỗi, bởi vì các cạnh (không ghi nhãn) giữa một [i] đều bằng không ? tích cực.

Đây có lẽ sẽ là một kỹ thuật hữu ích để viết mã không tầm thường trong Hexagony nói chung.

Lục giác , 169 byte

Tôi đã được truyền cảm hứng từ câu trả lời của Martin Büttner (cũng là esolang của anh ấy) và quyết định tôi có thể làm điều đó ở kích thước 8. (Tôi tin rằng nó cũng có thể ở kích thước 7, nhưng nó rất khó khăn. Tôi đã trải qua bốn ngày không - dừng lại ở đây.)

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

Đặt ra hình lục giác:

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

Chương trình không thực sự sử dụng #hướng dẫn, vì vậy tôi đã sử dụng ký tự đó để hiển thị các ô nào thực sự không được sử dụng. Hơn nữa, mọi ô không op được di chuyển theo một hướng là một gương (ví dụ: _nếu đi ngang theo chiều ngang), vì vậy bạn biết tất cả các .ký tự được di chuyển theo nhiều hướng.

Giải trình

Khi bắt đầu, chúng tôi thực hiện chuỗi các hướng dẫn r''o{{y''g{{b''p"")". Chúng được rải một chút ngớ ngẩn trên mã bởi vì tôi đã vắt chúng sau khi tôi viết mọi thứ khác. Tôi sử dụng ]để chuyển sang con trỏ lệnh tiếp theo một vài lần; bằng cách này, về cơ bản tôi có thể dịch chuyển đến một góc khác của hình lục giác. Toàn bộ phần còn lại của chương trình được thực hiện bởi con trỏ lệnh # 3.

Bộ nhớ bây giờ trông như sau, với các cạnh quan trọng được gắn nhãn tôi sẽ sử dụng trong phần giải thích này:

Các cạnh được dán nhãn có nghĩa như sau:

• in: Chúng tôi sử dụng cạnh này để lưu trữ một ký tự mà chúng tôi đọc từ STDIN.
• %: Chúng tôi sử dụng cạnh này để thực hiện một phép toán module trên nhân vật đọc từ STDIN ( in) và hiện nhân vật “hợp lệ” ( r, o, vv), mà sẽ được 0nếu chúng bằng nhau. Tôi đã đánh cắp thủ thuật này từ câu trả lời của Martin Büttner, nhưng phần còn lại của chương trình thì khác.
• #: Chừng nào chúng ta còn đọc các ký tự không hợp lệ của 195 (tức là màu chúng ta cần ăn), chúng ta sẽ tăng cạnh này. Do đó, cạnh này ghi nhớ echúng ta cần xuất bao nhiêu s sau này.
• r?: Luôn luôn 0ngoại trừ phần r(màu đỏ) là. Điều này cho chúng tôi biết khi chúng tôi hoàn thành một chu kỳ.

Chương trình tiến hành như vậy:

• Tiếp tục đọc nhân vật. Nếu đó không phải là nhân vật chúng tôi hiện đang tìm kiếm, hãy tăng dần #. Nếu không, di chuyển đến đoạn tiếp theo của bộ nhớ theo thứ tự chiều kim đồng hồ.
• Khi chuyển sang phân khúc tiếp theo, nếu r?tích cực, chúng tôi đã tạo nên một cuộc cách mạng. Tạo một vòng hoàn chỉnh và đầu ra # es và 1 ntrên mỗi đoạn. Điều này đặt từng #trở lại 0. (Các eđược đặt trên một cạnh không có nhãn, nhưng đối với nchúng tôi chiếm dụng các #cạnh, mà chúng tôi thiết lập để 0sử dụng một *(nhân) sau đó, mà làm việc bởi vì chúng ta biết rằng tất cả các %cạnh là zero vào lúc này.)
• Khi đọc một ký tự, nếu nó không tích cực (nghĩa là EOF), hãy quay ngược qua vòng tròn và xuất #+1 es cho đến khi bạn quay lại vị trí r?dương, sau đó thoát.

Sau khi chạy hoàn chỉnh, bộ nhớ trông xấp xỉ như sau ở cuối. Bạn sẽ nhận thấy các cạnh chứa 101(mã ASCII của e); một trong các incạnh là -1(EOF); tất cả các #cạnh đều ở 0; và con trỏ bộ nhớ kết thúc ở r?cạnh dương .

Võng mạc , 148 85 79 byte

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

[^n]
e

Bạn có thể chạy tệp này từ một tệp nguồn duy nhất với -scờ trình thông dịch.

Giải trình

Trước tiên, hãy lấy những thứ đơn giản ra khỏi đường đi:

$
#roygbp

Nối #roygbpvào cuối chuỗi, chúng ta sẽ sử dụng để tính toán chu kỳ của các chữ cái một cách linh hoạt.

Bước tiếp theo (dài) chỉ ra các vòng lặp để giữ và thay thế chúng bằng n. Chúng ta sẽ xem xét cách thức hoạt động của nó trong một chút.

#.*
<empty>

Điều này được loại bỏ người trợ giúp tra cứu của chúng tôi ở cuối chuỗi.

[^n]
e

Điều này thay thế tất cả các ký tự không được thay thế trong bước thứ hai bằng e, hoàn thành việc chuyển đổi.

Bây giờ chúng ta hãy quay lại bước thứ hai.

Cấu trúc cơ bản sử dụng một mẹo mà tôi đã phát hiện ra vài tháng trước để thay thế các nhân vật được chọn trong một trận đấu toàn cầu:

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

trong đó ...tương ứng với một mô hình phức tạp tùy ý. Điều này phù hợp với nhân vật được thay thế .và sau đó bắt đầu một cái nhìn (mà bạn nên đọc từ phải sang trái). Cái nhìn bắt được mọi thứ cho đến nhân vật phù hợp thành một nhóm prefix. Sau đó, nó chuyển sang một cái nhìn phía trước , bây giờ bắt đầu từ đầu chuỗi và có thể chứa một mẫu phức tạp. Sau ký tự mà chúng ta muốn thay thế trong mẫu đó, chúng ta đặt một cái nhìn tùy chọn phía sau , để kiểm tra xem prefixnhóm có khớp ở đây không. Nếu có, nó bắt một chuỗi rỗng vàoflagnhóm. Nếu không, vì nó là tùy chọn, nó hoàn toàn không ảnh hưởng đến trạng thái của công cụ regex và bị bỏ qua. Cuối cùng, một khi giao diện được khớp thành công, chỉ còn lại \k<flag>ở cuối chỉ phù hợp nếu cờ được đặt tại một số điểm trong quá trình tính toán.

Bây giờ, hãy để chế độ regex dài một chút bằng cách sử dụng các nhóm được đặt tên và chế độ tự do:

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

Tôi hy vọng bạn nhận ra các phác thảo chung từ phía trên, vì vậy chúng ta chỉ cần nhìn vào những gì tôi điền vào ....

Chúng tôi muốn bắt nhân vật tiếp theo trong chu kỳ vào nhóm char. Chúng tôi làm điều này bằng cách nhớ chuỗi ký tự từ #đến ký tự hiện tại cycle. Để có được nhân vật tiếp theo, chúng tôi sử dụng một cái nhìn để tìm kiếm #. Bây giờ chúng tôi cố gắng khớp cyclevà sau đó khớp với nhân vật tiếp theo char. Điều này thường sẽ có thể, trừ khi charlà nhân vật cuối cùng p. Trong trường hợp này, \k<cycle>sẽ khớp với toàn bộ phần còn lại của chuỗi và sẽ không có ký tự nào bị bắt char. Vì vậy, các backtracks động cơ, bỏ qua sự phản hồi cyclevà rthay vào đó chỉ phù hợp với ký tự đầu tiên .

Bây giờ chúng ta đã có nhân vật tiếp theo trong chu kỳ char, chúng ta tìm kiếm sự xuất hiện tiếp theo của nhân vật đó với .*?\k<char>. Đây là những ký tự chúng tôi muốn thay thế, vì vậy chúng tôi đặt prefixkiểm tra sau nó. Các bước này (tìm bước tiếp theo chartrong chu trình, tìm kiếm lần xuất hiện tiếp theo của nó, đặt cờ nếu thích hợp) giờ chỉ đơn giản được lặp lại với a +.

Đó thực sự là tất cả để tìm ra chu kỳ tuần hoàn, nhưng chúng ta cũng cần đảm bảo rằng chúng ta kết thúc vào một p. Điều này khá dễ dàng: chỉ cần kiểm tra xem giá trị hiện được lưu trữ có charkhớp pvới phần cuối của chuỗi không .*\k<char>$. Điều này cũng đảm bảo rằng chuỗi tra cứu của chúng tôi không được sử dụng để kết thúc một chu trình không hoàn chỉnh, bởi vì chúng tôi cần theo dõi pcho kiểm tra này.

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

Vòng lặp thứ nhất có chu kỳ và vòng thứ hai loại bỏ một chu trình không hoàn chỉnh

Đã lưu 3 byte nhờ JF và 5 từ DLosc

Perl 5, 76 65 byte

Một nhúm của các biểu thức chính quy nguyên chất không pha loãng.
Đầu tiên tìm thấy những gì không nên ăn. Những gì còn lại là ăn được.

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

Kiểm tra

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

Sử dụng mẫu Lua một cách sáng tạo; Tôi nghĩ đó là một cách tiếp cận thú vị.

Nó thay thế tất cả các ký tự không ăn bằng "*" s, thay thế tất cả các ký tự chữ và số bằng "e" s, sau đó thay thế tất cả "*" s bằng "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 đã thử nghiệm trong Firefox. Tôi nghe thấy Chrome hỗ trợ các chức năng mũi tên ngay bây giờ nhưng tôi chưa thử nghiệm điều này trong Chrome.

Ung dung:

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

chim ưng, 96

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

Xây dựng mô hình tìm kiếm "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"và thay thế "\\1n\\2n\\3n\\4n\\5n\\6n". Sau sự thay thế đó, nó tuyên bố mọi thứ thực phẩm ("e"), đó không phải là một phần của cầu vồng hoàn chỉnh.

Sự kết hợp này tự động đảm bảo, không có cầu vồng nào bị tổn hại trong quá trình hoạt động này và không có cầu vồng bị cắt đứt nào xuất hiện ở cuối.

Bình thường, 42 byte

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

Dùng thử trực tuyến: Trình diễn

CJam, 41 byte

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

Phương pháp tiếp cận Brute-force thử tất cả các biến thể ăn / không ăn và chọn một biến thể dẫn đến vòng cổ dài nhất, hợp lệ.

Hãy thử trực tuyến trong trình thông dịch CJam .

CJam, 50 byte

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

Dùng thử trực tuyến

Điều này dài hơn một chút so với một số bài nộp khác, nhưng nó rất hiệu quả với độ phức tạp tuyến tính. Nó quét qua chuỗi đầu vào và khớp từng ký tự một.

Phần cốt lõi của thuật toán thực sự khá nhỏ gọn. Khoảng một nửa mã là để loại bỏ chu trình không đầy đủ ở cuối.

C90, 142-146 byte (giảm xuống còn 119, tùy thuộc)

Hoạt động trong thời gian tuyến tính để ăn hiệu quả những vòng trái cây không thể là một phần của cầu vồng đẹp. Sau đó, một quá trình hậu kỳ giết chết bất kỳ vòng lặp một phần nào ở cuối.

Dưới đây là bốn phiên bản:

• Phiên bản 1 (146 byte), gọi với [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);}

• Phiên bản 2 (142 byte), gọi bằng [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);}
  Điều này cho phép bạn xác định thứ tự cầu vồng của riêng bạn với bất kỳ màu nào bạn muốn miễn là chúng không nhoặc e. Điều này thực sự làm cho mã ngắn hơn!

• Phiên bản 3 (123 byte), gọi như phiên bản 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);}
  Cái này cung cấp cho bạn càng nhiều cầu vồng của bạn càng tốt! Những cầu vồng không hoàn chỉnh cho thấy lời hứa! Chúng ta không nên ăn chúng!

• Phiên bản 4 (119 byte), gọi như phiên bản 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);}
  Tương tự như phiên bản 3, nhưng CÁC LOẠI RAINBOW MOAR!

Giới hạn nhỏ: máy phải có ký tự ký (trường hợp chung) và chuỗi phải khá ngắn. Xuất ra một dấu\n cho rõ ràng.

Phiên bản 1 là phiên bản duy nhất vượt qua các yêu cầu rõ ràng, mặc dù phiên bản 2 có thể tranh cãi. Phiên bản 3 và 4 là cách giải thích ít đúng (nhưng vẫn vui) cho câu hỏi.

Bình thường, 38 byte

Tôi biết điều này dài hơn đáng kể so với câu trả lời của orlp, nhưng câu hỏi này chạy trong thời gian tuyến tính: o)

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

Hãy thử nó ở đây .

Tóm lại, chương trình này thay thế tất cả các ký tự sau 'p' cuối cùng bằng khoảng trắng, sau đó lặp lại qua từng ký tự trong chuỗi kết quả. Nếu ký tự là ký tự tiếp theo trong chuỗi 'roygbp', hãy in 'n', nếu không thì in '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

Tôi đã vật lộn để tìm một cách ngắn hơn để xử lý chuỗi đầu vào. _>_zJđặc biệt cảm thấy lúng túng, nhưng <Jzkhông đưa ra chuỗi yêu cầu khi J == 0, tức là khi đầu vào kết thúc bằng 'p'.

Haskell, 138 byte

g Phải không.

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

Quy tắc "vòng cổ phải kết thúc bằng màu tím" ban đầu là một trở ngại lớn, tăng điểm của tôi từ 66 lên 125, nhưng tôi đã tìm thấy một cách ngắn hơn so với nó (rất may!).

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

Giải trình:

Mã này lặp qua từng ký tự trong đầu vào và thay thế từng ký tự bằng rhoặc ebằng logic này:

• Nếu vị trí của nhân vật là <= vị trí cuối cùng của pVÀ VÀ nhân vật là vị trí tiếp theo trong cầu vồng, hãy giữ nguyên vị trí đó (thay thế bằngn ).
• Nếu không, ăn nó (thay thế nó e).

Ung dung:

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

Gợi ý chào mừng!

Python 2, 254 byte

Vòng lặp!

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

Thứ lỗi cho sự chơi chữ. : P