একটি ফ্রুট লুপ নেকলেস ঠিক করা

Question

মনে করুন আপনি একটি নেকলেস, ব্রেসলেট, জুতো বা অন্য কোনও কিছুর জন্য ফ্রুট লুপের স্ট্র্যান্ড স্ট্রিং করছেন । এখানে 6 টি লুপের রঙ রয়েছে: আর এডি, ও রেঞ্জ, ওয়াই এলো, জি রেন , বি লু এবং পি ইউপ্রেল। আপনি চান যে আপনার স্ট্র্যান্ডটি খুব বাম দিকে লাল দিয়ে শুরু হবে এবং রংধনু ক্রমে ডানদিকে যেতে শুরু করবে, বেগুনি দিয়ে শেষ হবে। এটি হ'ল আপনি এটি তৈরি করতে চান যাতে আপনার স্ট্র্যান্ডটি roygbpকয়েকবার বারবার স্ট্রিং দ্বারা প্রতিনিধিত্ব করতে পারে (সম্ভবত 0)।

সমস্যাটি হচ্ছে, আপনি ইতিমধ্যে আপনার লুপগুলি স্ট্রিং করেছেন, কোনও নির্দিষ্ট ক্রমে নয়। কোন লুপগুলি খাওয়া উচিত এবং খাওয়া উচিত নয় যাতে আপনি প্রথম লুপ লাল এবং একেবারে শেষ লুপ বেগুনি দিয়ে বাম থেকে ডান দিকে যেতে সঠিক রামধনু চক্রের সংখ্যা সর্বাধিকতর করতে পারেন?

একটি প্রোগ্রাম বা ফাংশন লিখুন যা চরিত্রগুলির একটি স্বেচ্ছাসেবী স্ট্রিংয়ের মধ্যে নিয়ে যায় roygbpএবং eখাওয়ার nজন্য লুপের জায়গায় এবং না খাওয়ার জন্য লুপের জায়গায় একই দৈর্ঘ্যের একটি স্ট্রিং প্রিন্ট করে বা ফেরত দেয় ।

উদাহরণস্বরূপ, যদি আপনার ফ্রুট লুপ স্ট্র্যান্ডটি দেখতে লাগে

ইনপুট হবে

gorboypbgbopyroybbbogppbporyoygbpr

এবং বাম থেকে ডানে যেতে আমরা 3 টি সম্পূর্ণ roygbpরংধনু ক্রম খুঁজে পেতে পারি , তবে কিছু লুপগুলি খেয়ে ফেলতে হবে। সুতরাং আউটপুট হবে

eenenneennenennneeeeneennenennnnne

একটি নিখুঁত 3 চক্রের স্ট্র্যান্ডের ফলে:

যদি eইনপুটটিতে কোনও সম্পূর্ণ রেইনবো চক্র না থাকে তবে আউটপুটটি সমস্ত হবে এবং স্ট্র্যান্ডটি লুপ্লাসে শেষ হবে। যেমন ইনপুট proygbআউটপুট আছে eeeeee। বিপরীতে, proygbpআউটপুট আছে ennnnnn।

আপনি ধরে নিতে পারেন সমস্ত ইনপুট স্ট্র্যান্ডের কমপক্ষে একটি লুপ রয়েছে।

বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

Comments

@ ফ্যাটালাইজ হ্যাঁ রংধনু চক্রের সংখ্যা বাড়ানোর বিষয়ে অংশটি নোট করুন। অন্যথায় আপনি তাদের সব খেতে পারে।

— ক্যালভিনের

আপনি ছবি তোলার জন্য সেই ফলের লুপগুলি বাছাই এবং থ্রেড করেছেন, তাই না?

— মার্টিন এন্ডার

@ মার্টিনব্যাটনার অবশ্যই

— ক্যালভিনের শখ

প্রতিটি রেইনবো চক্রটি কি শুরু করতে হবে rবা oygbproygbprযোগ্যতা অর্জন করতে পারে ?

— orlp

হ্যাঁ, তবে তারা যদি কোনও নেকলেস বা ব্রেসলেট পরে থাকে তবে অবশ্যই এগুলি ঘোরানো যেতে পারে?

— পিটার টেলর

Answer 1

পাইথ, 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সত্য false .Dসূচকগুলির একটি স্ট্রিং এবং তালিকা গ্রহণ করে এবং সেই সূচকগুলির উপাদানগুলি মুছে দেয়। তাই .D"abcd",1 3হয় "ac"। যেহেতু .Dএকটি তালিকা প্রত্যাবর্তন করে (যা ক্ষেত্রে হওয়া উচিত নয়, পাইথের ভবিষ্যতের সংস্করণগুলিতে ঠিক হয়ে যায়), তাই আমি এটি ব্যবহার করে jk( kহয় "") একসাথে আবার স্ট্রিংয়ে যোগ দিতে পারি। :_"roygbp"kঅংশ খালি স্ট্রিং সঙ্গে একটি চক্র প্রতিটি উদাহরণের প্রতিস্থাপন করে।

যেহেতু খালি স্ট্রিংটি মিথ্যা, উপরের অনুচ্ছেদগুলি ব্যাখ্যা করে যে কীভাবে আমি কেবলমাত্র চক্র নিয়ে গঠিত স্ট্রিং পেতে খাওয়ার জন্য সূচকগুলির সবচেয়ে ছোট সেট খুঁজে পাই।

:*lz\n_\eতারপরে সূচকগুলির তালিকাটিকে একটি স্ট্রিতে পরিণত করে nnnneeennene।

Answer 2

হেক্সাগনি , 920 722 271 বাইট

ছয় বিভিন্ন ধরণের ফলের লুপ, আপনি বলছেন? হেক্সাগনিরজন্যএটিই তৈরি হয়েছিল।

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

ঠিক আছে, এটা ছিল না। হায় খোদা, আমি আমার কি করলাম ...

এই কোডটি এখন পাশের দৈর্ঘ্যের 10 একটি ষড়ভুজ (এটি 19 এ শুরু হয়েছিল)। এটি সম্ভবত আরও কিছু গল্ফ করা যেতে পারে, এমনকি 9 মাপের হতে পারে, তবে আমি মনে করি আমার কাজটি এখানে সম্পন্ন হয়েছে ... রেফারেন্সের জন্য, উত্সটিতে 175 প্রকৃত কমান্ড রয়েছে, যার অনেকগুলি সম্ভাব্য অপ্রয়োজনীয় আয়না (বা বাতিল করার জন্য যুক্ত করা হয়েছিল) একটি ক্রসিং পথ থেকে একটি আদেশ আউট)।

আপাত লৈঙ্গিকতা সত্ত্বেও কোডটি আসলে দ্বিমাত্রিক: হেক্সাগনি এটিকে একটি নিয়মিত ষড়জাগুলিতে পুনরায় সাজিয়ে তুলবে (যা বৈধ কোডও, তবে সমস্ত সাদা স্থান হেক্সাগনীতে optionচ্ছিক)। এটির সমস্ত ক্ষেত্রেই এখানে প্রকাশিত কোডটি রয়েছে ... ভাল আমি "সৌন্দর্য" বলতে চাই না:

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

ব্যাখ্যা

আমি এই গল্ফযুক্ত সংস্করণে সমস্ত সংশ্লেষিত মৃত্যুদণ্ডের পথগুলি ব্যাখ্যা করার চেষ্টাও করব না, তবে অ্যালগরিদম এবং সামগ্রিক নিয়ন্ত্রণ প্রবাহ এই অদৃশ্য সংস্করণের সাথে অভিন্ন যা আমি অ্যালগরিদম ব্যাখ্যা করার পরে সত্যই কৌতূহলের জন্য অধ্যয়ন করা সহজ হতে পারে:

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

সত্যি বলতে, প্রথম অনুচ্ছেদে আমি কেবল অর্ধেক রসিকতা করছি। আমরা ছয়টি উপাদানের একটি চক্র নিয়ে কাজ করছি তা আসলে একটি দুর্দান্ত সহায়তা। হেক্সাগনির মেমোরি মডেলটি একটি অসীম ষড়ভুজ গ্রিড যেখানে গ্রিডের প্রতিটি প্রান্তে একটি স্বাক্ষরিত স্বেচ্ছাসেবী-নির্ভুলতা পূর্ণসংখ্যা থাকে, এটি শূন্য থেকে শুরু করে।

এই প্রোগ্রামটিতে আমি যে স্মৃতি ব্যবহার করেছি তার বিন্যাসের একটি চিত্র এখানে দেওয়া হয়েছে:

বামদিকে লম্বা সোজা বিটটি 0 টি aস্বেচ্ছাসেবক আকারের টার্মিনেটেড স্ট্রিং হিসাবে ব্যবহৃত হয় যা অক্ষর আর এর সাথে যুক্ত । অন্যান্য বর্ণগুলিতে ড্যাশযুক্ত রেখাগুলি একই ধরণের কাঠামোকে উপস্থাপন করে, যার প্রত্যেকটি 60 ডিগ্রি দ্বারা আবর্তিত হয়। প্রারম্ভিক দিকে, উত্তর দিকে মুখ করে 1 টি লেবেল প্রান্তে মেমরি পয়েন্টারটি পয়েন্ট করে ।

কোডের প্রথম, রৈখিক বিট অক্ষরের প্রান্তের অভ্যন্তরীণ "তারা" সেট করে roygbpপাশাপাশি প্রাথমিক প্রান্তটি সেট করে 1, যেমন আমরা জানি যে চক্রটি কোথায় শেষ হয় / শুরু হয় (এর মধ্যে pএবং r):

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

এর পরে, আমরা 1 লেবেলযুক্ত প্রান্তে ফিরে এসেছি ।

এখন অ্যালগরিদমের সাধারণ ধারণাটি হ'ল:

1. চক্রের প্রতিটি চিঠির জন্য, এসটিডিআইএন থেকে চিঠিগুলি পড়া চালিয়ে যান এবং যদি সেগুলি বর্তমান বর্ণের চেয়ে আলাদা হয় তবে সেগুলি চিঠির সাথে যুক্ত স্ট্রিংয়ের সাথে যুক্ত করুন।
2. আমরা বর্তমানে যে চিঠিটি সন্ধান করছি তা যখন আমরা পড়ে থাকি তখন আমরা একটি eলেবেলযুক্ত প্রান্তে সঞ্চয় করি ? , কারণ যতক্ষণ চক্রটি সম্পূর্ণ না হয়, ততক্ষণ ধরে নিতে হবে যে আমাদের এই চরিত্রটিও খেতে হবে। এরপরে, আমরা রিংটির চারপাশে চক্রের পরবর্তী অক্ষরে চলে যাব।
3. এই প্রক্রিয়াটি ব্যাহত হওয়ার দুটি উপায় রয়েছে:
   • হয় আমরা চক্র সম্পন্ন করেছি। এই ক্ষেত্রে, আমরা চক্রটি দিয়ে আরও একটি দ্রুত রাউন্ড তৈরি করি, সমস্তগুলিকে eএর মধ্যে রেখে ? এর সাথে প্রান্তগুলি n, কারণ এখন আমরা সেই চক্রটি নেকলেসের কাছেই থাকতে চাই। তারপরে আমরা প্রিন্টিং কোডে চলে যাই।
   • অথবা আমরা ইওএফ (যা আমরা একটি নেতিবাচক চরিত্র কোড হিসাবে স্বীকৃত) হিট করেছি। এই ক্ষেত্রে, আমরা একটি নেতিবাচক মান লিখুন ? বর্তমান অক্ষরের প্রান্ত (যাতে আমরা সহজেই এটি উভয় eএবং পৃথক পৃথক করতে পারি n)। তারপরে প্রিন্টিং কোডে যাওয়ার আগে আমরা 1 প্রান্তটি (একটি সম্ভাব্য অসম্পূর্ণ চক্রের অবশিষ্ট অংশটি এড়াতে) অনুসন্ধান করি।
4. মুদ্রণ কোডটি আবার চক্রের মধ্য দিয়ে যায়: চক্রের প্রতিটি অক্ষরের জন্য এটি eপ্রতিটি অক্ষরের জন্য একটি মুদ্রণের সময় সঞ্চিত স্ট্রিং সাফ করে । তারপরে কী চলে ? প্রান্তটি চরিত্রের সাথে সম্পর্কিত। যদি এটি নেতিবাচক হয় তবে আমরা কেবল প্রোগ্রামটি শেষ করি। যদি এটি ইতিবাচক হয় তবে আমরা সহজেই এটি মুদ্রণ করি এবং পরবর্তী অক্ষরে চলে যাই। একবার চক্রটি শেষ করার পরে আমরা দ্বিতীয় ধাপে ফিরে যাই।

আকর্ষণীয় হতে পারে অন্য একটি জিনিস আমি কীভাবে স্বেচ্ছাচারী আকারের স্ট্রিংগুলি প্রয়োগ করেছি (কারণ এটি হেক্সাগনীতে আমি প্রথমবারের মতো সীমাহীন স্মৃতি ব্যবহার করেছি)।

কল্পনা করুন যে আমরা এমন এক পর্যায়ে রয়েছি যেখানে আমরা এখনও আর এর জন্য অক্ষরগুলি পড়ছি (যাতে আমরা চিত্রটি যেমন আছে তেমন ব্যবহার করতে পারি) এবং একটি [0] এবং একটি 1 ইতিমধ্যে অক্ষর দ্বারা পূর্ণ হয়ে গেছে (এর উত্তর-পশ্চিমের সবকিছু এখনও শূন্য রয়েছে) )। যেমন আমরা just ogপ্রান্তগুলিতে কেবল ইনপুটটির প্রথম দুটি অক্ষর পড়েছি এবং এখন একটি পড়ছি y।

নতুন চরিত্রের প্রবেশ পড়া হয় মধ্যে প্রান্ত। আমরা ব্যবহার করি ? প্রান্তটি এই অক্ষরটির সমান কিনা তা পরীক্ষা করতে r। (এখানে একটি নিফটি ট্রিকস রয়েছে: হেক্সাগনি কেবলমাত্র ইতিবাচক এবং অ-ধনাত্মক সহজেই পার্থক্য করতে পারে তাই বিয়োগের মাধ্যমে সমতা পরীক্ষা করা বিরক্তিকর এবং কমপক্ষে দুটি শাখা প্রয়োজন requires তবে সমস্ত অক্ষর একে অপরের থেকে 2 এর ফ্যাক্টরের চেয়ে কম হয়, তাই আমরা মডিউলগুলি গ্রহণ করে মানগুলি তুলনা করতে পারি, যা কেবল সমান হলে শূন্য দেবে))

কারণ yথেকে ভিন্ন r, আমরা (লেবেল বিহীন) প্রান্ত বাম সরাতে মধ্যে এবং কপি yআছে। আমরা এখন ষড়ভূজ প্রায় আরও সরানো, আরও প্রতিটি সময় চরিত্র এক প্রান্ত অনুলিপি, যতক্ষণ না আমরা আছে yপ্রান্ত বিপরীত উপর মধ্যে । তবে এখন একটি [0] এর মধ্যে ইতিমধ্যে একটি চরিত্র রয়েছে যা আমরা ওভাররাইট করতে চাই না। পরিবর্তে, আমরা yপরের ষড়্ভুজকের চারপাশে "টেনে আনি" এবং একটি 1 পরীক্ষা করি । তবে সেখানে একটি চরিত্রও রয়েছে, তাই আমরা আরও একটি ষড়ভুজ ঘুরে দেখি। এখন একটি [2] এখনও শূন্য, সুতরাং আমরা অনুলিপি করিyএটার ভিতরে. মেমরি পয়েন্টারটি এখন স্ট্রিং দিয়ে অভ্যন্তরের রিংয়ের দিকে ফিরে যায়। আমরা জানি আমরা কখন স্ট্রিংয়ের শুরুতে পৌঁছেছি, কারণ a [i] এর মধ্যে (শিরোনামহীন) প্রান্তগুলি সমস্ত শূন্য যেখানে ? ইতিবাচক।

সাধারণভাবে হেক্সাগনীতে অ-তুচ্ছ কোড লেখার জন্য এটি সম্ভবত একটি কার্যকর কৌশল হবে।

Comments

...কি দারুন. এইমাত্র.

— ইলিয়াস

এটা তোলে গলফ প্রতিদ্বন্দ্বিতা জিততে নাও হতে পারে, কিন্তু ... মানুষ, একটি ঝরঝরে সমাধান যে ...

— thanby

যেহেতু উত্সটিতে একটি বিন্দু বিন্দুগুলির দলগুলি প্রায়শই দেখা যায় তাই সম্ভবত আপনি বিন্দুগুলির রান-লেন্থ এনকোডিং বা কোডের দৈর্ঘ্যকে হ্রাস করার জন্য কোনও ভাষা যুক্ত করতে পারেন।

— mbomb007

@ mbomb007 গল্ফিং সত্যিই হেক্সাগনির তেমন একটা অগ্রাধিকার নয়। ;) তা ছাড়া, বাস্তব কোড থেকে রান-লেংথ এনকোডিংয়ের পার্থক্য করার মতো আমার কোনও অক্ষর বাকী নেই ... (এবং আমি মনে করি সত্যিই ভাল গল্ফড কোডে কোনও রান নেই এমনও নেই))

— মার্টিন ইন্ডার

Answer 3

হেক্সাগনি , 169 বাইট

আমি মার্টিন বাটনার এর উত্তরে অনুপ্রাণিত হয়েছি (এটিও তাঁর এসোলাংও) এবং আমি সিদ্ধান্ত নিয়েছিলাম যে আমি এটি ৮ ম আকারে করতে পারি (আমি নিশ্চিত যে এটি size মাপের ক্ষেত্রেও সম্ভব, তবে এটি খুব কঠিন) আমি ইতোমধ্যে চার দিন অবধি কাটিয়েছি - এই স্টপ।)

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?ইতিবাচক হয়, আমরা একটি সম্পূর্ণ বিপ্লব করেছি। একটি সম্পূর্ণ বৃত্তাকার এবং আউটপুট # eগুলি এবং nপ্রতি সেগমেন্ট 1 করে । এটি প্রতিটি #পিছনে সেট করে 0। ( eএটি একটি শিরোনামহীন প্রান্তে স্থাপন করা হয়েছে, তবে nআমরা #প্রান্তটি ভুল হিসাবে 0ব্যবহার করেছি, যা আমরা *পরে (গুণ) ব্যবহার করার জন্য সেট করেছি যা কাজ করে কারণ আমরা জানি যে %এই মুহুর্তে সমস্ত প্রান্ত শূন্য।)
• একটি অক্ষর পড়ার সময়, যদি এটি ইতিবাচক না হয় (অর্থাত্, ইওএফ), বৃত্তটি দিয়ে পিছনে যান এবং আউটপুট #+1 eগুলি আপনি যেখানে r?ইতিবাচক সেখানে ফিরে না আসা পর্যন্ত প্রস্থান করুন then

একটি সম্পূর্ণ রান করার পরে, মেমরিটি শেষে প্রায় নীচের হিসাবে দেখায়। আপনি 101(এএসসিআইআই কোড e)যুক্ত প্রান্তগুলি লক্ষ্য করবেন ; এক inপ্রান্ত হয় -1(ফাইলের শেষে); সমস্ত #প্রান্ত 0 এ রয়েছে; এবং মেমরি পয়েন্টারটি ইতিবাচক r?প্রান্তে শেষ হয় ।

Answer 4

রেটিনা , 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। তারপরে এটি সামনের দিকে তাকান , যা এখন স্ট্রিংয়ের শুরু থেকে শুরু হয় এবং একটি জটিল নিদর্শন থাকতে পারে। আমরা সেই প্যাটার্নটিতে যে চরিত্রটি প্রতিস্থাপন করতে চাই তার পরে আমরা একটি alচ্ছিক চেহারা রেখেছি , যা prefixএখানে গ্রুপের সাথে মেলে কিনা তা পরীক্ষা করে । যদি এটি হয় তবে এটি একটি খালি স্ট্রিংটি ক্যাপচার করেflagগ্রুপ। যদি এটি না হয়, কারণ এটি alচ্ছিক, এটি রেগেক্স ইঞ্জিনের অবস্থাকে মোটেই প্রভাবিত করে না এবং এড়ানো হবে। শেষ অবধি, একবার লুকের সাফল্যের সাথে মিলে \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

Answer 5

পাইথন 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 টি সংরক্ষণ করেছেন Sa

Comments

তোমাদের মধ্যে আরম্ভের একত্রিত করা যায়নি rএবং nএই মত: r=n=''?

— জেএফ

বরাদ্দ করা R=r.countযেমন স্ট্রিং হয় অপরিবর্তনীয় তাই কাজ না করে Rহয় ''.count, এমনকি যখন rপরিবর্তিত হয়।

— রুথ ফ্র্যাঙ্কলিন

Answer 6

পার্ল 5, 76 65 বাইট

এক চিমটি খাঁটি undiluted নিয়মিত প্রকাশ।
প্রথমে যা খাওয়া উচিত নয় তা খুঁজে বের করে। যা থেকে যায় তা খাওয়া যায়।

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

Comments

আমি এই পদ্ধতির পছন্দ। [^o]*ইত্যাদির পরিবর্তে , আপনি .*?(লোভী কোয়ান্টিফায়ার) ব্যবহার করতে পারেন ?

— DLosc

দুর্দান্ত টিপ, ধন্যবাদ! আমি জানিনা যে লোভী কোয়ালিফায়ার কাজে আসবে।

— LukStorms

আপনি যদি পূর্ববর্তী স্থানগুলিকে প্রতিস্থাপন করা এড়াতে চান তবে আপনি প্রথম সংস্করণের নেতিবাচক চরিত্র শ্রেণীর \sপরিবর্তে ব্যবহার করতে পারেন \n।

— DLosc

রেটিনার একই পদ্ধতি: r(.*?)o(.*?)y(.*?)g(.*?)b(.*?)p n$1n$2n$3n$4n$5n [^n\s] e(4 ফাইল, 57 বাইট)।

— DLosc

হ্যাঁ সঠিক. এর মধ্যে লাইনফিডগুলিও অন্তর্ভুক্ত রয়েছে। ভালো বল ধরা. এবং শুনতে ভাল লাগলো যে রেটিনা কমপক্ষে তার নিজের খেলায় পার্লকে পরাস্ত করতে পারে।

— LukStorms

Answer 7

লুয়া, 101 বাইট

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

সৃজনশীলভাবে লুয়া নিদর্শনগুলি ব্যবহার করে; আমি মনে করি এটি একটি আকর্ষণীয় পদ্ধতির।

এটি সমস্ত খাওয়া না হওয়া অক্ষরগুলিকে "*" এর সাথে প্রতিস্থাপন করে, সমস্ত বর্ণমালা অক্ষরকে "ই" এস দিয়ে প্রতিস্থাপন করে, তারপরে সমস্ত "*" গুলি "এন" গুলি দ্বারা প্রতিস্থাপিত করে।

Answer 8

জাভাস্ক্রিপ্ট (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``")

ফিডল ফায়ারফক্সে পরীক্ষা করেছেন। আমি শুনেছি ক্রোম এখন তীর ফাংশন সমর্থন করে তবে আমি ক্রোমে এখনও এটি পরীক্ষা করি নি।

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

Comments

ক্রোম তীর ফাংশন সমর্থন করে তবে আপাতদৃষ্টিতে ...স্বরলিপিটি এখনও দেয় নি।

— DLosc

Answer 9

gawk, 96

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

অনুসন্ধানের প্যাটার্ন "([^r]*)r([^o]*)o([^y]*)y([^g]*)g([^b]*)b([^p]*)p"এবং প্রতিস্থাপন তৈরি করে "\\1n\\2n\\3n\\4n\\5n\\6n"। প্রতিস্থাপনের পরে এটি সমস্ত খাদ্য ("ই") ঘোষণা করে, এটি একটি সম্পূর্ণ রংধনুর অংশ নয়।

এই সংমিশ্রণটি স্বয়ংক্রিয়ভাবে নিশ্চিত করে যে, এই অপারেশনের সময় কোনও রেইনবোজ ক্ষতিগ্রস্থ হবে না এবং শেষের দিকে কোনও বিচ্ছিন্ন রংধনু প্রদর্শিত হবে না।

Answer 10

পাইথ, 42 বাইট

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

অনলাইনে চেষ্টা করুন: বিক্ষোভ

Answer 11

সিজেম, 41 বাইট

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

ব্রুট-ফোর্স পদ্ধতির যা সমস্ত খাওয়ার / না-খাওয়ার বিভিন্নতার চেষ্টা করে এবং দীর্ঘতম, বৈধ নেকলেসের ফলাফল হিসাবে একটি নির্বাচন করে।

সিজেএম ইন্টারপ্রেটারে এটি অনলাইনে চেষ্টা করুন ।

Answer 12

সিজেম, 50 বাইট

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

এটি অনলাইনে চেষ্টা করুন

এটি অন্যান্য জমাগুলির তুলনায় কিছুটা দীর্ঘ, তবে লিনিয়ার জটিলতার সাথে এটি খুব দক্ষ। এটি ইনপুট স্ট্রিংয়ের মাধ্যমে স্ক্যান করে এবং একে একে অক্ষরের সাথে মেলে।

অ্যালগরিদমের মূল অংশটি আসলে মোটামুটি কমপ্যাক্ট। কোডের প্রায় অর্ধেকটি শেষে অসম্পূর্ণ চক্রটি সরিয়ে ফেলার জন্য।

Answer 13

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 হিসাবে একই, তবে মোয়ার রেইনবোর ধরণগুলি!

গৌণ সীমাবদ্ধতা: মেশিনে স্বাক্ষর করা অক্ষর থাকতে হবে (সাধারণ ক্ষেত্রে), এবং স্ট্রিং অবশ্যই মোটামুটি সংক্ষিপ্ত হতে হবে। \nস্বচ্ছতার জন্য একটি পিছনে আউটপুট দেয় ।

সংস্করণ 1 হ'ল একমাত্র যা প্রয়োজনীয়তাগুলি স্পষ্টভাবে পাস করে, যদিও সংস্করণ 2 তর্কযোগ্য। সংস্করণ 3 এবং 4 কম প্রশ্নের সঠিক (তবে এখনও মজাদার) ব্যাখ্যা।

Answer 14

পাইথ, 38 বাইট

আমি জানি এটি orlp এর উত্তরের চেয়ে উল্লেখযোগ্যভাবে দীর্ঘ, তবে এটি লিনিয়ার সময়ে চলে: o)

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

এখানে চেষ্টা করে দেখুন ।

সংক্ষেপে, এই প্রোগ্রামটি চূড়ান্ত 'পি' এর পরে সমস্ত অক্ষরকে স্পেস দিয়ে প্রতিস্থাপন করে, তারপরে ফলাফলের স্ট্রিংয়ের প্রতিটি অক্ষরের উপরে পুনরাবৃত্তি করে। চরিত্রটি যদি 'রায়জিবিপি' অনুক্রমের পরের হয় তবে 'এন' মুদ্রণ করুন, অন্যথায় 'ই' মুদ্রণ করুন।

                                          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, যখন ইনপুটটি 'পি' দিয়ে শেষ হয়।

Answer 15

হাস্কেল, 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))

Comments

আমি মনে করি আপনি সংজ্ঞায়িত করে fএবং zইনফিক্স হিসাবে কিছু বাইট সংরক্ষণ করতে পারেন : 'n'%'n'='n'এছাড়াও, এর সংজ্ঞাতে কিছু বন্ধনীর gসাহায্যে মুছে ফেলা যেতে পারে $।

— Zgarb

Answer 16

জাভাস্ক্রিপ্ট (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;
}

পরামর্শ স্বাগত!

Answer 17

পাইথন 2, 254 বাইট

Loops!

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: P