আমি কি আমার সমস্ত কর্ড এবং অ্যাডাপ্টারকে এক সাথে স্ট্রিং করতে পারি?


30

মনে করুন একদিন আপনি আপনার অব্যবহৃত কম্পিউটার কর্ড এবং অ্যাডাপ্টারগুলির বড় বাক্সটি (ইউএসবি থেকে ইউএসবি মিনি, ভিজিএ থেকে ডিভিআই ইত্যাদি) খনন করছেন। জঞ্জাল দড়িগুলি সর্বত্র বেশ জগাখিচুড়ি করছে এবং আপনি ভাবছেন যে আপনি যদি সমস্ত কর্ডগুলিকে এক দীর্ঘ স্ট্র্যান্ডের সাথে সংযুক্ত করে কিছু সহজ করে তুলতে পারেন, এবং তারপরে কেবল এটিকে ঘুরিয়ে তোলেন।

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

অল-কর্ড স্ট্র্যান্ডের প্রান্তে কী ধরণের প্লাগ রয়েছে সে সম্পর্কে আপনার চিন্তা নেই। লুপ তৈরি করতে তাদের একে অপরের সাথে প্লাগ ইন করার দরকার নেই। আপনি কেবলমাত্র জানতে চান যে সমস্ত কর্ড স্ট্র্যান্ড তৈরি করা সম্ভব এবং এটি যদি হয় তবে কীভাবে এটি করা যায়।

চ্যালেঞ্জ

এমন একটি প্রোগ্রাম বা ফাংশন লিখুন যা মাল্টলাইন স্ট্রিংয়ে নেয় যেখানে প্রতিটি লাইন আপনার নিজের একটি কর্ডকে চিত্রিত করে। -উভয় প্রান্তে একটি প্লাগ সহ একটি কর্ড এক বা একাধিক ড্যাশ ( ) দিয়ে গঠিত। একটি প্লাগ সর্বদা 8 টি অক্ষরের একটি ()[]{}<>

সুতরাং এটি কিছু বৈধ কর্ড:

>->
(--[
}-{
<-----]
(---)

তবে এগুলি নয়:

-->
(--
)--
[{
---

কর্ডগুলি সংযোগ করার সময়, ঠিক একই বন্ধনী ধরণের প্লাগগুলি একসাথে সংযুক্ত হতে পারে।

সুতরাং এগুলি কিছু কার্যকর কর্ড সংযোগগুলি:

...---((---...
...---))---...
...---]]---...
...---{{---...
...---<<---...

এবং এগুলি অবৈধ:

...---()---...
...---)(---...
...---{]---...
...---{[---...
...---><---...
...--->)---...

যদি ইনপুটটির সমস্ত কর্ডগুলি একটি দীর্ঘ স্ট্র্যান্ডে পুনরায় সাজানো এবং সংযুক্ত করা যায়, তবে সেই স্ট্র্যান্ডটি এক লাইনে স্টাডআউটে আউটপুট দেয় (optionচ্ছিক ট্রেলিং নিউলাইন সহ)। যখন একাধিক সমাধান হয় আপনি আউটপুট থেকে তাদের যে কোনও একটি চয়ন করতে পারেন। যদি একটি একক স্ট্র্যান্ড তৈরি করা সম্ভব না হয়, তবে আউটপুট কিছুই না (বা emptyচ্ছিক ট্রেইলিং নতুন লাইনের সাথে একটি খালি স্ট্রিং আউটপুট)।


উদাহরণস্বরূপ, যদি ইনপুট হয়

[-->
{---]
>----{

আউটপুট হতে পারে

[-->>----{{---]

যেখানে সমস্ত কর্ড একসাথে স্ট্রিং করা হয়।

তবে যদি ইনপুট হত

[-->
{---]

কর্ডগুলি সংযুক্ত করা যাবে না যাতে কোনও আউটপুট থাকবে না।


নোট করুন যে সংযোগগুলি তৈরি করতে কর্ডগুলি প্রয়োজনীয় পরিমাণে প্রায় ফ্লিপ করা যেতে পারে। যেমন [-->এবং <--]কার্যকরভাবে একই কর্ড কারণ তারা একই ধরণের সংযোগ তৈরি করতে পারে। কিছু আউটপুট ইনপুট কর্ডগুলি ফ্লিপ করার উপর নির্ভর করে।


উদাহরণ স্বরূপ

(-[
}--]

আউটপুট থাকতে পারে

(-[[--{

যেখানে দ্বিতীয় কর্ডটি উল্টানো হয়, বা

}--]]-)

যেখানে প্রথম কর্ড উল্টানো হয়

(দ্রষ্টব্য যে সাধারণভাবে পুরো আউটপুট উল্টানো বৈধ হয় কারণ এটি প্রাথমিকভাবে প্রতিটি কর্ড পৃথকভাবে উল্টানোর মতোই as)


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

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

পরীক্ষার মামলা

আউটপুট সহ কেস:

[-->
{---]
>----{
gives
[-->>----{{---]
or
[---}}----<<--]

(-[
}--]
gives
(-[[--{
or
}--]]-)

(-)
gives
(-)

[--{
gives
[--{
or
}--]

[-]
]-[
gives
[-]]-[
or
]-[[-]

[----->
)------------[
{--<
}---)
could give
[----->>--}}---))------------[
or
>--}}---))------------[[----->
or
}---))------------[[----->>--}
or
{--<<-----]]------------((---{
etc.

>-->
>->
>--->
could give
>-->>->>--->
or
>--->>-->>->
or
>->>-->>--->
or
<--<<---<<-<
etc.

(-]
]->
>-}
}-)
)-[
[-<
<-{
{-(
could give
(-]]->>-}}-))-[[-<<-{{-(
or
{-((-]]->>-}}-))-[[-<<-{
or
<-{{-((-]]->>-}}-))-[[->
etc.

আউটপুট ছাড়া কেস:

[-->
{---]

[-]
[-]

(-]
]->
}-)

>->
>-->
]---]

[-------------------]
]-------------------[
[-----------------]
[-----------------]

{--[
]--}

6
অব্যবহৃত কম্পিউটার কর্ড এবং অ্যাডাপ্টারের বড় বাক্স যা আমাকে আরও ভাল অনুভব করে - আমি একমাত্র নই। আসলে আমার কাছে এই বাক্সগুলির বেশ কয়েকটি রয়েছে।
ডিজিটাল ট্রমা

কিন্তু যদি আপনি নিজের মধ্যে একটি কর্ড প্লাগ করেন?
anoKsquirrel

সকলের গ্যারান্টিযুক্ত কর্ডগুলি কী বৈধ?
আর কাপ,

@ আর.ক্যাপ হ্যাঁ তারা হ'ল
ক্যালভিনের

উত্তর:


10

অপঠনযোগ্য , 3924 বাইট

আমি প্রথমবারের মতো অপঠনযোগ্যতে কিছুটা কল-স্ট্যাকের মতো কাঠামো প্রয়োগ করেছি।

(এর প্রথম সংস্করণটি 5300 বাইটেরও বেশি ছিল, কেবল আমি এটি কতটা গল্ফ দিয়েছিলাম তা ধারণা দেওয়ার জন্য))

' "" "" "'" " '" "" "" "'" "" "" " '" ""' "" ' ""' "" ' ""' "" ' ""' "" "" "" " '" ""' "" "" "" ' ""' "" " '" "" "" "" "" "'" "" " '" "" "'" "" " '" " "" "" ' ""' "" ' ""' "" ' ""' "" ' "" "" "" "'" "" ' "" "" "'" "" "" """" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" " " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' """ "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" " "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" ' ""' "" ' "" "" "" "'" "" ' "" "" """ "" " '" "" "" "" "'" "" ' "" "'" "" " '" "" "" "'" " '" "'" " '" "'" "" ' "" "" "" "'" " '" "'" "" "" "" ' "" "'" "" "" " '" "'" "" "" "" ' "" "'" " '" "" "" ""' "" ' "" "" "" "'" "" ' "" "" "'" "" "" " '" "'" "" ' "" """ "" ' "" "" "" "'" "" ' "" ""' "" "" "" ' ""' "" ' ""' "" "" "" " '" ""' "" "" "" "" " '" "" "" "'" " '" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' """ "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" " "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" """ "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" " ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" """ ' ""' "" " '" "" "" "" ""' "" "" "" ' ""' "" " '" "" "" "" "'" "" "" "" ' ""' "" " '" "" "" "" ""' "" "" "" ' ""' "" " '" "" "" "" "'" "" "" "" " ' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' """" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" " " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" ""' "" ' "" "'" "" "" "" "" ' "" "" ""' "" ' "" "'""" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" " "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" """ "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" " ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" " '" "'" ""' "" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" " ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""'"" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" " "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" "" "" "" "'" "" "" "" " '" """ "" "" ' "" "" "" "'" " '" ""' "" "" "" "" ' "" "" "" ""' "" "" "" " '" " "" "" " '" ""' "" ' ""' "" "" "" " '" "" "" ""' "" " '" "'" " '" "" "" ""' "" "" "" " '" ""' "" ' ""' "" "" "" " '" "" "" ""' "" " '" "" "" "" "'"" "" "" " '" "" "" ""' "" " '" "'" "" "" "" ' "" "" "" "'" "" ' "" "" ""' "" " '" "'" " '" "" "" ""' "" " '" "" "" "'" " '" "'" " '" "" "" ""' "" " ' "" "" "" " '" "" "" "" "'" "" "" "" ' "" "'" "" "" "" "" " '" "" "" "'"" "" "" " '" ""' "" "" "" "" ' "" "" ""' "" ' ""' "" ' "" "'" "" "" " '" " "" "" ' ""' "" " '" "'" "" "" "" ' "" "'" "" ' "" "" "'" "" "" "" ' ""' "" ' ""' "" " '" "" "'" "" " '" "" "" "'" " '" "'" "" ' "" "" ""' "" " '" "" '" "" ""' "" "" "" " '" "" "" "'" "" ' ""' "" ' ""' "" ' ""' "" "" "" " ' "" " '" "" "" "" ""' "" "" "" " '" "'" " '" "'" " '" "" "" ""' "" " '" ""' "" "" "" ' ""' "" ' "" "'" "" "" "" " '" ""' "" "" "" "" " '" "" "" ""'"" ' ""' "" " '" "" "" "'" " '" "'" " '" ""' "" "" "" "" ' "" "'" "" " '" " "" ' "" "" ""' "" " '" "" "" ""' "" "" "" " '" "'" "" ' "" "" "'" "" "" "" ' "" "" ""' "" " '" "'" " '" "'" " '" "'" "" "" "" ' "" "'" "" "" "" ""' "" "" "" "'" " '" "'" " '" "'" "" "" "" ' "" "'" "" ' "" "" "" "" "'" "" "" "" "" ' "" "" "" "'" "" "" "" " '" "" "" ""' "" ' "" "'" "" " '" "" "'" "" "" " '" "" "" "" "'" "" ' "" "" "" "'" " '" "'" "" "" "" ' "" "" """" ' "" "" "" "'" " '" ""' "" "" "" ' ""' "" ' "" "'" " '" "" "" ""' "" "" "" " '" ""' "" "" "" "" " '" "" ""' "" "" "" ' ""' "" ' "" "'" "" "" "" " ' "" "" "" " '" "'" " '" ""' "" "" "" ' "" "" "" ""' "" " '" "" "" "" "'"" "" "" " '" "" "" "" "'" "" ' "" "" "" ""' "" " '" ""' "" " '" "" "" "'" "" ' "" "" "" ""' "" "" "" ' ""' "" ' "" "'" "" "" " '" "" "" ""' "" ' "" " ' "" "" "" "'" "" ' "" "'" "" "" "" "" ' "" "" "" "'" " '" "'" "" ' """" "" ' "" "" ""' "" ' "" "'" " '" "" "" ""' "" ' "" "'" "" "" " '" "" "" " " '" ""' "" "" "" ' "" "" "" "" "'" "" "" "" ' "" "" "" ""' "" "" "" " '" " " '" "'" " '" "'" " '" "'" "" "" "" ' "" "'" "" "" "" " '" "" "" "" "'"" "" "" "" ' "" "" "" ""' "" "" "" "" ' "" "" "" "'" "" ' "" "'" "" "" "" "" ' "" "" ""' "" " '" "" "" ""' "" "" "" ' ""' "" " '" "" "" "" "'" "" "" "" ' ""' "" " '" "" "" "'" " '" "'" " '" "'" "" "" "" ' "" "'" "" "" "' "" "" "" "" "'" "" "" "" ' ""' "" ' ""' "" "" "" " '" ""' "" ' ""' "" ' " " '" "'" " '" "'" " '" "'" "" "" "" ' "" "'" "" "" "" " '" "" "" ""' "" " ' "" "" "" "" ' "" "'" "" "" " '" "'" " '" "'" "" ' "" "" "" ""' "" " '" """ "" "" " '" "" "" ""' "" " '" "" ""' "" "" "" "" ' "" "" "" "'" "" "" " ' "" " '" "'" "" "" "" ' "" "'" "" " '" "" "'" ' "" "" "" "'" "" "" "" ' "" " "" "" ' "" "'" "" "" ' ""' "" "" "" ' ""' "" "" "" " '" "" "" ""' "" "' "" "" "" ""' "" "" "" " '" "'" "" "" "" ' "" "" "" "'" "" ' "'" "" "" "" ' ""' "" ' ""' "" ' "" "'" ' "" "" "" "'" " '" "'" "" "" "" ' "" "" "" "'" "" ' "" "' "" "" "" "'" " '" "'" " '" "'" "" ' "'" "" "" "" ' ""' "" ' "" "" "" "'" "" "" "" ' "" "'" ""' "" "" "" "'" " '" "'" " '" "'" "" ' "'" "" "" "" ' ""' "" ' "" "" "" "'" "" "" "" ' "" "'" ""

ব্যাখ্যা

এই উদাহরণ ইনপুট বিবেচনা করুন:

>--{
[---}

মৃত্যুদণ্ড কার্যকর করার বেশিরভাগ সময় টেপটি নিম্নরূপ দেওয়া হয়:

  • 0 থেকে 5 ঘরগুলি বিভিন্ন ভেরিয়েবলের জন্য অবস্থান।

  • 6 সেলের পরে আপনার বাক্সে কেবলগুলির সেট সম্পর্কে সমস্ত তথ্য রয়েছে:

    টেপ বিন্যাস উদাহরণ

  • "শূন্য টার্মিনেটর" এর পরে অবশিষ্ট কক্ষগুলিতে স্ট্যাক থাকে। প্রতিটি "স্ট্যাকফ্রেম" হ'ল একটি একক সেল যা তারের প্রথম কক্ষকে নির্দেশ করে ("স্টার্ট প্লাগ" সেল)। উপরের উদাহরণে, যখন প্রোগ্রামটি সিদ্ধান্ত নিয়েছে এটি সমাধান খুঁজে পেয়েছে, তখন স্ট্যাকটিতে 6 ( >--{প্রথম তারের উল্লেখ করা) এবং 21 (উল্লেখ করা হবে {---], দ্বিতীয় কেবলটির আয়না) থাকবে।

প্রোগ্রামটি তিনটি প্রধান পর্যায়ে এগিয়ে যায়:

  1. পুরো ইনপুটটি পড়ুন এবং সমস্ত মিররযুক্ত তারগুলি সহ উপরের কাঠামোটি তৈরি করুন।
  2. সমস্ত সংমিশ্রণ চেষ্টা করে দেখুন (তবে কোনও সমাধান পাওয়া গেলে বন্ধ করুন)।
  3. যদি কোনও সমাধান পাওয়া যায়, তবে এটি আউটপুট করুন।

প্রথম পর্যায়ে (ইনপুট পড়ুন এবং তারের কাঠামো উত্পন্ন করুন) কেবলমাত্র কক্ষ # 1 (যা আমি কল করব p) এবং # 2 (যা আমি কল করব ch) ব্যবহার করে এবং কিছুক্ষণের মধ্যে লুপটি নিম্নরূপে পরিচালনা করে:

  • শর্ত থাকাকালীন: p6 দ্বারা বৃদ্ধি , পরবর্তী অক্ষরটি (প্লাগ শুরু করুন) ঘরে প্রবেশ করুন *pএবং পরীক্ষা করুন যে এটি -1(ইওএফ) নয়।

  • পরবর্তী অক্ষরগুলি পড়ুন *(p+2)এবং এগুলিতে গণনা করুন *(p+1), যতক্ষণ না আমরা -(হাইফেন) ব্যতীত অন্য কোনও কিছুর মুখোমুখি না হই । সেই সময়ে, হাইফেনের *(p+1)সংখ্যা (কেবলের দৈর্ঘ্য) এবং *(p+2)সর্বশেষ নন হাইফেন অক্ষর (শেষ প্লাগ) থাকবে। (আমরা হাইফেন অক্ষরগুলি কক্ষে # 5 ঘরেও অনুলিপি করি যাতে আউটপুট পর্যায়ে আমরা পরে এই ASCII কোডটি অ্যাক্সেস করতে পারি))

  • কিছুক্ষণ লুপের মধ্যে, আয়না প্লাগটি সন্ধান করুন এবং এটিকে সংরক্ষণ করুন *(p+3), তারপরে শূন্য pনা হওয়া পর্যন্ত 2 দ্বারা বৃদ্ধি করুন *p। লুপটি সিউডোকোডে এর মতো দেখাচ্ছে:

    while (ch = *p) {
        *(p+3) = (ch -= 40) ? (ch -= 1) ? (ch -= 19) ? (ch -= 31) ? ch-32 ? *p-2 : *p+2 : *p+2 : *p+2 : *p-1 : *p+1
        p += 2
    }
    
  • এই লুপটি সর্বদা দুটি পুনরাবৃত্তি (স্টার্ট প্লাগ এবং শেষ প্লাগ) সম্পাদন করবে এবং ফলাফলগুলি তারের চতুর্থ এবং ষষ্ঠ কক্ষে ফলাফল সংরক্ষণ করবে। এখন, আপনি যদি মনোযোগ দিয়েছেন, আপনি বুঝতে পারবেন যে ষষ্ঠ ঘরটি প্রকৃতপক্ষে মিরর করা শেষ প্লাগের জন্য সঠিক অবস্থান, তবে মিরর করা স্টার্ট প্লাগটি "বুলিয়ান নির্দেশকারী আসল কেবল" লেবেলযুক্ত ঘরে রয়েছে। এটি ঠিক আছে কারণ আমাদের কেবল এই ঘরটি একটি শূন্য-মান হতে হবে।

  • যেহেতু pসবেমাত্র মোট 4 টি বাড়ানো হয়েছে, এখন এটি "বুলিয়ান ইন্ডিকেটিং ক্যাবল ব্যবহার হচ্ছে" লেবেলযুক্ত সেলটির দিকে ইঙ্গিত করছে। সেট *(p+3)মূল্য *(p-1)। এটি মিররড স্টার্ট প্লাগটিকে সঠিক জায়গায় রাখে।

  • আরও একটি চরিত্র পড়ুন (এবং বাতিল করুন) (যা আমরা একটি নতুন লাইন হওয়ার প্রত্যাশা করি, তবে প্রোগ্রামটি এটি পরীক্ষা করে না)।

pশুরুতে 0 থেকে শুরু হয় তবে সময়ের শর্তের মধ্যে 6 দ্বারা বাড়ানো হয়, এইভাবে তারের ডেটা # 6 সেল থেকে শুরু হয়। pলুপের দেহের অভ্যন্তরে 4 দ্বারা বৃদ্ধি করা হয় এবং প্রতিটি কেবলের জন্য মোট 10 হয়, যা আমাদের প্রয়োজন ঠিক এটি।

দ্বিতীয় পর্যায়ের সময়, কোষ # 0-4 ভেরিয়েবল দ্বারা দখল করা হয় যে, আমি ডাকবো a, p, q, m, এবং notdone। (5 নম্বরের সেলটি হাইফেনের ASCII কোডটি এখনও মনে রাখে))

দ্বিতীয় ধাপের জন্য প্রস্তুত হওয়ার জন্য, আমাদের *p0-এ ফিরে যেতে হবে ("শূন্য টার্মিনেটর" নামে চিহ্নিত সেল) যাতে এটি কেবলের তালিকার জন্য টার্মিনেটর হিসাবে কাজ করতে পারে; আমরা q(যা আমাদের স্ট্যাক পয়েন্টার) সেটও করেছি ( p+1অর্থাত্ "জিরো টার্মিনেটর" এর পরে একটি ঘর; এখানে স্ট্যাক শুরু হয়); *q1 এ (স্ট্যাকের প্রথম আইটেম; কেন 1 পরে স্পষ্ট হবে); এবং notdone1 টি। এই সমস্ত একক বিবৃতিতে সম্পন্ন করা হয়:

*p = (notdone = *(q = p+1) = 1)-1

দ্বিতীয় স্তরটিও একটি লুপ is এর অবস্থা সহজভাবে notdone। লুপ চলাকালীন প্রতিটি পুনরুক্তিতে নিম্নলিখিত চারটি জিনিসের যে কোনও একটি ঘটতে পারে:

  1. আমরা দেখতে পাচ্ছি যে সমস্ত তারগুলি "ব্যবহৃত" হিসাবে চিহ্নিত রয়েছে। এর অর্থ আমরা একটি সমাধান খুঁজে পেয়েছি (যা বর্তমান স্ট্যাকের সামগ্রী দ্বারা প্রতিনিধিত্ব করা হয়)।
  2. আমরা *qঅন্য যোগ্য তারে (যা আমরা অবিলম্বে এটির দুটি ব্যবহারের সাথে সাথে "ব্যবহৃত হিসাবে চিহ্নিত" করব) এবং তারপরে পুনরাবৃত্তি করতে পারি (অর্থাত্ একটি নতুন স্ট্যাকফ্রেম তৈরি করব)।
  3. আমরা অগ্রসর হতে পারি না *qকারণ আর কোনও যোগ্য তারের অস্তিত্ব নেই, তাই আমাদের ব্যাকট্র্যাক করতে হবে (একটি স্ট্যাকফ্রেম সরিয়ে পূর্ববর্তী কেবল এবং এর যমজটিকে আর "ব্যবহারে" চিহ্নিত করা হবে না)।
  4. আমরা অগ্রসর হতে পারছি না *qকারণ আরও উপযুক্ত তারের উপস্থিতি নেই এবং আমরা ব্যাকট্র্যাক করতে পারি না কারণ আমরা স্ট্যাকের নীচে পৌঁছেছি। এর অর্থ কোনও সমাধান নেই।

লুপ বডি এই ক্রমে এই চারটি শর্তের প্রতিটি জন্য পরীক্ষা করে। বিশদটি এখানে:

  1. সেট করুন mএবং p1 এবং কিছুক্ষণের মধ্যে লুপ, p5 দ্বারা ইনক্রিমেন্ট (এইভাবে তারগুলির মাধ্যমে পুনরাবৃত্তি করা) এবং *(p+4)("ব্যবহারে") সেট করা আছে কিনা তা পরীক্ষা করুন। যদি এটি না mহয় তবে 0 এ সেট করুন that লুপটির শেষে, mআমাদেরটি জানান যে সমস্ত তারগুলি ব্যবহৃত হয়। যদি তা notdoneহয় তবে মূল লুপটি শেষ করতে 0 তে সেট করুন । অন্যথায়, নীচের পদক্ষেপ 2 এ চালিয়ে যান।

  2. সেট pকরুন *q(স্ট্যাকের শীর্ষে কেবলটি) এবং কিছুক্ষণের মধ্যে উপরের মতো লুপে, pকেবলগুলি মাধ্যমে পুনরাবৃত্তি করতে 5 দ্বারা বাড়ানো। শুরু করা *qনিশ্চিত করে আমরা কেবল তাদেরই বিবেচনা করব যা আমরা ইতিমধ্যে বিবেচনা করি নি; তবে, মনে রাখবেন যে নতুন স্ট্যাকফ্রেমের প্রাথমিক মানটি 1, সুতরাং প্রথম কেবলটি সেল 6 এর একটি, যা প্রকৃতপক্ষে প্রথম কেবল।

    প্রতিটি তারের জন্য আমাদের এটি পরীক্ষা *(p+4)করে নেওয়া দরকার যে এটি ইতিমধ্যে ব্যবহারে নেই এবং তাও হয় *(q-1) শূন্য (যার অর্থ আমরা স্ট্যাকের নীচে আছি, সুতরাং স্টার্ট প্লাগটিতে কোনও বাধা নেই), বা *p (তারের শুরু) প্লাগ) সমান *(*(q-1)+2)(স্ট্যাকের ঠিক নীচে কেবলের শেষ প্লাগ)। আমরা সামনের aজন্য *(*(q-1)+2)এবং সেটিং সেট mকরে *p+1এবং তারপরে কিছুক্ষণ লুপের মধ্যে উভয় হ্রাস করে check +1কারণ mএই শর্তে যখন ভিতরে decremented হয় তাই এটি একাধিকবার decremented হয় aaএর শেষে যদি শূন্য হয় তবে দুটি প্লাগ সমান।

    সুতরাং, যদি হয় *(q-1)শূন্য হয় বা সমতার তুলনা সফল হয়, কেবল তার যোগ্য। নতুনটির সাথে স্ট্যাকের শীর্ষে কেবলটি প্রতিস্থাপন *qকরতে সেট করুন p; mএকই সাথে সেট করুন যে আমরা একটি ম্যাচিং কেবলটি পেয়েছি; এবং তারপরে হ্রাস p। এই হ্রাসটি যখন লুপটি (তারগুলি দিয়ে পুনরুক্তি করা) তাড়াতাড়ি অবসান ঘটাতে একটি কৌশলটি; এটি pআবার 5 বৃদ্ধি পাবে , এইভাবে এই কেবলটির "ব্যবহারের" পতাকাযুক্ত সেলটিতে নিয়ে যাবে এবং আমরা জানি এটি শূন্য কারণ আমরা কেবল এটি পরীক্ষা করেছি। অবশেষে, লুপের সময় কেবল-পুনরাবৃত্ত হওয়ার পরে, আমরা পরীক্ষা করি যে mশূন্য নয় কিনা । যদি তা হয় তবে আমরা একটি মিলে যাওয়া তারের সন্ধান পেয়েছি এবং pসেই ম্যাচিং কেবলটির জন্য "ব্যবহারযোগ্য" পতাকাটিতে ইঙ্গিত করছি। এটি হিসাবে ব্যবহৃত হিসাবে চিহ্নিত করতে এটি 1 এ সেট করুন। সেটও করেছেন*(*(p-1) ? p+5 : p-5)1 টি ব্যবহার হিসাবে এটি তার যমজ চিহ্নিত। শেষ অবধি , ইনক্রিমেন্ট qএবং *qনতুন স্ট্যাকফ্রেম তৈরি করতে নতুনকে 1 এ সেট করুন ।

  3. যদি, লুপের সময় কেবল-পুনরাবৃত্তি হওয়ার পরে, আমরা mশূন্য হতে দেখি, আর কোনও মিলের কেবল নেই, সুতরাং আমাদের ব্যাকট্র্যাক করা দরকার। qস্ট্যাকের নিচে নামার হ্রাস এবং এটি এখনও কেবল তার দিকে নির্দেশ করছে কিনা তা পরীক্ষা করুন (একটি শূন্য নয়)। যদি তা হয় তবে সেই তারটি এবং এর যমজকে আর ব্যবহারযোগ্য নয় হিসাবে চিহ্নিত করুন। (আমরা মান সংরক্ষণ *qমধ্যে pএই মত প্রকাশের কোডে খাটো করতে।)

  4. যদি, হ্রাসের পরে q, আমরা দেখতে পেলাম যে এটি একটি শূন্য মানকে নির্দেশ করে, তবে এটি হ'ল "শূন্য টার্মিনেটর", যার অর্থ আমরা স্ট্যাকটি আওতাভুক্ত করেছি। আমরা সিদ্ধান্তে পৌঁছেছি যে এর কোনও সমাধান নেই। notdoneমূল লুপটি শেষ করতে আমরা 0 এ সেট করেছি ।

তৃতীয় স্তরটি আউটপুট পর্যায়। দুটি জিনিস ঘটতে পারে:

  • মূল লুপটি এমন একটি সমাধান পেয়েছে যা আমাদের আউটপুট করতে হবে বা
  • মূল লুপটি সিদ্ধান্ত নিয়েছে যে কোনও সমাধান নেই এবং আমরা কিছুই আউটপুট পাই না।

সুবিধাজনকভাবে, যদি কোনও সমাধান নাp পাওয়া যায় তবে শূন্য হয় কারণ আমরা এটি *qশূন্যের জন্য যাচাই করার আগে এটির মান নির্ধারণ করেছি ; এবং যদি কোনও সমাধান ছিল , p"জিরো টার্মিনেটর" এর দিকে ইঙ্গিত করছে কারণ এটি কেবল তারগুলি দিয়ে পুনরাবৃত্তি করেছে, তাই আমরা এখন pস্ট্যাকের মাধ্যমে পুনরাবৃত্তি করতে ব্যবহার করতে পারি । সুতরাং কেবল স্ট্যাকের মাধ্যমে পুনরাবৃত্তি করুন, প্রতিটি কেবলের জন্য স্টার্ট প্লাগ ( *(*p)), হাইফেনগুলি ( *(*p+1)কিছুক্ষণের লুপে হ্রাস করে; এবং সেল # 5 এ সঞ্চিত হাইফেন ASCII কোড ব্যবহার করে) এবং শেষ প্লাগ ( *(*p+2)) ব্যবহার করুন। কখনও মনে করবেন না যে এটি তারের দৈর্ঘ্যের তথ্যকে ধ্বংস করে দেয়; আমাদের আর দরকার নেই।


3

সিজেম, 67

qN%e!{_,2,m*\f{.{_{"()[]{}<>--"_@#1^=}%W%?}_2ew{~\W=#}%0-{;}&}~}%1<

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

দ্রষ্টব্য: লিঙ্কটি রিপোজিটরির সর্বশেষ কোডটি ব্যবহার করছে (ধাক্কা দিলেও এখনও মুক্তি পায় নি), কারণ এতে একটি বাগ ফিক্স রয়েছে।

ব্যাখ্যা:

প্রোগ্রামটি সহজভাবে সমস্ত কর্ডগুলির সমস্ত অনুমতি এবং সমস্ত দিকনির্দেশ চেষ্টা করে।

qN%             read the input and split into lines
e!              generate all permutations
{…}%            map each permutation of cords
  _,            get the number of cords (n)
  2,m*          generate all patterns of n bits (cartesian power of [0 1])
  \f{…}         for each bit pattern and the cord permutation
    .{…}        apply the block to each bit and cord (flipping cords for bit 0)
      _         duplicate the cord
      {…}%      map each character of the cord
        "…"_    push the string of all the plugs (and 2 dashes) and duplicate it
        @#      get the index of the character in the string
        1^      XOR with 1
        =       get the character at this new index (plugs get toggled)
      W%        reverse the cord
                 the stack now has the bit, the original cord and the flipped cord
      ?         if the bit is 1, use the original cord, else use the flipped one
    _           duplicate the array of cords
    2ew         get all pairs of adjacent cords
    {…}%        map each pair of cords
      ~\        dump the 2 cords on the stack and swap them
      W=        get the right plug of the first cord
      #         find its position in the second cord (if 0, we have a match)
    0-          remove all the zeros
    {…}&        if the array is not empty (i.e. we have a mismatch)
      ;         pop the array of cords
  ~             dump all the results for this permutation on the stack
                 (to avoid nested arrays)
1<              get the first result (if any) from the array of all results

এটি ঠিক কীভাবে কাজ করে তার একটি ব্যাখ্যা?
টিমউই

@ টিমভি ঠিক আছে, আমি এটি আরও কিছুটা
গল্ফ দিয়েছি

ইনপুটটির জন্য কোনও আউটপুট উত্পাদন না করায় এই সমাধানটি অবৈধ (-] ]-> >-} }-) )-[ [-< <-{ {-(
আর কাপ,

@ আর কেপ এটিকে এই ইনপুটটি সমাধান করে তবে সেই নির্দিষ্ট অনলাইন দোভাষীটির একটি সময়সীমা শেষ হয়েছে (এবং এটি সম্পর্কে বেশ নীরব)) আপনি তার পরিবর্তে এখানে চেষ্টা করে দেখতে পারেন (এবং এটি বেশ কয়েক মিনিট দিন) বা জাভা ইন্টারপ্রিটার (দ্রুততম) ব্যবহার করতে পারেন
aditsu

প্রকৃতপক্ষে, আমি উপরোক্ত সংবেদককে সংযুক্ত করে সম্ভবত এই ইনপুটটি সমাধান করতে অনেক সময় লাগবে। জাভা অনুবাদক সমাধান এটা আমার কম্পিউটারে কম 1.5 মিনিটের মধ্যে।
অ্যাডিটসু

2

জাভাস্ক্রিপ্ট (ES6), 206

পুনরাবৃত্তি ফাংশন

f=(l,a=l.pop(),x=x=>(z='<>[]{}()')[z.indexOf(x)^1])=>l[0]?l.some((b,i)=>r=[b,x([...b].pop())+b.slice(1,-1)+x(b[0])] .some(b=>r=a[0]==[...b].pop()?b+a:b[0]==[...a].pop()?a+b:0)&&(l=[...l],l[i]=r,f(l)))?r:'':a

আরও পঠনযোগ্য

f=(l,a=l.pop(),x=x=>(z='<>[]{}()')[z.indexOf(x)^1])=>
  l[0]?
  l.some((b,i)=>
     r=[b,x([...b].pop())+b.slice(1,-1)+x(b[0])]
     .some(b=>r=a[0]==[...b].pop()?b+a:b[0]==[...a].pop()?a+b:0)
     &&(l=[...l],l[i]=r,f(l))
    )?r:''
 :a

পরীক্ষা

f=(l,a=l.pop(),x=x=>(z='<>[]{}()')[z.indexOf(x)^1])=>l[0]?l.some((b,i)=>r=[b,x([...b].pop())+b.slice(1,-1)+x(b[0])] .some(b=>r=a[0]==[...b].pop()?b+a:b[0]==[...a].pop()?a+b:0)&&(l=[...l],l[i]=r,f(l)))?r:'':a

console.log=(...x)=>O.textContent+=x+'\n'

;[
 //OK
 ['[-->','{---]','>----{']
,['(-[','}--]']
,['(-)']
,['[--{']
,['[-]',']-[']
,['[----->',')------------[','{--<','}---)']
,['>-->','>->','>--->']
,['(-]',']->','>-}','}-)',')-[','[-<','<-{','{-(']
 //KO
,['[-->','{---]']
,['[-]','[-]']
,['(-]',']->','}-)']
,['>->','>-->',']---]']
,['[-------]',']-------[','[-------]','[---------]'] // shortened a little,
,['{--[',']--}']
].forEach(t=>{
  console.log(t+' : "'+f(t)+'"\n')
})
<pre id=O></pre>


1

জাভাস্ক্রিপ্ট, 800 বাইট

একটি অনুকূলিত সমাধান থেকে দূরে, তবে এখানে জাভাস্ক্রিপ্টে একসাথে একটি দ্রুত হ্যাক (কোনও অভিনব একমা 5 বা কোনও কিছুই নেই, কারণ আমি এটি জানি না)।

function a(r){function t(r,t){var n=r.slice();return n.splice(t,1),n}function n(r){var t,n={"[":"]","]":"[",">":"<","<":">","(":")",")":"(","{":"}","}":"{"},e=r.split("").reverse();for(t=0;t<e.length;t++)n.hasOwnProperty(e[t])&&(e[t]=n[e[t]]);return e.join("")}function e(r,t){return r.unshift(t),r}var h,u,f=[];if(1==r.length)return r[0];for(h=0;h<r.length;h++){var l=r[h],i=t(r,h),c=l.charAt(0),g=l.charAt(l.length-1);for(u=0;u<i.length;u++){var o=i[u],s=o.charAt(0),p=o.charAt(o.length-1);c==p&&f.push(e(t(i,u),o+l)),g==s&&f.push(e(t(i,u),l+o)),o=n(o),s=o.charAt(0),p=o.charAt(o.length-1),c==p&&f.push(e(t(i,u),o+l)),g==s&&f.push(e(t(i,u),l+o))}}if(f.length<1)return!1;for(h=0;h<f.length;h++){if(1===f[h].length)return f[h][0];f[h]=a(f[h])}for(h=0;h<f.length;h++)if(f[h]!==!1)return f[h];return!1}

নিখরচায়, এটি এখানে ... আমি নিশ্চিত যে লুপগুলির জন্য কমপক্ষে 2 টি এখানে অপ্রয়োজনীয় এবং শীর্ষে একটি একক উপাদান ইনপুট এবং নীচে একক উপাদান ম্যাচ চেক করা দুর্গন্ধযুক্ত ... তবে এটি কাজ করে বলে মনে হয় এবং পরীক্ষা ইনপুট প্রক্রিয়া।

function a(inputs)
{
	var i, ii, matches = [];
	if (inputs.length == 1) {
		return inputs[0];
	}
	// For each of the elements in inputs (e1)
	for (i = 0; i < inputs.length; i++) {
		var e1 = inputs[i],
			others = except(inputs,i),
			e1s = e1.charAt(0),
			e1e = e1.charAt(e1.length-1);
		// Compare to each of the other elements in inputs (e2)
		for (ii = 0; ii < others.length; ii++) {
			// get the start and end of the elements to compare (e1s,e1e,e2s,e2e)
			var e2 = others[ii],
				e2s = e2.charAt(0),
				e2e = e2.charAt(e2.length-1);
			// if any of them match up (e1s == e2e || e1s == e2s || e1e == e2s || e1e = e2e)
			// Make a new array of inputs containing the joined elements (as a single element) and all other elements which might join with them
			if (e1s == e2e) {
				matches.push(addTo(except(others,ii),e2+e1));
			}
			if (e1e == e2s) {
				matches.push(addTo(except(others,ii),e1+e2));
			}
			e2 = flip(e2);
			e2s = e2.charAt(0);
			e2e = e2.charAt(e2.length-1);
			if (e1s == e2e) {
				matches.push(addTo(except(others,ii),e2+e1));
			}
			if (e1e == e2s) {
				matches.push(addTo(except(others,ii),e1+e2));
			}
		}
	}

	if (matches.length < 1) {
		return false;
	}

	for (i = 0; i < matches.length; i++) {
		if (matches[i].length  === 1) {
			return matches[i][0];
		} else {
			matches[i] = a(matches[i]);
		}
	};

	for (i = 0; i < matches.length; i++) {
		if (matches[i] !== false) {
			return matches[i];
		}
	};

	return false;

	function except(list,idx)
	{
		var newList = list.slice();
		newList.splice(idx,1);
		return newList;
	}
	function flip(s) {
		var replacements = {
			'[':']',
			']':'[',
			'>':'<',
			'<':'>',
			'(':')',
			')':'(',
			'{':'}',
			'}':'{'
		}, i, a = s.split('').reverse();
		for (i = 0; i < a.length; i++) {
			if (replacements.hasOwnProperty(a[i])) {
				a[i] = replacements[a[i]];
			}
		}

		return a.join('');
	}
	function addTo(arr,newEl)
	{
		arr.unshift(newEl);
		return arr;
	}
}


1
বেশ কয়েকটি বাইট সংরক্ষণ করতে আপনি ফাংশনটির নাম পরিবর্তন করতে পারেন। stackoverflow.com/questions/6156319/...
noɥʇʎԀʎzɐɹƆ

1
জাভাস্ক্রিপ্টের যে কোনও সংস্করণে .charAt এড়ান। s.charAt(x)===s[x]
edc65

1

পাইথন 3, 217 বাইট

from itertools import*
a='()[]{}<>'
all(any(c[-1]!=d[0]for c,d in zip(q,q[1:]))or print(''.join(q))for p in permutations(open(0))for q in product(*[(c[:-1],a[a.find(c[-2])^1]+c[-3:0:-1]+a[a.find(c[0])^1])for c in p]))

( আইডিয়নে ডেমো )


এটি কীভাবে ইনপুট নেয়?
আর কাপ,

@ আর কেপ অন স্টিডিনে, প্রতি লাইনে একটি কর্ড।
অ্যান্ডারস ক্যাসরগ

মনে হয় না, কমপক্ষে আমি যখন এটি চালিয়েছি।
আর কাপ,

এছাড়াও, এটির জন্য সঠিক উত্তরটি কীভাবে দ্রুত খুঁজে পেতে পারে (-] ]-> >-} }-) )-[ [-< <-{ {-(?
আর কাপ,

@ আর.ক্যাপ আইডিয়নে ডেমো দেখুন যার উদাহরণ দেয় ইনপুট এবং উত্পাদন আউটপুট। (এটি উইন্ডোজে কাজ নাও করতে পারে, যদি আপনি যা করার চেষ্টা করছেন তা যদি হয়?) এটি চলে ~ তাত্ক্ষণিকভাবে আপনার পরীক্ষার ক্ষেত্রে। অবশ্যই অবশ্যই এমন কেস রয়েছে যা তাত্পর্যপূর্ণ সময় নেবে।
অ্যান্ডারস ক্যাসরগ

0

লুয়া, 477 বাইট

function r(s)return s:reverse():gsub("[()%[%]{}<>]",{["("]=")",[")"]="(",["["]="]",["]"]="[",["{"]="}",["}"]="{",["<"]=">",[">"]="<"})end
function a(c,b)for i, v in next,b do
m=c:sub(-1,-1)n=v:sub(1,1)o=r(c):sub(-1,-1)p=r(v):sub(1,1)l=table.remove(b,i)if m==n then
return a(c..v,b)elseif o==n then
return a(r(c)..v,b)elseif m==p then
return a(c..r(v),b)elseif o==p then
return a(r(c)..r(v),b)end
table.insert(b,i,l)end
return#b>0 and""or c
end
print(a(table.remove(arg,1),arg))

কর্ডগুলি কমান্ড লাইন আর্গুমেন্ট হিসাবে গ্রহণ করে


0

পাইথন 3.5, 448 432 427 424 286 311 বাইট:

( +25 যেহেতু কোনও বাগ ছিল যেখানে আউটপুটটি কিছু ইনপুটগুলির চেয়ে বেশি দীর্ঘ হতে পারে )

def g3(z):
 B=z.split();M='i[::-1].translate({41:40,40:41,125:123,123:125,62:60,60:62,93:91,91:93})';f=B+[eval(M)for i in B if eval(M)not in B];d=[f.pop(0)]
 for h in d:
  try:[d.append([f.pop(f.index(c))for c in f if h[-1]==c[0]][0])if len(d)<len(B)else E]
  except:break
 return''.join(d)if len(d)>=len(B)else''

পুরোপুরি কাজ করে! 7 বা ততোধিক মান সহ ইনপুট ব্যতীত । এটিগুলির জন্য এটি একটি দীর্ঘ সময় নেয় , সম্ভবত সম্ভবত এটি অবশ্যই ইনপুটটির সেই সমস্ত ক্রিয়াকলাপ এবং ইনপুট বিপরীত মাধ্যমে যেতে হবে । আমি যখন পারি তখন এটি ঠিক করার চেষ্টা করব, তবে আপাতত, এটি যথেষ্ট ভাল বলে মনে হচ্ছে। সব এখন ভাল! কেবলমাত্র যদি আমি সেই try-exceptতালিকাটিকে কোনওরকম তালিকা বোধের জন্য ব্যবহার করতে পারি তবে এটি কিছুটা খাটো হতে পারে এবং আরও সুন্দর দেখাতে পারে। তবুও, এটি এখন সমস্ত পরীক্ষার ক্ষেত্রে কাজ করে এবং সর্বোপরি, এটি কোনও আমদানি ব্যবহার করে না ! :)

এটি অনলাইন চেষ্টা করুন! (আইডিয়ন) (২৮৪ বাইট এখানে)

(টিপ: এটি চেষ্টা করার জন্য, কেবল "কাঁটাচামচ" নির্বাচন করুন, এবং তারপরে আপনার পছন্দগুলি, স্থান-পৃথক করে ইনপুট করুন এবং "রান" নির্বাচন করুন)

ব্যাখ্যা

মূলত, যা হচ্ছে তা হচ্ছে ...

  1. একটি তালিকা,, Bইনপুট থেকে সাদা অংশে এর উপাদান "কর্ড" এ বিভক্ত করে তৈরি করা হয়।
  2. Mআমি তৈরি করা একটি স্ট্রিং যা মূল্যায়ন করার পরে একটি তালিকা প্রদান করে Bযার উপর ভিত্তি করে সমস্ত কর্ড রয়েছে তবে এবার পিছন দিকে
  3. থেকে তৈরি তালিকা Mপরিণামে সঙ্গে ঘনিভূত হয় Bএকটি তালিকা তৈরি করতে নিজেই f, "দড়ি" এর সব সম্ভব ওরিয়েন্টেশন সঙ্গে।
  4. অন্য একটি তালিকা dতৈরি করা হয়েছে, যা প্রথম মান (মান f[0]) দিয়ে শুরু করা হবে f
  5. শেষ dঅবধি , সমস্ত মানগুলি পুনরাবৃত্তি হয় এবং প্রতিটি মানের সর্বশেষ বর্ণটি প্রতিটি উপাদানের প্রথম অক্ষরের সাথে তুলনা করা হয় fএবং কোনও মিল খুঁজে পাওয়া গেলে সেই অক্ষরটি পপ করা হয় (বা সরানো হয়) এবং তালিকা থেকে ফিরে আসে f। এই ঘটনা পর্যন্ত IndexErrorউত্থাপিত হয়, অথবা তালিকার দৈর্ঘ্য dছাড়িয়ে গেছে Bএবং NameErrorকল পর উত্থাপিত হয় E, এই দুই ধরনের পরিচালনা করা হয়, এবং তারপর তালিকার d'র বিষয়বস্তু একটি স্ট্রিং মধ্যে যোগদান হয় এবং দৈর্ঘ্য যতদিন ফিরে তালিকায় dবেশি এর চেয়ে বড় বা তালিকার দৈর্ঘ্য সমান B। অন্যথায়, একটি ফাঁকা স্ট্রিং ফিরে আসবে ( ''), যেহেতু dদৈর্ঘ্যের সমান না হয়ে Bইঙ্গিত দেয় যে সমস্ত "কর্ড" তালিকার মধ্যে রয়েছেB এক দীর্ঘ "কর্ড" এ যোগ দেওয়া যায় না।

@ কেনেনিলাউ আপনি কী পরিবর্তন করেছেন? আমি যা দেখতে পাচ্ছি তা থেকে আপনি কেবল যুক্ত করেছেন <!-- language: lang-python -->hat কী পরিবর্তন হয়?
আর কাপ,

এটি আপনার কোডের জন্য সিনট্যাক্স হাইলাইটিং সক্ষম করতে পারে।
ফাঁস নুন

@ কেনিলাউ ওয়াও, এটি দুর্দান্ত। আমি ভাবছিলাম কীভাবে আমি পিপিসিজিতে এটি করব। এখন আমি জানি! ধন্যবাদ! :)
আর কাপ,
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.