एक फ्रूट लूप हार फिक्सिंग

47

मान लीजिए कि आप एक हार, कंगन, जूते का फीता, या जो कुछ भी के लिए फ्रूट लूप्स के एक स्ट्रैंड को स्ट्रिंग कर रहे हैं । 6 पाश रंग हैं: आर एड, ओ रेंज, y ellow, जी रीन, ख लुए, और पी urple। आप चाहते हैं कि आपका स्ट्रैंड बहुत बाईं ओर लाल से शुरू हो और इंद्रधनुष क्रम में जा रहा है, बैंगनी के साथ समाप्त हो रहा है। यही है, आप इसे बनाना चाहते हैं ताकि आपके स्ट्रैंड को roygbpकुछ बार दोहराई जाने वाली स्ट्रिंग द्वारा दर्शाया जा सके (संभवतः 0)।

समस्या यह है, आप पहले से ही अपने छोरों को मार चुके हैं, और किसी विशेष क्रम में नहीं। आपको कौन से छोरों को खाना चाहिए और खाना नहीं चाहिए ताकि आप बाएं से दाएं जाने वाले इंद्रधनुष के चक्रों की संख्या को अधिकतम कर सकें, पहले लूप लाल और बहुत आखिरी लूप पर्पल के साथ?

एक प्रोग्राम या फ़ंक्शन लिखें जो वर्णों roygbpऔर प्रिंटों की एक मनमानी स्ट्रिंग में लेता है या eखाने के लिए छोरों के स्थान पर और खाने के लिए छोरों के स्थान पर उसी लंबाई की एक स्ट्रिंग देता है n।

उदाहरण के लिए, यदि आपका फ्रूट लूप स्ट्रैंड दिखता है

यादृच्छिक Froot लूप किनारा

इनपुट होगा

gorboypbgbopyroybbbogppbporyoygbpr

और बाएं से दाएं हम 3 पूर्ण roygbpइंद्रधनुष अनुक्रम पा सकते हैं , लेकिन कुछ छोरों को दूर खाने की आवश्यकता होती है। इस प्रकार उत्पादन होगा

eenenneennenennneeeeneennenennnnne

एक आदर्श 3 चक्र किनारा में परिणाम:

3 इंद्रधनुष चक्र फ्रूट लूप स्ट्रैंड

यदि इनपुट में पूर्ण इंद्रधनुष चक्र नहीं होते हैं, तो आउटपुट सभी हो जाएगा eऔर स्ट्रैंड लूपलेस हो जाएगा। जैसे इनपुट proygbमें आउटपुट है eeeeee। इसके विपरीत, proygbpआउटपुट है ennnnnn।

आप मान सकते हैं कि सभी इनपुट स्ट्रैंड में कम से कम एक लूप है।

बाइट्स में सबसे छोटा कोड जीतता है।

code-golf  string 
— केल्विन के शौक
स्रोत
1
@ हाँ हाँ। इंद्रधनुष चक्रों की संख्या को अधिकतम करने के बारे में भाग पर ध्यान दें। और आप उन सभी को खा सकते हैं।
— केल्विन के शौक
15
आपने वास्तव में उन फलों के लूपों को छांटा और पिरोया, जो तस्वीरें लेने के लिए नहीं थे?
— मार्टिन एंडर
13
@ मार्टिनबटनर बेशक
— केल्विन के शौक
1
क्या हर इंद्रधनुष चक्र को शुरू करना पड़ता है rया वह oygbproygbprभी क्वालीफाई कर सकता है ?
— orlp
4
हां, लेकिन अगर वे एक हार या कंगन पर फंसे हैं तो निश्चित रूप से उन्हें घुमाया जा सकता है?
— पीटर टेलर

जवाबों:

11

पायथ, 31 बाइट्स

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

अविश्वसनीय रूप से अक्षम, स्पष्टीकरण जल्द ही आ रहा है।

yUlzzक्रम में (इनपुट) के सभी संभव सूचकांकों के सभी संभव सबसेट को उत्पन्न करता है । जैसे यदि इनपुट है abc:

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

फिर उपरोक्त सूची में hf!पहला ऐसा पाया गया Tजो :jk.DzT"roygbp"kझूठा है। .Dएक स्ट्रिंग और सूचकांकों की सूची लेता है, और उन सूचकांकों में तत्वों को हटा देता है। तो .D"abcd",1 3है "ac"। के बाद से .Dरिटर्न एक सूची है, मैं उपयोग (जो मामला नहीं होना चाहिए, Pyth के भविष्य के संस्करणों में ठीक कर देंगे) jk( kहै "") यह एक साथ एक स्ट्रिंग में वापस शामिल होने के लिए। :_"roygbp"kभाग रिक्त स्ट्रिंग के साथ एक चक्र के प्रत्येक उदाहरण बदल देता है।

चूंकि खाली स्ट्रिंग झूठी है, इसलिए उपरोक्त पैराग्राफ बताते हैं कि कैसे मैं एक चक्र प्राप्त करने के लिए खाने के लिए खाने के लिए आवश्यक सूचकांकों का सबसे छोटा सेट ढूंढता हूं।

:*lz\n_\eफिर सूचकांक की उस सूची को एक nnnneeenneneस्ट्रिंग में बदल देता है ।

— orlp
स्रोत
55

हेक्सागोनी , 920 722 271 बाइट्स

छह अलग-अलग प्रकार के फल लूप, आप कहते हैं? यही हेक्सागोनी केलिए बनाया गया था।

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

ठीक है, यह नहीं था। हे भगवान, मैंने अपने आप को क्या किया ...

यह कोड अब साइड 10 लंबाई का षट्भुज है (यह 19 में शुरू हुआ)। यह संभवत: 9 और आकार का हो सकता है, शायद 9 के आकार का भी हो, लेकिन मुझे लगता है कि मेरा काम यहां हो गया है ... संदर्भ के लिए, स्रोत में 175 वास्तविक कमांड हैं, जिनमें से कई संभावित अनावश्यक दर्पण हैं (या रद्द करने के लिए जोड़े गए थे) एक पार पथ से एक कमांड)।

स्पष्ट रैखिकता के बावजूद, कोड वास्तव में दो-आयामी है: हेक्सागोनी इसे एक नियमित षट्भुज में बदल देगा (जो कि वैध कोड भी है, लेकिन सभी व्हाट्सएप हेक्सागोनी में वैकल्पिक है)। यहाँ इसके सभी में अनकहा कोड है ... अच्छी तरह से मैं "सौंदर्य" नहीं कहना चाहता:

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

व्याख्या

मैं भी कोशिश नहीं करूँगा और इस गोल्फ संस्करण में सभी जटिल निष्पादन मार्गों की व्याख्या करना शुरू कर दूंगा, लेकिन एल्गोरिथ्म और समग्र नियंत्रण प्रवाह इस असम्बद्ध संस्करण के समान है जो कि मैंने एल्गोरिथ्म के समझाने के बाद वास्तव में जिज्ञासु के लिए अध्ययन करना आसान हो सकता है:

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

ईमानदारी से, पहले पैराग्राफ में मैं केवल आधा मजाक कर रहा था। तथ्य यह है कि हम छह तत्वों के एक चक्र के साथ काम कर रहे हैं वास्तव में एक बड़ी मदद थी। हेक्सागोनी का मेमोरी मॉडल एक अनंत हेक्सागोनल ग्रिड है जहां ग्रिड के प्रत्येक किनारे में एक हस्ताक्षरित मनमाना-सटीक पूर्णांक होता है, जिसे शून्य से आरंभ किया जाता है।

यहाँ इस कार्यक्रम में उपयोग की गई मेमोरी के लेआउट का एक चित्र दिया गया है:

यहाँ छवि विवरण दर्ज करें

बाईं ओर के लंबे सीधे बिट का उपयोग aमनमाने आकार के 0-टर्मिनेटेड स्ट्रिंग के रूप में किया जाता है जो अक्षर r से जुड़ा होता है । अन्य अक्षरों पर धराशायी लाइनें एक ही तरह की संरचना का प्रतिनिधित्व करती हैं, प्रत्येक को 60 डिग्री से घुमाया जाता है। प्रारंभ में, मेमोरी पॉइंटर 1 पर स्थित किनारे पर इंगित करता है , उत्तर की ओर।

कोड का पहला, रैखिक बिट किनारों के आंतरिक "स्टार" को अक्षरों के roygbpसाथ-साथ प्रारंभिक किनारे पर सेट करता है 1, जैसे कि हम जानते हैं कि चक्र कहां समाप्त होता है / शुरू होता है (बीच pऔर r):

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

इसके बाद, हम 1 लेबल वाले किनारे पर वापस आ गए हैं ।

अब एल्गोरिथ्म का सामान्य विचार यह है:

  1. चक्र में प्रत्येक अक्षर के लिए, एसटीडीआईएन से पत्र पढ़ते रहें और, यदि वे वर्तमान पत्र से अलग हैं, तो उन्हें उस पत्र से जुड़े स्ट्रिंग में जोड़ दें।
  2. जब हम उस पत्र को पढ़ते हैं जिसे हम वर्तमान में देख रहे हैं, तो हम eलेबल वाले किनारे में संग्रहीत करते हैं ? , क्योंकि जब तक यह चक्र पूरा नहीं होता है, हमें यह मानना ​​होगा कि हमें इस चरित्र को भी खाना होगा। बाद में, हम चक्र में अगले वर्ण के लिए रिंग के चारों ओर घूमेंगे।
  3. इस प्रक्रिया को बाधित करने के दो तरीके हैं:
    • या तो हमने चक्र पूरा कर लिया है। इस मामले में, हम चक्र के माध्यम से एक और त्वरित दौर बनाते हैं, जो उन सभी को बदल रहा eहै ? किनारों के साथ n, क्योंकि अब हम चाहते हैं कि यह चक्र हार पर बना रहे। फिर हम प्रिंटिंग कोड की ओर बढ़ते हैं।
    • या हमने ईओएफ को मारा (जिसे हम एक नकारात्मक चरित्र कोड के रूप में पहचानते हैं)। इस मामले में, हम एक नकारात्मक मान लिखते हैं ? वर्तमान चरित्र का किनारा (ताकि हम इसे आसानी से दोनों से अलग कर सकें eऔर n)। फिर हम मुद्रण कोड पर जाने से पहले 1 किनारे (संभावित अपूर्ण चक्र के शेष को छोड़ना) के लिए खोज करते हैं ।
  4. मुद्रण कोड फिर से चक्र से गुजरता है: चक्र में प्रत्येक वर्ण के लिए यह eप्रत्येक वर्ण के लिए मुद्रण करते समय संग्रहीत स्ट्रिंग को साफ करता है । फिर यह करने के लिए चलता है ? चरित्र के साथ जुड़ा हुआ किनारा। यदि यह नकारात्मक है, तो हम बस कार्यक्रम को समाप्त कर देते हैं। यदि यह सकारात्मक है, तो हम इसे प्रिंट करते हैं और अगले चरित्र पर जाते हैं। एक बार जब हम चक्र पूरा कर लेते हैं तो हम चरण 2 पर वापस जाते हैं।

एक और बात जो दिलचस्प हो सकती है, वह यह है कि मैंने मनमाने आकार के तारों को कैसे लागू किया है (क्योंकि यह पहली बार मैंने हेक्सागोनी में अनबाउंड मेमोरी का उपयोग किया है)।

कल्पना कीजिए कि हम कुछ बिंदु जहां हम अभी भी के लिए पात्रों पढ़ रहे हैं पर हैं आर (ताकि हम आरेख का उपयोग कर सकते है के रूप में) और एक [0] और एक 1 पहले से ही अक्षर के साथ भर दिया गया है (उनमें से सब कुछ उत्तर पश्चिम अभी भी शून्य है )। उदाहरण के लिए, शायद हमने ogइनपुट के पहले दो पात्रों को उन किनारों में पढ़ा है और अब पढ़ रहे हैं y।

नए चरित्र को किनारे में पढ़ा जाता है । हम का उपयोग करें ? यह जाँचने के लिए कि क्या यह पात्र समान है r। (यहां एक निफ्टी चाल है: हेक्सागोनी केवल सकारात्मक और गैर-सकारात्मक के बीच आसानी से अंतर कर सकती है, इसलिए घटाव के माध्यम से समानता की जांच करना कष्टप्रद है और इसके लिए कम से कम दो शाखाओं की आवश्यकता होती है। लेकिन सभी अक्षर एक दूसरे से 2 के कारक से कम हैं, इसलिए। हम मोडुलो को लेते हुए मूल्यों की तुलना कर सकते हैं, जो केवल शून्य देगा यदि वे समान हैं।)

क्योंकि yसे अलग है r, हम (लेबल नहीं किया गया) बढ़त के बायीं तरफ चली में और कॉपी yवहाँ। अब हम षट्भुज चारों ओर आगे ले जाते हैं, आगे हर बार चरित्र एक किनारे को कॉपी, जब तक हमारे पास yके किनारे विपरीत पर में । लेकिन अब पहले से ही एक चरित्र है [0] जिसे हम अधिलेखित नहीं करना चाहते हैं। इसके बजाय, हम yअगले षट्भुज के चारों ओर "खींचें" और एक 1 की जांच करें । लेकिन वहाँ एक चरित्र के रूप में अच्छी तरह से है, इसलिए हम आगे एक और षट्भुज चलते हैं। अब एक [2] अभी भी शून्य है, इसलिए हम इसकी नकल करते हैंyइसे में। मेमोरी पॉइंटर अब स्ट्रिंग के साथ-साथ इनर रिंग की ओर बढ़ता है। हम जानते हैं कि जब हम स्ट्रिंग की शुरुआत में पहुंच गए हैं, क्योंकि [(i) [a] के बीच (अनलेबल्ड) किनारों सभी शून्य हैं ? सकारात्मक है।

यह संभवतः हेक्सागोनी में सामान्य रूप से गैर-तुच्छ कोड लिखने के लिए एक उपयोगी तकनीक होगी।

— मार्टिन एंडर
स्रोत
12
...वाह। बस वाह।
— एलियास बेनेवेदेस
1
यह गोल्फ चुनौती नहीं जीत सकता है, लेकिन ... आदमी, एक साफ समाधान है कि ...
— thanby
चूंकि एक पंक्ति में डॉट्स के समूह अक्सर स्रोत में होते हैं, हो सकता है कि आप डॉट्स के रन-लेंथ एन्कोडिंग के लिए भाषा में कोई सुविधा जोड़ सकते हैं या कोड लंबाई में कटौती करने के लिए कुछ कर सकते हैं।
— mbomb007
@ mbomb007 गोल्फिंग वास्तव में हेक्सागोनी की प्राथमिकता में नहीं है। ;) इसके अलावा, मेरे पास वास्तविक कोड से रन-लेंडिंग एन्कोडिंग को भेद करने के लिए कोई पात्र नहीं बचा है ... (और मुझे लगता है कि वास्तव में अच्छी तरह से गोल्फ कोड में भी नो-ऑप्स के ये रन नहीं होंगे।)
— मार्टिन एंडर
30

हेक्सागोनी , 169 बाइट्स

मैं मार्टिन बंटनर के जवाब से प्रेरित था (यह उसका एसोलैंग भी है) और मैंने फैसला किया कि मैं इसे आकार 8 में कर सकता हूं (मुझे विश्वास है कि यह आकार 7 में भी संभव है, लेकिन यह बहुत मुश्किल है। मैंने पहले ही चार दिन बिताए हैं। -इस पर रुकें

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

हेक्सागोनली से बाहर निकलना:

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

कार्यक्रम वास्तव में #निर्देश का उपयोग नहीं करता है , इसलिए मैंने उस चरित्र का उपयोग यह दिखाने के लिए किया है कि कौन से सेल वास्तव में अप्रयुक्त हैं। इसके अलावा, प्रत्येक नो-ऑप सेल जो केवल एक दिशा में ट्रेस किया जाता है, एक दर्पण है (उदाहरण के लिए _यदि क्षैतिज रूप से ट्रेस किया गया है), तो आप जानते हैं कि सभी .वर्ण एक से अधिक दिशाओं में ट्रैवर्स किए गए हैं।

व्याख्या

प्रारंभ में, हम निर्देशों के अनुक्रम को निष्पादित करते हैं r''o{{y''g{{b''p"")"। ये कोड भर में थोड़े अजीब हैं, क्योंकि मैंने उन्हें सब कुछ लिखने के बाद निचोड़ लिया था। मैं ]अगले अनुदेश सूचक को कुछ बार स्विच करने के लिए उपयोग करता हूं ; इस तरह मैं अनिवार्य रूप से षट्भुज के दूसरे कोने में टेलीपोर्ट कर सकता हूं। कार्यक्रम के पूरे बाकी को निर्देश सूचक # 3 द्वारा निष्पादित किया जाता है।

स्मृति अब इस स्पष्टीकरण के साथ नामों के साथ लेबल किए गए महत्वपूर्ण किनारों के साथ निम्नानुसार दिखती है:

स्मृति लेआउट कार्यक्रम की शुरुआत के पास

लेबल किए गए किनारों का मतलब निम्न है:

  • in: हम इस किनारे का उपयोग एक चरित्र को स्टोर करने के लिए करते हैं जिसे हम STDIN से पढ़ते हैं।
  • %: हम इस बढ़त का उपयोग करें (इस पात्र को सापेक्ष आपरेशन STDIN से पढ़ने के प्रदर्शन करने के लिए in) और वर्तमान "वैध" वर्ण ( r, oआदि) है, जो हो जाएगा 0अगर वे बराबर हैं। मैंने मार्टिन बट्टनर के जवाब से इस चाल को चुरा लिया है, लेकिन बाकी कार्यक्रम अलग है।
  • #: जब तक हम "अमान्य" अक्षर पढ़ते हैं (यानी हमें खाने के लिए जो रंग चाहिए), हम इस बढ़त को बढ़ाते हैं। इस प्रकार, यह बढ़त याद रखती है कि eहमें बाद में कितने एस की जरूरत है।
  • r?: हमेशा ( 0सिवाय जहां rलाल) हिस्सा है। यह बताता है कि हमने कब एक चक्र पूरा किया है।

इस प्रकार कार्यक्रम आगे बढ़ता है:

  • किरदार पढ़ते रहे। यदि यह वह चरित्र नहीं है जिसे हम वर्तमान में देख रहे हैं, वेतन वृद्धि #। अन्यथा क्लॉकवाइज ऑर्डर में मेमोरी के अगले सेगमेंट में जाएं।
  • अगले सेगमेंट में जाने पर, यदि r?सकारात्मक है, तो हमने पूरी क्रांति कर दी है। एक पूर्ण गोल और आउटपुट # es और 1 nप्रति खंड बनाएं । यह प्रत्येक को #वापस सेट करता है 0। ( eएक nगैर- सूचीबद्ध किनारे पर रखा गया है, लेकिन हम #किनारे को गलत बताते हैं , जिसे हम बाद में 0एक *(गुणा) का उपयोग करने के लिए सेट करते हैं , जो काम करता है क्योंकि हम जानते हैं कि %इस समय सभी किनारे शून्य हैं।)
  • किसी पात्र को पढ़ते समय, यदि यह सकारात्मक नहीं है (यानी, EOF), सर्कल के माध्यम से पीछे की ओर जाएं और #+1 es तब तक आउटपुट करें जब तक कि आप r?सकारात्मक नहीं है, तब तक बाहर निकलें।

एक पूर्ण चलाने के बाद, मेमोरी लगभग अंत में निम्नानुसार दिखाई देती है। आप किनारों को नोटिस करेंगे 101(ASCII कोड e); में से एक inकिनारों है -1(EOF); सभी #किनारे 0 पर हैं; और मेमोरी पॉइंटर पॉजिटिव r?एज पर समाप्त होता है ।

कार्यक्रम के अंत में मेमोरी लेआउट

— Timwi
स्रोत
15

रेटिना , 148 85 79 बाइट्स

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

[^n]
e

आप इसे -sदुभाषिया ध्वज के साथ एकल स्रोत फ़ाइल से चला सकते हैं ।

व्याख्या

आइए पहले सामान को बाहर निकालें:

$
#roygbp

जोड़ता #roygbpस्ट्रिंग है, जो हम गतिशील पत्र के चक्र की गणना करने के लिए इस्तेमाल करेंगे के अंत तक।

अगले (लंबे) चरण के आंकड़े बताते हैं कि उन्हें रखने और बदलने के लिए कौन से छोर हैं n। हम इस पर ध्यान देंगे कि यह कैसे थोड़ा सा काम करता है।

#.*
<empty>

यह स्ट्रिंग के अंत में हमारे लुकअप हेल्पर से छुटकारा दिलाता है।

[^n]
e

यह उन सभी वर्णों को बदल देता है eजिन्हें परिवर्तन पूरा करने के साथ दूसरे चरण में प्रतिस्थापित नहीं किया गया था ।

अब दूसरे चरण पर वापस जाते हैं।

मूल संरचना एक चाल का उपयोग करती है, जिसे मैंने कुछ महीने पहले एक वैश्विक मैच में चयनित पात्रों को बदलने के लिए खोजा था :

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

जहां ...एक मनमाने ढंग से जटिल पैटर्न से मेल खाती है। यह चरित्र के साथ प्रतिस्थापित होने के साथ मेल खाता है .और फिर एक खोज शुरू करता है (जिसे आपको दाएं से बाएं पढ़ना चाहिए)। एक समूह में मिलान किए गए चरित्र तक सब कुछ दिखता है prefix। फिर यह आगे एक नज़र में बदल जाता है , जो अब स्ट्रिंग की शुरुआत से शुरू होता है और इसमें एक जटिल पैटर्न हो सकता है। उस चरित्र के बाद जिसे हम उस पैटर्न में बदलना चाहते हैं, हम पीछे एक वैकल्पिक नज़र डालते हैं , जो यह जाँचता है कि prefixसमूह यहाँ मेल खाता है या नहीं। यदि ऐसा होता है, तो यह एक खाली स्ट्रिंग को पकड़ लेता हैflagसमूह। यदि यह नहीं है, क्योंकि यह वैकल्पिक है, तो यह रेगेक्स इंजन की स्थिति को बिल्कुल भी प्रभावित नहीं करता है और इसे नजरअंदाज कर दिया जाता है। अंत में, एक बार जब लुकहेड का सफलतापूर्वक मिलान हो जाता है, तो केवल \k<flag>अंत में छोड़ दिया जाता है जो केवल तभी मिलान करता है यदि गणना के दौरान ध्वज को किसी बिंदु पर सेट किया गया था।

अब नामित समूहों और फ्रीस्प्रेसिंग मोड का उपयोग करके लंबे रेगेक्स को थोड़ा सा खोल दें:

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

मुझे आशा है कि आप ऊपर से सामान्य रूपरेखा को पहचानेंगे, इसलिए हमें केवल यह देखने की जरूरत है कि मैंने क्या भरा है ...।

हम समूह में अगले चरित्र को चक्र में कैद करना चाहते हैं char। हम इसे #वर्तमान वर्ण में से स्ट्रिंग को याद करके भी करते हैं cycle। अगला चरित्र पाने के लिए, हम खोज के लिए एक लुकहेड का उपयोग करते हैं #। अब हम मिलान करने की कोशिश करते हैं cycleऔर फिर अगले चरित्र का मिलान करते हैं char। यह आमतौर पर संभव होगा, जब तक charकि अंतिम चरित्र न हो p। इस स्थिति में, \k<cycle>स्ट्रिंग के शेष भाग से मेल खाएगा और इसमें कैप्चर करने के लिए कोई वर्ण नहीं बचेगा char। इसलिए इंजन बैकट्रैक करता है, बैकरेस्ट को छोड़ देता है cycleऔर rइसके बजाय पहले अक्षर से मेल खाता है ।

अब हमें चक्र में अगला चरित्र मिल गया है char, हम उस चरित्र की अगली संभावित घटना को खोजते हैं .*?\k<char>। ये ऐसे अक्षर हैं जिन्हें हम बदलना चाहते हैं, इसलिए हम prefixइसके बाद चेक लगाते हैं। ये चरण ( charचक्र में अगला ढूंढें , इसकी अगली घटना के लिए खोज करें, ध्वज सेट करें यदि उपयुक्त हो) अब बस एक के साथ दोहराया जाता है +।

यह वास्तव में चक्रीय परिणाम को खोजने के लिए है, लेकिन हमें यह भी सुनिश्चित करने की आवश्यकता है कि हम एक पर समाप्त होते हैं p। यह काफी आसान है: बस जांचें कि वर्तमान में स्ट्रिंग के अंत में charमेल खाते में संग्रहीत मूल्य । यह भी सुनिश्चित करता है कि हमारे लुकअप स्ट्रिंग का उपयोग अपूर्ण चक्र को पूरा करने के लिए नहीं किया गया है, क्योंकि हमें इस चेक के लिए अनुगामी की आवश्यकता है ।p.*\k<char>$p

— मार्टिन एंडर
स्रोत
7

अजगर 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 बाइट्स जेएफ के लिए और 5 डीएलकोस से धन्यवाद

— रूथ फ्रैंकलिन
स्रोत
क्या आप इसके rऔर nइस तरह के संयोजन को जोड़ नहीं सकते r=n='':?
— जेएफ
नियत R=r.countके रूप में तार कर रहे हैं अपरिवर्तनीय तो काम नहीं करता Rहै ''.count, तब भी जब rबदल जाता है।
— रूथ फ्रैंकलिन
3

पर्ल 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
— LukStorms
स्रोत
1
मुझे यह तरीका पसंद है। [^o]*आदि के बजाय , क्या आप .*?(गैर-लालची क्वांटिफायर) का उपयोग कर सकते हैं ?
— DLosc
महान टिप, धन्यवाद! मुझे पता नहीं था कि गैर-लालची क्वालीफायर काम आएगा।
— LukStorms
यदि आप अनुगामी स्थानों को बदलने से बचना चाहते हैं, तो आप पहले संस्करण के नकारात्मक चरित्र वर्ग के \sबजाय उपयोग कर सकते हैं \n।
— DLosc
1
रेटिना में समान दृष्टिकोण: r(.*?)o(.*?)y(.*?)g(.*?)b(.*?)p n$1n$2n$3n$4n$5n [^n\s] e(4 फाइलें, 57 बाइट्स)।
— DLosc
अरे हाँ। \ s में लाइनफीड भी शामिल है। अच्छी पकड़। और यह सुनकर अच्छा लगा कि रेटिना कम से कम पर्ल को हरा सकती है, यह उसका अपना खेल है।
— लुकस्टॉर्म
3

लुआ, 101 बाइट्स

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

रचनात्मक रूप से लुआ पैटर्न का उपयोग करता है; मुझे लगता है कि यह एक दिलचस्प तरीका है।

यह सभी गैर खाए जाने वाले पात्रों को "*" के स्थान पर बदल देता है, सभी अल्फ़ान्यूमेरिक वर्णों को "e" s के साथ बदल देता है, फिर सभी "*" s को "n" s के साथ बदल देता है।

— Trebuchette
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 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``")

फ़ायरफ़ॉक्स में परीक्षण किया गया फिडल । मुझे लगता है कि 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``
")
— DankMemes
स्रोत
Chrome तीर फ़ंक्शंस का समर्थन करता है, लेकिन स्पष्ट ...रूप से अभी तक संकेतन नहीं है।
— DLosc
2

गौक, 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"। उस प्रतिस्थापन के बाद यह सब कुछ भोजन ("ई") घोषित करता है, यह एक पूर्ण इंद्रधनुष का हिस्सा नहीं है।

यह संयोजन स्वचालित रूप से सुनिश्चित करता है, कि इस ऑपरेशन के दौरान किसी भी इंद्रधनुष को नुकसान नहीं होगा, और कोई भी गंभीर इंद्रधनुष अंत में दिखाई नहीं देगा।

— Cabbie407
स्रोत
1

CJam, 41 बाइट्स

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

ब्रूट-बल दृष्टिकोण जो सभी खाने / न खाने की विविधताओं की कोशिश करता है और सबसे लंबे, वैध हार के परिणामस्वरूप होता है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

— डेनिस
स्रोत
1

सीजेएम, 50 बाइट्स

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

इसे ऑनलाइन आज़माएं

यह कुछ अन्य सबमिशन की तुलना में थोड़ा लंबा है, लेकिन यह रैखिक जटिलता के साथ बहुत कुशल है। यह इनपुट स्ट्रिंग के माध्यम से स्कैन करता है, और एक-एक करके वर्णों से मेल खाता है।

एल्गोरिथ्म का मुख्य हिस्सा वास्तव में काफी कॉम्पैक्ट है। लगभग आधा कोड अंत में अपूर्ण चक्र को हटाने के लिए है।

— रेटो कोराडी
स्रोत
1

C90, 142-146 बाइट्स (नीचे 119, निर्भर करता है)

रेखीय समय में कुशलता से उन फलों के छोरों को खाने के लिए संचालित होता है जो एक सुंदर इंद्रधनुष का हिस्सा नहीं हो सकते। फिर, एक पोस्टप्रोसेस अंत में किसी भी आंशिक लूप को मारता है।

यहाँ चार संस्करण हैं:

  • संस्करण 1 (146 बाइट्स), साथ कॉल करें [name] [string]:
    main(int a,char**b){char*v=b[1],*s="roygbp",i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';while(k-->0)v[--i]='e';puts(v);}

  • संस्करण 2 (142 बाइट्स), इसके साथ कॉल करें [name] [string] [rainbow order]:
    main(int a,char**b){char*v=b[1],*s=b[2],i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';while(k-->0)v[--i]='e';puts(v);}
    यह आपको अपने इंद्रधनुष आदेश को किसी भी रंग के साथ परिभाषित करने की अनुमति देता है जो आप चाहते हैं कि वे लंबे समय तक नहीं हैं nया नहीं e। यह वास्तव में कोड को छोटा बनाता है!

  • संस्करण 3 (123 बाइट्स), संस्करण 1 की तरह कॉल करें:
    main(int a,char**b){char*v=b[1],*s="roygbp",i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';puts(v);}
    यह आपको जितना संभव हो सके आपके इंद्रधनुष के बारे में बताता है! अधूरे अनुगामी इंद्रधनुष ने वादा दिखाया! हमें उन्हें नहीं खाना चाहिए!

  • संस्करण 4 (119 बाइट्स), संस्करण 2 की तरह कॉल करें:
    main(int a,char**b){char*v=b[1],*s=b[2],i=0,k=0;for(;v[i];++i)if(s[k]==v[i]){++k;k%=6;v[i]='n';}else v[i]='e';puts(v);}
    संस्करण 3 के समान, लेकिन MOAR RAINBOW TYPES!

मामूली सीमा: मशीन पर हस्ताक्षर किए जाने वाले चार्ट (सामान्य मामला) होना चाहिए, और स्ट्रिंग को काफी कम होना चाहिए। \nस्पष्टता के लिए एक अनुगामी उत्पादन करता है।

संस्करण 1 केवल एक ही है जो स्पष्ट रूप से आवश्यकताओं को पारित करता है, हालांकि संस्करण 2 यकीनन है। संस्करण 3 और 4 प्रश्न की कम-सही (लेकिन अभी भी मजेदार) व्याख्या हैं।

— imallett
स्रोत
1

पायथ, 38 बाइट्स

मुझे पता है कि यह orlp के उत्तर की तुलना में काफी लंबा है, लेकिन यह एक रैखिक समय में चलता है: o)

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

इसे यहाँ आज़माएँ ।

संक्षेप में, यह कार्यक्रम रिक्त स्थान के साथ अंतिम 'पी' के बाद सभी वर्णों को बदलता है, फिर परिणामी स्ट्रिंग में प्रत्येक वर्ण पर पुनरावृत्त करता है। यदि वर्ण '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।

— सोक
स्रोत
1

हास्केल, 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))
— लीफ विलर्ट्स
स्रोत
मुझे लगता है कि आप कुछ बाइट्स को परिभाषित करके fऔर zinfix के रूप में सहेज सकते हैं : 'n'%'n'='n'आदि। इसके अलावा, की परिभाषा में कुछ कोष्ठक के gसाथ हटाया जा सकता है $।
— जरगब
1

जावास्क्रिप्ट (ईएस 6), 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;
}

सुझावों का स्वागत है!

— ETHproductions
स्रोत
0

पायथन 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])

दण्ड का बहाना करो। : पी

— Zach गेट्स
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.