สมมติว่าคุณกำลังร้อยเชือกของFroot Loopsสำหรับสร้อยคอสร้อยข้อมือเชือกผูกรองเท้าหรืออะไรก็ตาม มีวงวน 6 สีให้เลือก: r ed, o range, y ellow, g reen, b lue และp urple คุณต้องการให้สายของคุณเริ่มต้นด้วยสีแดงที่ด้านซ้ายสุดและวนไปตามลำดับสายรุ้งไปทางขวาสิ้นสุดด้วยสีม่วง นั่นคือคุณต้องการสร้างมันขึ้นมาเพื่อให้สแตรนด์ของคุณแสดงโดยสตริงroygbpซ้ำหลาย ๆ ครั้ง (อาจเป็น 0)

ปัญหาคือคุณได้ห่วงลูปของคุณแล้วและไม่ได้อยู่ในลำดับใด ๆ ลูปไหนที่คุณควรกินและไม่กินเพื่อให้คุณสามารถเพิ่มจำนวนรอบการเรนโบว์ที่ถูกต้องจากซ้ายไปขวาด้วยลูปสีแดงแรกและลูปสีม่วงสุดท้าย

เขียนโปรแกรมหรือฟังก์ชั่นที่รับสายอักขระตามใจชอบroygbpและพิมพ์หรือส่งคืนสตริงที่มีความยาวเท่ากันโดยeใส่nในสถานที่ของลูปเพื่อรับประทาน

ตัวอย่างเช่นหาก Froot Loop ของคุณมีลักษณะเหมือน

อินพุตจะเป็น

gorboypbgbopyroybbbogppbporyoygbpr

และจากซ้ายไปขวาเราสามารถหาroygbpลำดับรุ้งได้ 3 แบบแต่ลูปบางส่วนจำเป็นต้องถูกกินไป ดังนั้นผลลัพธ์จะเป็น

eenenneennenennneeeeneennenennnnne

ส่งผลให้เป็น 3 รอบสาระสมบูรณ์:

หากไม่มีรอบรุ้งสมบูรณ์ในการป้อนข้อมูลแล้วออกจะเป็นทั้งหมดe's และสาระปลายขึ้น loopless เช่นการป้อนข้อมูลที่มีเอาท์พุทproygb eeeeeeตรงกันข้ามมีเอาท์พุทproygbpennnnnn

คุณสามารถสันนิษฐานว่าทุกสายเข้ามีเส้นวนอย่างน้อยหนึ่งวง

รหัสที่สั้นที่สุดในหน่วยไบต์ชนะ

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ส่งคืนรายการ (ซึ่งไม่ควรเป็นกรณีนี้จะแก้ไขใน Pythas ในอนาคต) ฉันใช้jk( kเป็น"") เพื่อรวมเข้าด้วยกันกลับเข้าไปในสตริง ชิ้น:_"roygbp"kส่วนจะแทนที่ทุกอินสแตนซ์ของรอบด้วยสตริงว่าง

เนื่องจากสตริงที่ว่างเปล่าเป็นเท็จย่อหน้าข้างต้นอธิบายวิธีที่ฉันค้นหาดัชนีชุดเล็กที่สุดที่จำเป็นในการกินเพื่อให้ได้สตริงที่ประกอบด้วยรอบเท่านั้น

:*lz\n_\eจากนั้นเปลี่ยนรายการดัชนีเป็นnnnneeenneneสตริง

Hexagony , 920 722 271 ไบต์

คุณพูดว่าลูปผลไม้หกประเภท นั่นคือสิ่งที่ Hexagonyสร้างขึ้นมาเพื่อ

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

ไม่เป็นไร โอ้พระเจ้าฉันทำอะไรกับตัวเอง ...

รหัสนี้คือความยาวด้านหกเหลี่ยม 10 (เริ่มต้นที่ 19) มันอาจจะเล่นกอล์ฟได้มากกว่านี้บางทีอาจเป็นขนาด 9 แต่ฉันคิดว่างานของฉันเสร็จที่นี่ ... สำหรับการอ้างอิงมี 175 คำสั่งจริงในแหล่งที่มาซึ่งส่วนใหญ่เป็นกระจกที่ไม่จำเป็น (หรือเพิ่มเพื่อยกเลิก ออกคำสั่งจากเส้นทางข้าม)

แม้จะมีเส้นตรงชัดเจนรหัสเป็นจริงสองมิติ: Hexagony จะจัดเรียงใหม่เป็นรูปหกเหลี่ยมปกติ (ซึ่งเป็นรหัสที่ถูกต้อง แต่ช่องว่างทั้งหมดเป็นตัวเลือกใน Hexagony) นี่คือรหัสที่คลี่ในทั้งหมดของมัน ... ดีฉันไม่ต้องการที่จะพูดว่า "ความงาม":

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

คำอธิบาย

ฉันจะไม่ลองและเริ่มอธิบายเส้นทางการทำงานที่ซับซ้อนทั้งหมดในเวอร์ชัน golfed นี้ แต่อัลกอริทึมและการควบคุมการไหลโดยรวมนั้นเหมือนกับเวอร์ชั่นที่ไม่ได้รับการแก้ไขซึ่งอาจง่ายต่อการศึกษาสำหรับผู้อยากรู้อยากเห็นจริง ๆ

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

สุจริตในวรรคแรกฉันล้อเล่นเพียงครึ่งเดียว ความจริงที่ว่าเรากำลังจัดการกับวัฏจักรของหกองค์ประกอบเป็นจริงช่วยได้มาก โมเดลหน่วยความจำของ Hexagony เป็นกริดหกเหลี่ยมแบบไม่มีที่สิ้นสุดที่ขอบของกริดแต่ละอันประกอบด้วยเลขจำนวนเต็มความแม่นยำที่มีการลงนามซึ่งเริ่มต้นที่ศูนย์

นี่คือไดอะแกรมของเลย์เอาต์ของหน่วยความจำที่ฉันใช้ในโปรแกรมนี้:

บิตยาวตรงด้านซ้ายถูกนำมาใช้เป็นสตริง 0 สิ้นสุดaของขนาดโดยพลการซึ่งมีความเกี่ยวข้องด้วยตัวอักษรR เส้นประที่อยู่บนตัวอักษรอื่น ๆ แสดงถึงโครงสร้างชนิดเดียวกันโดยแต่ละเส้นนั้นหมุนด้วย 60 องศา ในขั้นต้นตัวชี้หน่วยความจำชี้ไปที่ขอบป้าย1ซึ่งหันไปทางทิศเหนือ

บิตแรกที่เป็นเส้นตรงของโค้ดจะตั้งค่า "ดาว" ด้านในของขอบให้กับตัวอักษรroygbpเช่นเดียวกับการตั้งค่าขอบเริ่มต้นเป็น1เช่นที่เรารู้ว่าวงจรสิ้นสุด / เริ่มต้น (ระหว่างpและr):

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

หลังจากนี้เรากลับมาอยู่บนขอบที่มีข้อความ1

ตอนนี้แนวคิดทั่วไปของอัลกอริทึมคือ:

1. สำหรับแต่ละตัวอักษรในวงรอบให้อ่านตัวอักษรจาก STDIN และหากตัวอักษรนั้นแตกต่างจากตัวอักษรปัจจุบันให้ต่อท้ายสตริงที่เกี่ยวข้องกับตัวอักษรนั้น
2. เมื่อเราอ่านจดหมายที่เรากำลังมองหาอยู่เราเก็บจดหมายeไว้ที่ขอบ? เพราะตราบใดที่รอบยังไม่สมบูรณ์เราต้องสมมติว่าเราจะต้องกินตัวละครนี้ด้วย หลังจากนั้นเราจะย้ายวงแหวนไปที่ตัวละครถัดไปในวงรอบ
3. มีสองวิธีที่กระบวนการนี้สามารถถูกขัดจังหวะ:
   • ไม่ว่าเราจะเสร็จสิ้นรอบ ในกรณีนี้เราทำอีกรอบอย่างรวดเร็วผ่านวงจรแทนสิ่งเหล่านั้นทั้งหมดeใน? ขอบกับns เพราะตอนนี้เราต้องการให้วงจรนั้นอยู่บนสร้อยคอ จากนั้นเราไปยังรหัสการพิมพ์
   • หรือเรากด EOF (ซึ่งเราจำได้ว่าเป็นรหัสอักขระเชิงลบ) ในกรณีนี้เราเขียนค่าลบลงใน? ขอบของอักขระปัจจุบัน (เพื่อให้เราสามารถแยกแยะได้ง่ายจากทั้งสองeและn) จากนั้นเราค้นหาขอบ1 (เพื่อข้ามส่วนที่เหลือของวัฏจักรที่อาจไม่สมบูรณ์) ก่อนที่จะย้ายไปพิมพ์รหัสเช่นกัน
4. รหัสการพิมพ์จะผ่านรอบอีกครั้ง: สำหรับตัวละครแต่ละตัวในรอบนั้นจะเป็นการล้างสตริงที่เก็บไว้ในขณะที่พิมพ์eสำหรับตัวละครแต่ละตัว จากนั้นมันจะย้ายไปที่? ขอบที่เกี่ยวข้องกับตัวละคร ถ้ามันเป็นลบเราก็จะยุติโปรแกรม ถ้ามันเป็นบวกเราก็พิมพ์และย้ายไปที่ตัวละครต่อไป เมื่อเราเสร็จสิ้นรอบเรากลับไปที่ขั้นตอนที่ 2

อีกสิ่งหนึ่งที่น่าสนใจคือวิธีที่ฉันใช้สตริงขนาดตามอำเภอใจ (เพราะเป็นครั้งแรกที่ฉันใช้หน่วยความจำที่ไม่มีขอบเขตใน Hexagony)

ลองนึกภาพเราในบางจุดที่เรายังคงอ่านตัวอักษรR (เพื่อให้เราสามารถใช้แผนภาพที่เป็นอยู่) และa [0]และ1ได้รับแล้วเต็มไปด้วยตัวละคร (ทุกอย่างตะวันตกเฉียงเหนือของพวกเขายังคงเป็นศูนย์ ) เช่นบางทีเราได้เพียงแค่อ่านตัวละครสองตัวแรกของการป้อนข้อมูลลงในขอบเหล่านั้นและตอนนี้การอ่านogy

ตัวละครใหม่จะถูกอ่านเข้าไปในขอบ เราใช้? rขอบเพื่อตรวจสอบว่าตัวละครตัวนี้จะมีค่าเท่ากับ (มีเคล็ดลับที่ดีที่นี่: Hexagony สามารถแยกความแตกต่างระหว่างค่าบวกและค่าบวกได้อย่างง่ายดายดังนั้นการตรวจสอบความเท่าเทียมกันผ่านการลบนั้นน่ารำคาญและต้องใช้อย่างน้อยสองสาขา แต่ตัวอักษรทั้งหมดนั้นน้อยกว่า 2 ปัจจัยจากกัน เราสามารถเปรียบเทียบค่าโดยการใช้โมดูโลซึ่งจะให้เป็นศูนย์ถ้ามันเท่ากัน)

เนื่องจากyแตกต่างจากrเราจึงย้ายขอบ (ไม่มีป้ายกำกับ) ที่เหลือเข้าไปและคัดลอกที่yนั่น ตอนนี้เราย้ายออกไปรอบหกเหลี่ยมคัดลอกตัวอักษรหนึ่งขอบเพิ่มเติมในแต่ละครั้งจนกว่าเราจะมีyตรงข้ามขอบใน แต่ตอนนี้มีตัวละครใน[0]ซึ่งเราไม่ต้องการเขียนทับ แต่เรา "ลาก" ในyรอบหกเหลี่ยมต่อไปและตรวจสอบ1 แต่มีตัวละครอยู่ที่นั่นด้วยเราเลยออกไปอีกหกเหลี่ยม ตอนนี้[2]ยังคงเป็นศูนย์ดังนั้นเราจึงคัดลอกyเป็นมัน ตัวชี้หน่วยความจำตอนนี้ย้ายกลับไปตามสายไปทางวงแหวนด้านใน เรารู้เมื่อเรามาถึงจุดเริ่มต้นของสตริงเพราะ (unlabelled) ขอบระหว่างa [i]ทั้งหมดเป็นศูนย์ในขณะที่? เป็นบวก

นี่อาจเป็นเทคนิคที่มีประโยชน์สำหรับการเขียนโค้ดที่ไม่น่าสนใจใน Hexagony โดยทั่วไป

Hexagony , 169 ไบต์

ฉันได้แรงบันดาลใจจากคำตอบของ Martin Büttner (มันเป็น esolang ของเขาด้วย) และตัดสินใจว่าฉันจะทำได้ในขนาด 8 (ฉันเชื่อว่ามันเป็นไปได้ในขนาด 7 เช่นกัน แต่มันยากมากฉันใช้เวลาสี่วันแล้วไม่ใช่ - หยุดที่นี่)

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

วางหกเหลี่ยม:

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

โปรแกรมไม่ได้ใช้#คำสั่งดังนั้นฉันใช้ตัวละครนั้นเพื่อแสดงว่าเซลล์ใดที่ไม่ได้ใช้จริง ยิ่งกว่านั้นเซลล์ no-op ทุกอันที่เคลื่อนที่ในทิศทางเดียวเท่านั้นจะเป็นกระจกเงา (เช่น_ถ้าเคลื่อนที่ในแนวนอน) ดังนั้นคุณจะรู้ว่า.ตัวละครทุกตัวถูกสำรวจในทิศทางเดียวมากกว่าหนึ่งทิศทาง

คำอธิบาย

r''o{{y''g{{b''p"")"ในช่วงเริ่มต้นที่เราดำเนินการลำดับคำแนะนำ สิ่งเหล่านี้เกลื่อนกลาดไปทั่วรหัสเพราะฉันบีบพวกเขาหลังจากที่ฉันเขียนทุกอย่างอื่น ฉันใช้]เพื่อสลับไปยังตัวชี้คำสั่งถัดไปสองสามครั้ง ด้วยวิธีนี้ฉันสามารถส่งผ่านทางไกลไปยังอีกมุมหนึ่งของรูปหกเหลี่ยมได้ ส่วนที่เหลือทั้งหมดของโปรแกรมดำเนินการโดยตัวชี้คำแนะนำ # 3

ขณะนี้หน่วยความจำมีลักษณะดังนี้โดยมีขอบที่สำคัญติดป้ายชื่อฉันจะใช้ในคำอธิบายนี้:

ขอบป้ายกำกับหมายถึงสิ่งต่อไปนี้:

• in: เราใช้ขอบนี้เพื่อเก็บอักขระที่เราอ่านจาก STDIN
• %: เราใช้ขอบนี้เพื่อดำเนินการแบบโมดูโลในตัวอักษรที่อ่านได้จาก STDIN ( in) และปัจจุบัน“ถูกต้อง” ตัวอักษร ( r, oฯลฯ ) ซึ่งจะเป็น0ถ้าพวกเขามีค่าเท่ากัน ฉันขโมยเล่ห์อุบายนี้จากคำตอบของ Martin Büttner แต่โปรแกรมที่เหลือแตกต่างกัน
• #: ตราบใดที่เราอ่านตัวอักษร“ ไม่ถูกต้อง” (เช่นสีที่เราต้องกิน) เราเพิ่มขอบนี้ ดังนั้นขอบนี้จะจำได้ว่าeเราต้องการออกจำนวนเท่าใดในภายหลัง
• r?: เสมอ0ยกเว้นส่วนที่เป็นr(สีแดง) สิ่งนี้บอกเราเมื่อเราเสร็จสิ้นรอบ

โปรแกรมดำเนินการดังนี้:

• อ่านตัวอักษรต่อไป #หากยังไม่ได้ตัวละครที่เรากำลังมองหาที่เพิ่มขึ้น มิฉะนั้นย้ายไปยังส่วนต่อไปของหน่วยความจำตามเข็มนาฬิกา
• เมื่อย้ายไปยังส่วนต่อไปหากr?เป็นบวกเราได้ทำการปฏิวัติทั้งหมด ทำรอบที่สมบูรณ์และเอาท์พุท# es และ 1 nต่อส่วน ชุดนี้แต่ละคนกลับไป# 0( 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กับจุดสิ้นสุดของสตริงซึ่งเราจะใช้ในการคำนวณวงจรของตัวอักษรแบบไดนามิก

ถัดไป (ยาว) ตัวเลขขั้นตอนออก loops nซึ่งจะเก็บและแทนที่พวกเขาด้วย เราจะดูว่ามันใช้งานได้ดี

#.*
<empty>

สิ่งนี้จะกำจัดผู้ช่วยค้นหาของเราที่ส่วนท้ายของสตริง

[^n]
e

สิ่งนี้จะแทนที่อักขระทั้งหมดที่ไม่ได้ถูกแทนที่ในขั้นตอนที่สองด้วยeทำให้การแปลงเสร็จสมบูรณ์

ตอนนี้เราจะกลับไปที่ขั้นตอนที่สอง

โครงสร้างพื้นฐานใช้เคล็ดลับซึ่งฉันค้นพบเมื่อไม่กี่เดือนที่ผ่านมาเพื่อแทนที่อักขระที่เลือกในการแข่งขันระดับโลก:

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

ที่...สอดคล้องกับรูปแบบที่ซับซ้อนโดยพลการ สิ่งนี้ตรงกับตัวละครที่จะถูกแทนที่ด้วย.และจากนั้นเริ่ม lookbehind (ซึ่งคุณควรอ่านจากขวาไปซ้าย) จับ lookbehind prefixทุกอย่างขึ้นกับตัวละครจับคู่ลงในกลุ่ม จากนั้นมันจะเปลี่ยนเป็นการมองไปข้างหน้าซึ่งตอนนี้เริ่มต้นจากจุดเริ่มต้นของสตริงและสามารถมีรูปแบบที่ซับซ้อน หลังจากตัวละครที่เราต้องการแทนที่ในรูปแบบนั้นเราใส่ตัวเลือกดูด้านหลังซึ่งตรวจสอบว่าprefixกลุ่มตรงกับที่นี่ ถ้าเป็นเช่นนั้นมันจะจับสตริงว่างเข้าไปในflagกลุ่ม. หากไม่เป็นเช่นนั้นเพราะเป็นตัวเลือกจะไม่ส่งผลกระทบต่อสถานะของโปรแกรม regex เลยและจะถูกข้าม ในที่สุดเมื่อจับคู่ lookahead ได้สำเร็จจะมีเพียงส่วน\k<flag>ท้ายที่เหลือซึ่งจะจับคู่ก็ต่อเมื่อมีการตั้งค่าสถานะในบางช่วงระหว่างการคำนวณ

ทีนี้มาลอง regex ยาว ๆ กันหน่อยโดยใช้กลุ่มที่มีชื่อและโหมดอิสระ:

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

...ฉันหวังว่าคุณรู้จักเค้าร่างทั่วไปจากข้างต้นดังนั้นเราจะต้องดูสิ่งที่ฉันเต็มใน

charเราต้องการที่จะจับตัวอักษรถัดไปในวงจรในกลุ่ม เราทำเช่นนี้โดยยังจดจำสตริงจากตัวละครในปัจจุบัน# cycleที่จะได้รับตัวอักษรถัดไปเราจะใช้ lookahead #การค้นหาสำหรับ ตอนนี้เราพยายามให้ตรงนั้นตรงกับตัวอักษรถัดไปในcycle charซึ่งมักจะเป็นไปได้เว้นแต่เป็นตัวละครที่ผ่านมาchar pในกรณีนี้จะตรงกับที่เหลือทั้งหมดของสตริงและจะไม่มีตัวละครจากซ้ายไปจับเข้า\k<cycle> charดังนั้นเครื่องยนต์ backtracks ละเว้นการอ้างอิงย้อนกลับcycleและเพียงแค่จับคู่อักขระตัวแรกrแทน

ตอนนี้เราได้มีตัวอักษรถัดไปในวงจรในเราค้นหาที่เกิดขึ้นเป็นไปได้ต่อไปของตัวละครที่มีchar .*?\k<char>นี่คือตัวละครที่เราต้องการแทนที่ดังนั้นเราจึงใส่prefixเครื่องหมายในเช็ค ขั้นตอนเหล่านี้ (พบว่าต่อไปcharในรอบการค้นหาสำหรับเหตุการณ์ถัดไปของมันธงชุดถ้าเหมาะสม) +ตอนนี้ก็ซ้ำกับ

ที่จริงทั้งหมดที่มีให้หา subsequence วงจร 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

Lua, 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"

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

ซอถูกทดสอบใน Firefox ฉันได้ยิน Chrome รองรับฟังก์ชั่นลูกศร แต่ฉันยังไม่ได้ทดสอบใน Chrome

Ungolfed:

input=>eval("
    array = [...input],
    rainbow_index = 0,
    mapped = array.map( item=>
        item == 'roygbp'[rainbow_index%6] ? 'n'[++rainbow_index&0] : 'e'
        // when we encounter an item of the rainbow, do not eat and start using
        // the next rainbow item, otherwise eat
    );
    // go through backwards and eat until we find a 'p' indicating the last
    // complete loop
    for(i = mapped.length - 1; i && array[i]!='p'; mapped[i--] = 'e');

    mapped.join``
")

เหยี่ยว, 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"หลังจากการแทนที่มันจะประกาศอาหารทุกอย่าง ("e") นั่นไม่ใช่ส่วนหนึ่งของสายรุ้งที่สมบูรณ์

การรวมกันนี้ช่วยให้มั่นใจโดยอัตโนมัติว่าจะไม่มีอันตรายใด ๆ กับรุ้งระหว่างการดำเนินการนี้

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!

ข้อ จำกัด เล็ก ๆ น้อย ๆ : เครื่องต้องมีตัวอักษรที่ลงนาม (ตัวพิมพ์ใหญ่) และสตริงต้องสั้นพอสมควร เอาต์พุตต่อท้าย\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)

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

ยินดีต้อนรับข้อเสนอแนะ!

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