একটি সুসংযুক্ত চ্যালেঞ্জ


40

বিরক্ত হওয়ার সময় আমি যে কার্যকলাপটি মাঝেমধ্যে করি তা হ'ল মিলের জোড়ায় কয়েকটা অক্ষর লেখা। আমি এই অক্ষরগুলি সংযুক্ত করতে লাইনগুলি (উপরে কখনও নিচে শীর্ষে নেই) আঁকি। উদাহরণস্বরূপ আমি লিখতে এবং তারপরে আমি লাইনগুলি :abcbac

প্রথম লিঙ্ক

অথবা আমি লিখতেabbcac

দ্বিতীয় লিঙ্ক

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

লুপ টানা

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

নোট করুন যে কয়েকটি স্ট্রিং একাধিক উপায়ে আঁকতে পারে। উদাহরণস্বরূপ, নিম্নলিখিত দুটি উপায়ে আঁকতে পারে (এবং তৃতীয়টি অন্তর্ভুক্ত নয়):bbbb

উপায় 1 অথবা উপায় 2

যদি এইগুলির মধ্যে একটির মতো আঁকতে পারে যে কোনও বদ্ধ লুপটি কোনও লাইনকে ছেদ না করে কিছু অক্ষর ধারণ করে, তবে স্ট্রিংটি ভালভাবে লিঙ্কযুক্ত নয়। (সুতরাং ভালভাবে সংযুক্ত নেই)bbbb

কার্য

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

এছাড়াও আপনার প্রোগ্রামটি অবশ্যই একটি ভাল সংযুক্ত স্ট্রিং অর্থ হতে পারে

  • প্রতিটি চরিত্র আপনার প্রোগ্রামে একাধিকবার উপস্থিত হয়।

  • নিজেই পাস হয়ে গেলে সত্যের মানটি আউটপুট করা উচিত।

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

কম স্কোর হওয়ার চেয়ে কম বাইটের সাথে উত্তরগুলি তাদের দৈর্ঘ্যের হিসাবে করা হবে।

ইঙ্গিত

একটি স্ট্রিং ভালভাবে লিঙ্কযুক্ত নয় যদি একটি স্বতন্ত্র অবৈধ খালি কঠোর স্ট্রিংস উপস্থিত থাকে যে প্রতিটি অক্ষর সেই স্ট্রিংগুলিতে একাধিকবার প্রদর্শিত হয়।

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

abcbac -> True
abbcac -> False
bbbb -> False
abacbc -> True
abcbabcb -> True
abcbca -> False

1
টেস্ট কেস: abcbca -> False
janrjan জোহানসেন

আমি মনে করি আপনার ইঙ্গিতটিতে একটি অতিরিক্ত অতিরিক্ত রয়েছে there
জোনাথন ফ্রেচ

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

ইনপুটটিতে কি ধরণের অক্ষর থাকতে পারে?
xnor

@ এক্সনর আমি এটিকে চ্যালেঞ্জে যুক্ত করেছি। আশা করি এটি পরিষ্কার হয়ে যায়।
গম উইজার্ড

উত্তর:


19

রেজেক্স (ECMAScript 2018 বা .NET), 140 126 118 100 98 82 বাইট

^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)

এটি 98 বাইট সংস্করণের তুলনায় অনেক ধীর ^\1গতিযুক্ত , কারণ লুকোচূড়ার বামদিকে রয়েছে এবং এর পরে এটি মূল্যায়ন করা হয়। গতি আবার ফিরে আসে এমন একটি সাধারণ স্যুইচারুর জন্য নীচে দেখুন। তবে এর কারণে, নীচের দুটি টিআইও পূর্বের তুলনায় একটি ছোট পরীক্ষার সেটটি সীমাবদ্ধ করার জন্য সীমাবদ্ধ এবং নেট নেট তার নিজস্ব রেজেক্স পরীক্ষা করতে খুব ধীর।

এটি অনলাইন চেষ্টা করুন! (ECMAScript 2018)
এটি অনলাইনে ব্যবহার করে দেখুন! (.Net)

18 বাইট (118 → 100) নামার জন্য , আমি নির্লজ্জভাবে নীলের রেইগেক্স থেকে একটি দুর্দান্ত অপ্টিমাইজেশন চুরি করেছি যা নেতিবাচক লুকবিহিনের ভিতরে লুকআপের প্রয়োজনকে এড়িয়ে চলেছে (একটি 80 বাইট অব্যাহত রেজেক্স ফলন করেছে)। ধন্যবাদ, নীল!

জয়তেয়ার ধারণাগুলির জন্য এটি একটি অবিশ্বাস্য 16 টি বাইট (98 → 82) বাদ দিলে তা অপ্রচলিত হয়ে পড়েছিল যা 69 বাইটের সীমাহীন রেগেক্সের কারণ হতে পারে! এটি অনেক ধীর, তবে এটি গল্ফ!

দ্রষ্টব্য যে (|(রেজেক্সকে ভাল-সংযুক্ত করার জন্য কোনও বিকল্প নেই এটি নেট। এর অধীনে খুব ধীরে ধীরে মূল্যায়ন করার ফলাফল রয়েছে। ECMAScript এ এগুলির প্রভাব নেই কারণ শূন্য-প্রস্থের alচ্ছিক ম্যাচগুলিকে অ-মিল হিসাবে বিবেচনা করা হয়

ECMAScript দাবিতে কোয়ান্টিফায়ারগুলিকে নিষিদ্ধ করে, তাই এটি প্রয়োজনীয়তাগুলি আরও শক্ত করে তোলে । যাইহোক, এই মুহুর্তে এটি এতটা সুসজ্জিত যে আমি মনে করি না যে এই বিশেষ সীমাবদ্ধতাটি হ্রাস করা আরও গল্ফিংয়ের সম্ভাবনা খুলে দেবে।

অতিরিক্ত অক্ষর ছাড়াই এটি বিধিনিষেধ ( 101 pass 69 বাইট) পাস করার জন্য প্রয়োজনীয় :

^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))

এটি ধীর গতিযুক্ত, তবে এই সাধারণ সম্পাদনাটি (মাত্র ২ টি অতিরিক্ত বাইটের জন্য) সমস্ত হারিয়ে যাওয়া গতি এবং আরও অনেক কিছু ফিরে পায়:

^(?!(.*)(.+)(.*$)(?<!^\2|(?=\1((((?!\8).)*(\8|\3$)){2})*$)^\1.*(.)+\3))

^
(?!
    (.*)               # cycle through all starting points of substrings;
                       # \1 = part to exclude from the start
    (.+)               # cycle through all ending points of non-empty substrings;
                       # \2 = the substring
    (.*$)              # \3 = part to exclude from the end
    (?<!               # Assert that every character in the substring appears a total
                       # even number of times.
        ^\2            # Assert that our substring is not the whole string. We don't
                       # need a $ anchor because we were already at the end before
                       # entering this lookbehind.
    |                  # Note that the following steps are evaluated right to left,
                       # so please read them from bottom to top.
        ^\1            # Do not look further left than the start of our substring.
        (?=
            # Assert that the number of times the character \8 appears in our
            # substring is odd.
            (
                (
                    ((?!\8).)*
                    (\8|\3$) # This is the best part. Until the very last iteration
                             # of the loop outside the {2} loop, this alternation
                             # can only match \8, and once it reaches the end of the
                             # substring, it can match \3$ only once. This guarantees
                             # that it will match \8 an odd number of times, in matched
                             # pairs until finding one more at the end of the substring,
                             # which is paired with the \3$ instead of another \8.
                ){2}
            )*$
        )
        .*(.)+         # \8 = cycle through all characters in this substring
        # Assert (within this context) that at least one character appears an odd
        # number of times within our substring. (Outside this negative lookbehind,
        # that is equivalent to asserting that no character appears an odd number
        # of times in our substring.)
        \3             # Skip to our substring (do not look further right than its end)
    )
)

আমি এটি ভ্যারিয়েবল-দৈর্ঘ্যের বর্ণমহলে রূপান্তর করার আগে আণবিক লুক হেড ( 103 69 বাইট) ব্যবহার করে এটি লিখেছিলাম:

^(?!.*(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$))

^
(?!
    .*(?*(.+)(.*$))       # cycle through all non-empty substrings;
                          # \1 = the current substring;
                          # \2 = the part to exclude from the end
    (?!                   # Assert that no character in the substring appears a
                          # total even number of times.
        ^\1$              # Assert that our substring is not the whole string
                          # (i.e. it's a strict substring)
    |
        (?*(.)+.*\2$)    # \3 = Cycle through all characters that appear in this
                          # substring.
        # Assert (within this context) that this character appears an odd number
        # of times within our substring.
        (
            (
                ((?!\3).)*
                (\3|\2$)
            ){2}
        )*$
    )
)

এবং আমার রেজেক্সকে নিজের সাথে সুসংযুক্ত করার জন্য সহায়তা করার জন্য, আমি উপরের রেজেক্সের একটি প্রকরণ ব্যবহার করছি:

(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$)\1

যখন এটি ব্যবহার করা হয় তখন regex -xml,rs -oএটি ইনপুটটির একটি কঠোর সাবস্ট্রিং সনাক্ত করে যা প্রতিটি অক্ষরের একটি সমান সংখ্যক (যদি উপস্থিত থাকে) থাকে। অবশ্যই, আমি এই কাজটি করার জন্য একটি নন-রেজেক্স প্রোগ্রামটি লিখতে পারতাম তবে তাতে মজা কোথায় হবে?


8
wtf এটি এখনও গল্ফ করা হচ্ছে
ASCII- কেবল

@ এএসসিআইআই-কেবল এবং এখনও গল্ফ করা হচ্ছে ...
কুইনটেক

11

জেলি, 20 বাইট

ĠẈḂẸẆṖÇ€Ạ
ĠẈḂẸ
ẆṖÇ€Ạ

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

প্রথম লাইন উপেক্ষা করা হয়। কেবলমাত্র শর্তটি পূরণ করার জন্যই প্রতিটি চরিত্র একাধিকবার প্রদর্শিত হয়।

পরের লাইনটি Ġসূচকগুলি তাদের মান অনুসারে প্রথমে পাঠায়। এরপরে যদি আমরা ফলাফলের তালিকায় প্রতিটি সাবলিস্টের দৈর্ঘ্য নিই ( ), আমরা প্রতিটি অক্ষর প্রদর্শিত হওয়ার সংখ্যা পাই। এগুলির কোনওটি অ- সম -কিনা কিনা তা যাচাই করতে, আমরা প্রতিটি গণনার সর্বশেষ এটি পাই এবং জিজ্ঞাসা করি যে সেখানে সত্যবাদী (ননজারো) মান রয়েছে কি না।

সুতরাং, এই সহায়ক লিঙ্কটি কোনও স্ট্রিংটি বৃত্তাকারে চলা যায় না কিনা তা ফেরত দেয় ।

মূল লিঙ্কে, আমরা ইনপুট ( ) এর সমস্ত সাবস্ট্রিংগুলি গ্রহণ করি , শেষটি বন্ধ করি (যাতে আমরা পুরো স্ট্রিংটি প্রদক্ষিণ করা যায় কিনা তা পরীক্ষা করতে পারি না Ç) এবং আছ স্ট্রিংয়ের সাহায্যকারী লিঙ্কটি ( ) চালনা করি । ফলস্বরূপ তারপর এলএল সাবস্ট্রিংগুলি বৃত্তাকারে আনা যায় না।


সুতরাং, হাঁ, এই আমার সমাধান খুব হতে পারে, কিন্তু, দুর্ভাগ্যবশত, এটা বিরক্তিকর ... :(
এরিক Outgolfer

8

জে , 34 বাইট

2:@':.,|~*'>1(#.,)*/@(1>2|#/.~)\.\

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

-8 বাইট ফ্রেউনিফ্রোগের জন্য ধন্যবাদ

মূল

জে , 42 বাইট

(*#'.,012&|@~#')=1#.[:,([:*/0=2&|@#/.~)\.\

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

ব্যাখ্যা

(*#'.,012&|@~#') = 1 #. [: , ([: */ 0 = 2&|@#/.~)\.\

(*#'.,012&|@~#')                                       NB. this evaluates to 1
                                                       NB. while supplying extra
                                                       NB. chars we need.  hence...
                 =                                     NB. does 1 equal...
                   1 #.                                NB. the sum of...
                        [: ,                           NB. the flatten of...
                             (                  )\.\   NB. the verb in parens applied
                                                       NB. to every suffix of every
                                                       NB. prefix, ie, all contiguous 
                                                       NB. substrings
                             ([: */ 0 = 2&|@#/.~)      NB. def of verb in paren:
                                             /.~       NB. when we group by each
                                                       NB. distinct char...
                              [: */                    NB. is it the case that
                                                       NB. every group...
                                           @#          NB. has a length...
                                    0 = 2&|            NB. divisible by 2...

1
@ ডেডকোড যেহেতু প্রতিটি স্ট্রিংয়ের মতো পুরো স্ট্রিংয়ের জন্য বিপরীত পরীক্ষা করার সমতুল্য হ্যান্ডেল করা, এটি একটি নিরাপদ বাজি বলে মনে হচ্ছে যে বেশিরভাগ সমাধানই এটিকে ছাড়বে। পরীক্ষা করে দেখা হচ্ছে abc, কেবল পার্ল এন্ট্রি এতে "ব্যর্থ" হয় না। (যদিও
এটিতে

1
@ JanrjanJohansen আপনি ভুল বুঝেছেন। আমি বলেছিলাম যে কোনও অক্ষরের বিশিষ্ট মোট সংখ্যার স্ট্রিংগুলি (যা কেবল প্রোগ্রামগুলির উত্স কোডটিকেই অযোগ্য করে দেয়, ভাল-সংযুক্ত স্ট্রিংগুলিকে) ভালভাবে সংযুক্ত করা যায়, এবং এই প্রোগ্রামটি কিছু ভাল-সংযুক্ত স্ট্রিংগুলির জন্য মিথ্যা ফিরিয়ে দেয়। প্রশ্ন স্পষ্টত এই অপরিবর্তিত আচরণের অনুমতি দেয়, তাই প্রোগ্রামটি বৈধ। জোনা, আমি মনে করি এটি সত্যই আকর্ষণীয় যে আপনার প্রোগ্রামটি এটি করে এবং আমি প্রশংসা করি যে আপনি এই পদ্ধতিতে কাজ করে এমন একটি পদ্ধতি খুঁজে পেয়েছেন। আমি একটি ব্যাখ্যা পছন্দ করি। এই জাতীয় প্রোগ্রামিং আমার কাছে সম্পূর্ণ এলিয়েন তাই আমি মন্তব্য এবং কোড বুঝতে পারি না।
ডেডকোড

1:@':.,02|~*'=1(#.,)*/@(0=2|#/.~)\.\
ফ্রাউনফ্রোগ

1
2:@':.,|~*'>1(#.,)*/@(1>2|#/.~)\.\এছাড়াও বৈধ বলে মনে হচ্ছে
ফ্রাউনফ্রোগ

6

পাইথন 3.8 (প্রাক রিলিজ) , 66 বাইট

lambda l,b={id}:len({str(b:=b^{c})for(c)in l})<len(l)#,<^fmnost{}#

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

এসাইনমেন্ট এক্সপ্রেশন এর যুগ আমাদের উপর। সঙ্গে PEP 572 পাইথন 3.8 অন্তর্ভুক্ত golfing একই হতে হবে। আপনি প্রাথমিক বিকাশকারী পূর্বরূপ 3.8.0a1 এখানে ইনস্টল করতে পারেন ।

অ্যাসাইনমেন্ট এক্সপ্রেশন :=আপনাকে সেই মানটির মূল্যায়ন করার সময় ভেরিয়েবল ইনলাইন নির্ধারণ করতে ব্যবহার করতে দেয়। উদাহরণস্বরূপ, (a:=2, a+1)দেয় (2, 3)। এটি অবশ্যই পুনরায় ব্যবহারের জন্য ভেরিয়েবলগুলি সঞ্চয় করতে ব্যবহার করা যেতে পারে, তবে এখানে আমরা আরও একধাপ এগিয়ে গিয়ে একটি বোধগম্যতার জন্য এটি একটি সঞ্চয়ী হিসাবে ব্যবহার করি।

উদাহরণস্বরূপ, এই কোডটি ক্রমসংখ্যার অঙ্কগুলি গণনা করে [1, 3, 6]

t=0
l=[1,2,3]
print([t:=t+x for x in l])

তালিকা বোধগম্যতার মধ্য দিয়ে প্রতিটি পাসের সাথে নোট করুন, ক্রমবর্ধমান সমষ্টিটি tবৃদ্ধি পেয়েছে xএবং বোধগমের দ্বারা উত্পাদিত তালিকায় নতুন মান সংরক্ষণ করা হয়।

একইভাবে, এতে অক্ষর রয়েছে কিনা তা টগল করতে b:=b^{c}অক্ষরের সেট আপডেট করে এবং এর নতুন মানকে মূল্যায়ন করে । সুতরাং, কোডটি অক্ষরগুলির মধ্যে পুনরাবৃত্তি করে এবং প্রতিটি খালি খালি উপসাগরে অদ্ভুত সংখ্যক বার দেখা অক্ষরের সেট সংগ্রহ করে।bcb[b:=b^{c}for c in l]cl

পরিবর্তে এটি একটি সেট বোধগম্য করে এবং এর দৈর্ঘ্য এর চেয়ে কম কিনা s, এর অর্থ হল যে কিছু পুনরাবৃত্তি সঙ্কুচিত হয়েছে এই নকলের জন্য এই তালিকাটি পরীক্ষা করা হয়েছে । যদি তা হয় তবে পুনরাবৃত্তির অর্থ হ'ল sসেই সময়ের মধ্যে দেখা অংশটিতে প্রতিটি চরিত্র একটি সংখ্যক সংখ্যক সংখ্যার মুখোমুখি হয়েছিল, স্ট্রিংটিকে নন-লিঙ্কযুক্ত করে তোলে। পাইথন অপসারণযোগ্য হওয়ার জন্য সেটগুলির সেটগুলিকে অনুমতি দেয় না, সুতরাং অভ্যন্তর সেটগুলি পরিবর্তে স্ট্রিংয়ে রূপান্তরিত হয়।

সেটটি bএকটি optionচ্ছিক আর্গুমেন্ট হিসাবে আরম্ভ করা হয় এবং সফলভাবে ফাংশন স্কোপে পরিবর্তিত হয়। আমি চিন্তিত ছিলাম এটি ফাংশনটি পুনরায় ব্যবহারযোগ্য করে তুলবে, তবে এটি রানের মধ্যে পুনরায় সেট হয়ে যায় বলে মনে হচ্ছে।

উত্স বিধিনিষেধের জন্য, জোড় করা অক্ষরগুলি শেষে একটি মন্তব্যে স্টাফ করা হয়। লেখার for(c)in lপরিবর্তে for c in lঅতিরিক্ত অতিরিক্ত প্যারেন্স বাতিল করে দেয়। আমরা idপ্রারম্ভিক সেটে রেখেছি b, এটি যেহেতু নির্দোষ, যেহেতু এটি কোনও সেট হিসাবে শুরু হতে পারে, তবে খালি সেটটি লিখতে পারে না {}কারণ পাইথন একটি খালি অভিধান তৈরি করে। যেহেতু চিঠিগুলি iএবং dজুটির প্রয়োজন তাদের মধ্যে রয়েছে তাই আমরা ফাংশনটি idসেখানে রাখতে পারি।

নোট করুন যে কোডটি অবহেলিত বুলিয়ানগুলিকে আউটপুট দেয়, সুতরাং এটি সঠিকভাবে Falseনিজেই দেবে।



5

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

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)

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

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

উত্স সীমাবদ্ধতা সম্পর্কে এখন। জুটি বাঁধার জন্য প্রয়োজনীয় অক্ষরগুলি বিভিন্ন নিরীহ জায়গায় স্টাফ করা হয়, নীচে আন্ডারলাইন করা হয়:

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)
_____              _              _      _    _    ___        ___    

f<sমূল্যায়ণ 0করার সময় একটি বন্ধ যুক্ত করার f, ফাংশন নাম হচ্ছে সুবিধার সুযোগ গ্রহণ fযাতে এটি সংজ্ঞায়িত হচ্ছে (সময় ফাংশন বলা দ্বারা।) 0^0একটি শোষণ ^প্রতীক।

0মধ্যে P={0}পাইথন মধ্যে: দুর্ভাগ্যজনক {}একটি খালি সেট আমরা চাই হিসাবে বদলে একটি খালি অভি মূল্যায়ণ, এবং এখানে আমরা কোনো অ-অক্ষর উপাদানের ক্ষেত্রে লাগাতে পারেন এবং এটি নিরীহ হবে। যদিও আমি রাখার জন্য অতিরিক্ত কিছু দেখছি না 0এবং এটি bmn02 টি বাইটের মধ্যে রেখে একটি নকল করে রেখেছি । নোট করুন যে ফাংশনটি সংজ্ঞায়িত হওয়ার সাথে সাথে প্রাথমিক আর্গুমেন্টগুলি মূল্যায়ন করা হয়, সুতরাং আমরা নিজেরাই নির্ধারিত ভেরিয়েবলগুলি এখানে স্থাপন করা যায় না।


4

পার্ল 6 , 76 বাইট

*.comb[^*X+(^*).map(^*)].grep({$_&[&]($_)}).none.Bag{*}.none%2#*^+XBob2rec%#

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

একটি যাই হোক না কেন ল্যাম্বদা যে কোনওটি নয় জংশনের কোনটিই জংশন দেয় না যা সত্য / মিথ্যা মানকে বোঝানো যায়। আমি ?রিটার্নের ফলাফলটিকে প্রশংসনীয় যেটিকে সরিয়ে না দেওয়ার পরামর্শ দিচ্ছি , অন্যথায় আউটপুট বরং আরও বড় হয়ে যায়

এই সমাধান লিঙ্কমুক্ত হচ্ছে বিভিন্ন জড়িত ফাংশন, যেমন কারণে, একটু প্রয়োজন তুলনায় আরো জটিল .., all, >>, %%ইত্যাদি উৎস বাধা ছাড়াই, এই 43 বাইট হতে পারে:

*.comb[^*X.. ^*].grep(?*).one.Bag{*}.all%%2

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

ব্যাখ্যা:

*.comb                     # Split the string to a list of characters
      [^*X+(^*).map(^*)]   # Get all substrings, alongside some garbage
                        .grep({$_&[&]($_)})        # Filter out the garbage (empty lists, lists with Nil values)
                                           .none                 # Are none of
                                                .Bag{*}          # The count of characters in each substring
                                                       .none%2   # All not divisible by 2

                                               #*^+XBob2rec%#    And garbage to even out character counts

3

পার্ল 5 -p, 94, 86, 78 বাইট

m-.+(?{$Q|=@q&grp,$\|=$&eq$_^!grep+/^/&(@m=$g=~/\Q$_/g),($g=$&)=~/./g})(?!)-}{

আউটপুট 0 অন্যথায় ভালভাবে সংযুক্ত থাকলে।

78 বাইট

86 বাইট

94 বাইট

কিভাবে এটা কাজ করে

  • -pসঙ্গে }{আউটপুট কৌতুক বিভক্তি $\শেষে
  • m-.+(?{.. })(?!)-, সমস্ত শূন্য খালি স্ট্রিংয়ের উপর কোড কার্যকর করতে ( .+পুরো স্ট্রিংটির সাথে প্রথমে মেলে, এবং এর মধ্যে কোড কার্যকর করার পরে (?{.. })ব্যর্থ বাধ্য হয়ে ব্যাকট্র্যাকগুলি(?!)
  • $Q|=@q&grp, উত্স সীমাবদ্ধতার কারণে আবর্জনা
  • $\|=সংখ্যার বিটওয়াস বা অ্যাসাইনমেন্ট, যদি প্রায় 1 জন থাকে $\তবে এটি 1 (সত্য) হবে, ডিফল্টরূপে এটি খালি (মিথ্যা)
  • $&eq$_এই ক্ষেত্রে যেখানে স্ট্রাস্ট্রিং পুরো স্ট্রিংটি ^"কোনও বিজোড় চরিত্রের উপস্থিতি" এর সাথে কিছুটা জোর করে
  • ($g=$&)=~/./g$gম্যাচ করা স্ট্রিংগুলিকে এতে অনুলিপি করতে (কারণ পরবর্তী রেজেক্স ম্যাচের পরে ওভারর্ট করা হবে) এবং স্ট্রিংয়ের চরিত্রের অ্যারেটি ফিরিয়ে আনুন।
  • /^/ আবর্জনা যা মূল্যায়ন 1
  • grep&(@m=$g=~/\Q$_/g),স্ট্রিংয়ের প্রতিটি চরিত্রের জন্য ১ টি $gনিজের সাথে মিলিয়ে অক্ষরের অ্যারে পান, স্কেলারে অ্যারে তার আকারের জন্য মূল্যায়ন করে এবং grepবিজোড় ঘটনাক্রমে ক্র্যাক্টরগুলি ফিল্টার 1&xকরা সমানx%2==1

আমি মনে করি না এটি উত্স বিধিনিষেধকে সন্তুষ্ট করে: আমি একটি অদ্ভুত সংখ্যক খোলা বন্ধনী গণনা করি, উদাহরণস্বরূপ
msh210

@ msh210 এই কথাটি না? যদি কোনও
সমান

ভাল লিঙ্ক হচ্ছে প্রয়োজনীয়তা @Quintec ওয়ান সেখানে যে হয় প্রতিটি অক্ষর একটি জোড় সংখ্যা।
আরজান জোহানসেন

আমার প্রথম উত্তরের প্রয়োজনীয়তা ছিল কিন্তু গল্ফ চেষ্টা করার পরে, এটি হারিয়ে ফেলল। আপডেট হয়েছে, তবে গল্ফ করা যেতে পারে।
নাহুয়েল ফিউইলুল

1
এখানে সমস্ত উত্স উত্স বিধিনিষেধকে
মেটায়

3

রেটিনা , 150 96 বাইট

^(?!(.*)(.+)(.*)$(?<!^\2|^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি নিজেই সহ পরীক্ষার কেসগুলি অন্তর্ভুক্ত করে। সম্পাদনা করুন: @ ডেডকোডের সাহায্যে মূল রেজেক্সকে মোটামুটি কিছুটা নিচে নামিয়ে দিন, তারপরে উত্সের বিন্যাসটি বজায় রাখতে কিছুটা অমিতব্যয়ীভাবে ব্যাক আপ করুন। ব্যাখ্যা:

^(?!(.*)(.+)(.*)$

জোর দিয়ে নিন যে কোনও স্ট্রিং \3বিদ্যমান নেই যা নিম্নলিখিত সীমাবদ্ধতার সাথে মেলে।

(?<!^\2|

জোড় করে বলুন যে সাবস্ট্রিং সম্পূর্ণ মূল স্ট্রিং নয়।

^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

জোর দিয়ে বলুন যে এর \6মতো কোনও চরিত্র নেই :

  • এটি চরিত্র নিজেই (একচেটিয়া) এবং স্ট্রিংয়ের শেষের মধ্যে উপস্থিত হয় না
  • এটি স্ট্রিংয়ের শুরু এবং নিজেই (একচেটিয়া) এর মধ্যে একাধিকবার উপস্থিত হয়

উত্স বিন্যাসের সীমাবদ্ধতাটি অতিক্রম করার জন্য, আমি এর ((((সাথে (?:(^?(?:(এবং ((সাথে প্রতিস্থাপন করেছি (|(। আমার কাছে এখনও একটি উত্স বাধা ছিল ))এবং অক্ষরগুলি !()1<{}বাকি ছিল, তাই আমি একটিতে পরিবর্তন করেছি এবং বাকীটি গ্রাস করার জন্য অকেজো +প্রবেশ করিয়েছি ।{1,}(?!,<)?


2
এটি সীমাবদ্ধ উত্সের প্রয়োজনীয়তাগুলি পূরণ করে না বলে মনে হয়।
আরজান জোহানসেন

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

3

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 208 206 200 198 বাইট

x=>!x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&!Enumerable.Repeat(x.Count,x.Count*x.Count).Where(
(l,i)=>i%l>0&!x.Skip(i/l).Take(i%l).GroupBy(c=>c).Any(g=>g.Count()%2>0)
).Any()/*>!oyAnC0EmeablR*WhiS/T*/

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

-2 বাইটস @ কেভিন ক্রুজসেনকে ধন্যবাদ!

অবশেষে এটি ২০০ এর নিচে পেয়েছে, সুতরাং আপাতত আমার জন্য গল্ফিং করা হতে পারে :) আমি আগের উত্তরের ভিত্তিতে জিনিসগুলি পরীক্ষা করার জন্য একটি দ্বিতীয় টিআইও তৈরি শেষ করেছি।

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

এই কাজটি জটিল করে তুলেছে এমন জিনিসগুলি:

  • সমতা অপারেটর ==অনুমোদিত ছিল না
  • বর্ধন / বরাদ্দ অপারেটর ++অনুমোদিত ছিল না
  • লিনাক All()ফাংশন অনুমোদিত ছিল না

নীচে মন্তব্য কোড:

// anonymous function that takes an IList as input
x=>
  // the first condition makes sure the string even
  // counts of each character
  !x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&
  // the second condition generates all proper substrings of x
  // and tests for any that contain even character counts
  // the string length `l` is repeated `l*l` times
  !Enumerable.Repeat(x.Count,x.Count*x.Count)
    .Where((l,i)=>
      // check that the substring length is greater than 0
      i%l>0&
      // use skip/take to generate a substring
      // and check for a character count thats odd
      // negate the result meaning we have found
      // a substring that invalidates the input
      !x.Skip(i/l).Take(i%l)
        .GroupBy(c=>c).Any(g=>g.Count()%2>0)
    )
    // if any invalid substrings are found
    // then the result in invalid
    // the comment string at the end is needed
    // to make the program well-linked
    .Any()/*>!oyAnC0EmeablR*WhiS/T*/

আপনি আপনার পিছনের মন্তব্যে দুটি স্থান সরিয়ে ফেলতে পারেন।
কেভিন ক্রুইজসেন

@ কেভিন ক্রুজসেন - ভাল একটি :) আমি ভুলে গিয়েছিলাম যে আমি ইতিমধ্যে একটি স্থান যুক্ত করেছি। আমাকে অন্য একটি উত্সে ফেলে দিতে হয়েছিল।
ডানা

2

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

lambda d,e=enumerate:min(max(d[l:l+b].count(k)%2for(k)in d)for b,c in e(d[2:],2)for l,f in e(d) )#b =:x+.%2#

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

-2 ধন্যবাদ অর্জান জোহানসেনকে


@ আরজান জোহানসেন হু, সুন্দর সম্পাদনা: দেখে মনে হচ্ছে এটি সামগ্রিকভাবে মাত্র দুটি বাইট সংরক্ষণ করে।
এরিক আউটগল্ফার

2

ব্র্যাচল্যাগ , 16 বাইট

sᶠb∋p~j&sᶠb∋p~j&

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

ছাপে false.truthy দৃষ্টান্ত এবং true.falsy দৃষ্টান্ত জন্য। টিআইও সংস্করণটি নিজেকে পরিচালনা করতে খুব ধীর, তবে এটি স্পষ্টতই সংযুক্ত কারণ এটি অনন্য অক্ষরগুলির সাথে একটি স্ট্রিং দু'বার পুনরাবৃত্তি করেছে।

ব্যাখ্যা

    Input is a string: "abcacbaa"
sᶠ  Find all substrings: ["abcacbaa","abcacba","abcacb",..,"a"]
b   Behead (now the proper substrings remain): ["abcacba","abcacb",..,"a"]
∋   Take one of them: "abcacb"
p   Permute it: "abcabc"
~j  It is some string repeated twice: "abc"
&   Get the input again: "abcacbaa"
    Then repeat the above.
    If the constraints can be satisfied, the result is true, otherwise false.

1

05 এ বি 1 ই , 22 20 বাইট

Œε¢Pà}KŒIKεSIS¢ÈP}àÈ

1স্ট্রিংটি ভাল-সংযুক্ত থাকলে আউটপুটগুলি এবং স্ট্রিংটি ভাল-সংযুক্ত 0না থাকলে।

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন

ব্যাখ্যা:

বেস প্রোগ্রামটি ŒsKεsS¢ÈP}à( 11 বাইট ), যা 0ভাল-সংযুক্ত এবং 1যদি ভাল-সংযুক্ত না থাকে তবে ফলাফল দেয়। ট্রেইলিং È(is_even) হ'ল একটি আধা আউটপুট যা আউটপুট উল্টায় তাই 1ভাল সংযুক্ত স্ট্রিংগুলির 0জন্য এবং ভাল-সংযুক্ত স্ট্রিংগুলির জন্য নয়। অন্যান্য অংশগুলি চ্যালেঞ্জের নিয়ম মেনে চলার কোনও বিকল্প নেই।

Œε¢Pà}K         # No-ops: substrings, map, count, product, maximum, close map, remove
                # Due to the last remove, we're back at the (implicit) input again
Π              # Take the substrings of the input
 IK             # Remove the input itself from that list of substrings
   ε            # Map each substring to:
    S           #  No-op: transform the substring into a list of characters
     IS         #  Get the input-string as a list of characters
       ¢        #  Count the occurrence of each character in the current substring
        È       #  Check which counts are even (1 if truthy; 0 if falsey)
         P      #  Take the product of that
              # After the map: check if any are truthy by taking the maximum
            È   # Semi no-op: check if this maximum is even (0 becomes 1; 1 becomes 0)
                # (and output the result implicitly)
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.