পরিশোধিত পার্টিশন


19

পূর্ণসংখ্যার একটি অ্যারে বিবেচনা করুন:

[1, 0, 9, 1, 3, 8]

এই তালিকাটিকে একটানা সাবলিস্টে ভাগ করার অনেকগুলি উপায় রয়েছে। এখানে তিনটি রয়েছে:

A: [[1, 0, 9], [1, 3, 8]]
B: [[1], [0, 9], [1, 3], [8]]
C: [[1, 0], [9, 1], [3, 8]]

X এর কিছু উপ-তালিকাকে আবার একসাথে যোগদান করে যদি Y এর কাছ থেকে এক্স পাওয়া যায় তবে আমরা একটি পার্টিশন ওয়াই এবং অন্য একটি পার্টিশন এক্স এর সংশোধন করব।

সুতরাং Bএকটি পরিশোধন হয় A: যদি আমরা প্রথম দুই এবং গত দুই sublists ফিরে একসঙ্গে যোগদান আমরা প্রাপ্ত A। কিন্তু Cহয় না একটি পরিশোধন A: আমরা বিভক্ত করা আছে চাই 9এবং 1অর্ডার পুনরুদ্ধার করার জন্য Aতা থেকে। এছাড়াও, যে কোনও বিভাজন তুচ্ছভাবে নিজের একটি পরিমার্জনীয়।

নোট করুন যে আমাদের কোনও উপ তালিকা বা উপাদানকে কোনও বিন্দুতে পুনরায় সাজানোর অনুমতি নেই।

চ্যালেঞ্জ

দুই পার্টিশন (পূর্ণসংখ্যার তালিকার তালিকা) দেওয়া Xএবং Yনির্ধারণ কিনা Yএকটি পরিশোধন হয় X

আপনি অনুমান করতে পারে যে পার্টিশন শুধুমাত্র থেকে পূর্ণসংখ্যার উপস্থিত থাকবে 0করার 9সমেত। আপনার অবশ্যই এটি ধরে নেওয়া উচিত নয় Xএবং Yএটি একই তালিকার পার্টিশন (যদি তা না হয় তবে তারা একে অপরের পরিমার্জনও নয়)। Xএবং / অথবা Yখালি থাকতে পারে তবে খালি সাবলিস্টগুলি কখনই থাকতে পারে না।

আপনি STDIN (অথবা নিকটতম বিকল্প), কমান্ড-লাইন আর্গুমেন্ট বা ফাংশন আর্গুমেন্টের মাধ্যমে ইনপুট নিয়ে কোনও প্রোগ্রাম বা ফাংশন লিখতে এবং STDOUT (বা নিকটতম বিকল্প), ফাংশন রিটার্ন মান বা ফাংশন (আউট) প্যারামিটারের মাধ্যমে ফলাফল আউটপুট করতে পারেন।

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

আউটপুট হওয়া উচিত truthy যদি Yএকটি পরিশোধন হয় Xএবং falsy অন্যথায়।

আপনার কোডটি অবশ্যই যুক্তিসঙ্গত ডেস্কটপ মেশিনে 1 সেকেন্ডের নীচে প্রতিটি পরীক্ষার কেস সমাধান করতে সক্ষম হবে। (সাধারণ উদ্দীপনা সমাধানগুলি এড়াতে এটি কেবল একটি স্যানিটেশন চেক))

এটি কোড গল্ফ, তাই সংক্ষিপ্ত উত্তরটি (বাইটে) জেতে।

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

প্রতিটি পরীক্ষার কেস তার নিজস্ব লাইনে থাকে, যেমনটি লিখিত হয় X Y। আমি কিছু অনুভূমিক স্থান বাঁচাতে গল্ফস্ক্রিপ্ট / সিজাম-স্টাইলের অ্যারের স্বরলিপি ব্যবহার করছি:

Truthy:

[] []
[[0]] [[0]]
[[1 0 9 1 3 8]] [[1 0 9] [1 3 8]]
[[1 0 9 1 3 8]] [[1 0 9 1 3] [8]]
[[1 0 9 1 3 8]] [[1] [0] [9] [1] [3] [8]]
[[1 0 9] [1 3 8]] [[1 0 9] [1 3 8]]
[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]
[[9 8 8 5 8 2 7] [5] [1 4] [2 0 0 6 0 8 4 2 6 4 2 3 7 8 7 3 9 5 7 9 8 2 9 5] [3 9 8] [7 1 4 9 7 4 5 9] [3 3 3] [9 0 7 8] [3 9 4 7 2 7 8 0 3 0] [8 2 2 7 3 9 3 2] [2 9 0 8 5 4 1 8 5 5 6 2 0 9 2 7 7 9 2 7] [3 6] [1 2 7 7 4 4 2 9]] [[9 8] [8] [5 8 2] [7] [5] [1 4] [2] [0 0 6] [0] [8 4 2] [6 4] [2] [3] [7 8] [7 3] [9] [5 7 9] [8 2] [9 5] [3] [9 8] [7 1 4] [9 7] [4 5 9] [3 3] [3] [9 0] [7 8] [3] [9] [4] [7 2] [7 8] [0] [3 0] [8 2] [2] [7 3] [9 3] [2] [2] [9] [0] [8 5 4] [1 8] [5 5] [6] [2 0] [9] [2] [7 7 9] [2 7] [3 6] [1 2] [7 7] [4 4 2] [9]]

Falsy:

[[0]] []
[[0]] [[1]]
[[1 0 9]] [[1 0 9] [1 3 8]]
[[1 0 9] [1 3 8]] [[1 0 9 1 3 8]]
[[1 0 9] [1 3 8]] [[1 0 9]]
[[1 0 9] [1 3 8]] [[1 0] [9]]
[[1 0 9] [1 3 8]] [[1 0] [9 1] [3 8]]
[[1] [0 9] [1 3] [8]] [[1 0 9] [1 3 8]]
[[9 8 8 5 8 2 7] [5] [1 4] [2 0 0 6 0 8 4 2 6 4 2 3 7 8 7 3 9 5 7 9 8 2 9 5] [3 9 8] [7 1 4 9 7 4 5 9] [3 3 3] [9 0 7 8] [3 9 4 7 2 7 8 0 3 0] [8 2 2 7 3 9 3 2] [2 9 0 8 5 4 1 8 5 5 6 2 0 9 2 7 7 9 2 7] [3 6] [1 2 7 7 4 4 2 9]] [[9 8] [8] [5 8 2] [7] [5 1] [4] [2] [0 0 6] [0] [8 4 2] [6 4] [2] [3] [7 8] [7 3] [9] [5 7 9] [8 2] [9 5] [3] [9 8] [7 1 4] [9 7] [4 5 9] [3 3] [3] [9 0] [7 8] [3] [9] [4] [7 2] [7 8] [0] [3 0] [8 2] [2] [7 3] [9 3] [2] [2] [9] [0] [8 5 4] [1 8] [5 5] [6] [2 0] [9] [2] [7 7 9] [2 7] [3 6] [1 2] [7 7] [4 4 2] [9]]

লিডারবোর্ড

নিয়মিত লিডারবোর্ড এবং ভাষার দ্বারা বিজয়ীদের একটি সংক্ষিপ্ত বিবরণ উভয়ই তৈরি করতে এখানে একটি স্ট্যাক স্নিপেট।

আপনার উত্তরটি প্রদর্শিত হয়েছে তা নিশ্চিত করার জন্য, দয়া করে নীচের মার্কডাউন টেম্পলেটটি ব্যবহার করে আপনার উত্তরটি শিরোনাম দিয়ে শুরু করুন:

# Language Name, N bytes

Nআপনার জমা দেওয়ার আকারটি কোথায় ? আপনি যদি নিজের স্কোরটি উন্নত করেন তবে আপনি পুরানো স্কোরগুলি শিরোনামে রেখে দিতে পারেন। এই ক্ষেত্রে:

# Ruby, <s>104</s> <s>101</s> 96 bytes

<script>site = 'meta.codegolf'; postID = 5314; isAnswer = true; QUESTION_ID = 51719</script><script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)</code></pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

সম্পর্কিত চ্যালেঞ্জ


চান [[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]]বা [["109" "138"] ["1" "09" "13" "8"]]একটি গ্রহণযোগ্য ইনপুট বিন্যাস হবে?
ডেনিস

@ ডেনিস পুরো অ্যারের ইনপুট মোড়ানো অদ্ভুত বলে মনে হচ্ছে। আমি এটি স্ট্যান্ডার্ড অনুশীলন সম্পর্কে সচেতন নই তবে এটি একটি মেটা প্রশ্নের জন্য মূল্যবান হতে পারে। বাহ্যিক বন্ধনীগুলি ছাড়া এটি অবশ্যই ভাল fine
মার্টিন ইন্ডার

আমি একটি মেটা প্রশ্ন লিখতে চেষ্টা করব।
ডেনিস

উত্তর:


6

সিজেম, 13 10 9 বাইট

lr.-F-U-!

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

@ মার্টিনব্যাটনারকে @ এডসি 65 এর ইনজেনিয়াস ইনপুট ফর্ম্যাটটির পরামর্শ দেওয়ার জন্য ধন্যবাদ ।

ইনপুট ফর্ম্যাটটি উন্নত করার জন্য এবং 3 অ্যাডিটোনাল বাইটগুলি গল্ফ করার জন্য @ জিমি 23013 কে ধন্যবাদ।

ইনপুট / আউটপুট

ইনপুট

সাবলিস্টগুলি ;একে অপরের দ্বারা পৃথক করে দ্বারা ,:

1;0;9,1;3;8
1,0;9,1;3,8

আউটপুট

1

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

lr e# Read line and a whitespace-separated token from STDIN.
.- e# Vectorized difference. Pushes the differences of corresponding code points.
F- e# Remove all occurrences of 15 (';' - ',') from the array.
U- e# Remove all occurrences of 0 from the array.
!  e# Push 1 if the resulting array is empty and 0 if not.

বিভিন্ন দৈর্ঘ্যের স্ট্রিংয়ের জন্য .-অ্যারেতে অক্ষরগুলি ছেড়ে যাবে, যা 0 বা 15 এর পূর্ণসংখ্যার সমান হতে পারে না।


আপনি ব্যবহার করতে পারেন ;বিভাজক হিসেবে ... ll.m27m0-!
জিমি 23013

@ জিমি 23013: আমি কেন দেখছি না। ,এবং ;উভয়ই সাধারণ অ্যারে সিনট্যাক্স (এবং এর কোনওটি সিজেএম দ্বারা ব্যবহৃত হয় না)। ধন্যবাদ!
ডেনিস

9

পাইথ, 19 বাইট

&gF_m{.u+NYdYQqFsMQ

এটি অনলাইনে ব্যবহার করে দেখুন: বিক্ষোভ বা পরীক্ষার জোতা

আমি পাইথের টিপল / তালিকা ফর্ম্যাটটি ইনপুট হিসাবে ব্যবহার করছি। কমা দিয়ে পরীক্ষার কেসগুলির স্থানগুলি কেবল স্থানান্তর করুন।

ব্যাখ্যা:

                     implicit: Q is the evaluated input
    m        Q       map each input list d to:
      .u   dY          reduce with intermediate states over d, initial value = []
        +NY              update initial value N with sum of N and Y (current element of d)
     {                 generate a set
   _                 invert
 gF                  check, if the first element is >= (superset) than the second
&                    and
                sMQ  check, if the joined lists of the input
              qF     are equal

যেহেতু সিউডো কোডটি এখনও কিছুটা বিভ্রান্তিকর, তাই আমি একটি উদাহরণ ইনপুট ব্যবহার করে অ্যালগরিদমটি প্রদর্শন করব।

Input: [[1,0,9],[1,3,8]],[[1],[0,9],[1,3],[8]]

.u+NYdYঅংশ সব একটানা sublists, যে প্রথম উপাদান নির্ণয় করে।

[[1,0,9],[1,3,8]]     => [[], [1,0,9], [1,0,9,1,3,8]]
[[1],[0,9],[1,3],[8]] => [[], [1], [1,0,9], [1,0,9,1,3], [1,0,9,1,3,8]]

Bএকটি পরিশোধন হয় Aiff প্রতিটি একটানা sublist, Aএছাড়াও একটি ক্রমাগত sublist হয় B(শুধুমাত্র এক ব্যতিক্রম নেই)।

সুতরাং আমি সহজেই পরীক্ষা করে দেখি, যদি ক্রমাগত সাবলিস্টগুলির Aসেটটি B( gF_m.u+NYdYQ) এর ধারাবাহিক সাবলিস্টগুলির সেটটির উপসেট হয় ।

একমাত্র ব্যতিক্রম হ'ল, যদি প্রথম ইনপুট তালিকায় দ্বিতীয় ইনপুট তালিকার চেয়ে কম উপাদান থাকে। উদাহরণস্বরূপ ইনপুট জন্য <Fm.u+YdYQফিরে আসবে ।True[[1]],[[1],[2]]

সুতরাং আমি যাচাই করা তালিকাও সমান কিনা তাও আমি পরীক্ষা করে দেখি &...qFsMQ


7

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

3 বাইট সংরক্ষিত thx @apsillers সম্পাদনা করুন

ফায়ারফক্সে পরীক্ষা করতে নীচে স্নিপেট চালান

f=(a,b)=>a+''==b // same values in the lists ?
&![...a.join(' ')].some((c,p)=>c<','&b.join(c)[p]>c) // splits in a are present in b?

// TEST

out=x=>O.innerHTML += x+'\n';

OK=[
[[],[]],
[[[0]],[[0]]],
[[[1,0,9,1,3,8]],[[1,0,9],[1,3,8]]],
[[[1,0,9,1,3,8]],[[1,0,9,1,3],[8]]],
[[[1,0,9,1,3,8]],[[1],[0],[9],[1],[3],[8]]],
[[[1,0,9],[1,3,8]],[[1,0,9],[1,3,8]]],
[[[1,0,9],[1,3,8]],[[1],[0,9],[1,3],[8]]],
[[[9,8,8,5,8,2,7],[5],[1,4],[2,0,0,6,0,8,4,2,6,4,2,3,7,8,7,3,9,5,7,9,8,2,9,5],[3,9,8],[7,1,4,9,7,4,5,9],[3,3,3],[9,0,7,8],[3,9,4,7,2,7,8,0,3,0],[8,2,2,7,3,9,3,2],[2,9,0,8,5,4,1,8,5,5,6,2,0,9,2,7,7,9,2,7],[3,6],[1,2,7,7,4,4,2,9]],[[9,8],[8],[5,8,2],[7],[5],[1,4],[2],[0,0,6],[0],[8,4,2],[6,4],[2],[3],[7,8],[7,3],[9],[5,7,9],[8,2],[9,5],[3],[9,8],[7,1,4],[9,7],[4,5,9],[3,3],[3],[9,0],[7,8],[3],[9],[4],[7,2],[7,8],[0],[3,0],[8,2],[2],[7,3],[9,3],[2],[2],[9],[0],[8,5,4],[1,8],[5,5],[6],[2,0],[9],[2],[7,7,9],[2,7],[3,6],[1,2],[7,7],[4,4,2],[9]]]
];

KO=[
[[[0]],[]],
[[[0]],[[1]]],
[[[1,0,9]],[[1,0,9],[1,3,8]]],
[[[1,0,9],[1,3,8]],[[1,0,9,1,3,8]]],
[[[1,0,9],[1,3,8]],[[1,0,9]]],
[[[1,0,9],[1,3,8]],[[1,0],[9]]],
[[[1,0,9],[1,3,8]],[[1,0],[9,1],[3,8]]],
[[[1],[0,9],[1,3],[8]],[[1,0,9],[1,3,8]]],
[[[9,8,8,5,8,2,7],[5],[1,4],[2,0,0,6,0,8,4,2,6,4,2,3,7,8,7,3,9,5,7,9,8,2,9,5],[3,9,8],[7,1,4,9,7,4,5,9],[3,3,3],[9,0,7,8],[3,9,4,7,2,7,8,0,3,0],[8,2,2,7,3,9,3,2],[2,9,0,8,5,4,1,8,5,5,6,2,0,9,2,7,7,9,2,7],[3,6],[1,2,7,7,4,4,2,9]],[[9,8],[8],[5,8,2],[7],[5,1],[4],[2],[0,0,6],[0],[8,4,2],[6,4],[2],[3],[7,8],[7,3],[9],[5,7,9],[8,2],[9,5],[3],[9,8],[7,1,4],[9,7],[4,5,9],[3,3],[3],[9,0],[7,8],[3],[9],[4],[7,2],[7,8],[0],[3,0],[8,2],[2],[7,3],[9,3],[2],[2],[9],[0],[8,5,4],[1,8],[5,5],[6],[2,0],[9],[2],[7,7,9],[2,7],[3,6],[1,2],[7,7],[4,4,2],[9]]]
];

dump=l=>l.map(x=>'['+x+']').join(',');

out('YES');
OK.forEach(l=>out(f(l[0],l[1])+' a['+dump(l[0])+'] b['+dump(l[1])+']'));
out('NO');
KO.forEach(l=>out(f(l[0],l[1])+' a['+dump(l[0])+'] b['+dump(l[1])+']'));
<pre id=O></pre>


এই দিনগুলির একটির মধ্যে আমি আপনার দুর্দান্ত সমাধানগুলি কার্যকর করতে ফায়ারফক্স ডাউনলোড করতে যাচ্ছি। :)
অ্যালেক্স এ

@AlexA। আপনি এটি ছাড়া বাঁচতে পারেন কিভাবে?
edc65

Repl.it ব্যবহার করুন, আমি মনে করি এটি ES6 সমর্থন করে: ডি
মার্ক কে কোয়ান

আমি পছন্দ করি আপনি কীভাবে ভেরিয়েবলের নাম দিয়েছেন OKএবং KO
rr-

7

সি, 69 75

2 বা স্ট্রিং প্যারামিটার সহ একটি ফাংশন, 0 বা 1 প্রদান করে।

প্যারামিটার ফর্ম্যাট: সাবলিস্ট স্পেস ('') দিয়ে পৃথক করা হয়েছে, কমা দিয়ে আলাদা করা উপাদানগুলির তালিকা দিন।

উদাহরণ: "1,0,9 1,3,8" "1,0 9,1,3,8"

f(char*a,char*b){for(;*a-44?*a&&*b==*a:*b<48;a++)b++;return!(*b|*a);}

কম গল্ফড

int f(char *a, char *b)
{
    // expected in a,b: digit,separator,digit... with separator being ' ' or ','
    for(; *a; a++,b++)
       // ' ' or digit in a must be the same in b
       // comma in a must be comma or space in b
       if (*a != ',' ? *b != *a : *b > *a) return 0;
    return !*b; // must have a null in *b too
}

পরীক্ষার ধারণা (পুরানো)


1
ইনপুট ফর্ম্যাটের চতুর পছন্দ। আমি এটি অন্য হাস্কেলের উত্তরের জন্য ধার নিয়েছি।
নিমি

আমি আমার জেএস উত্তরের জন্য ইনপুট দেওয়ার জন্য আপনার ধারণাটি ছিন্ন করেছিলাম, এবং এটি আপনার সি সংস্করণের তুলনায় এক বাইট দীর্ঘ হিসাবে প্রমাণিত হয়েছে যতক্ষণ না আমি এটি এএস 6 তে আপগ্রেড করেছি ... কে আশা করেছিল যে ...
মার্ক কে কোয়ান

6

হাস্কেল, 76 বাইট

[]#[]=1<2
[x]#[y]=x==y
x@(a:b)#(c:d:e)|a==c=b#(d:e)|1<2=x#((c++d):e)
_#_=2<1

রিটার্ন Trueবা False। ব্যবহারের উদাহরণ: [[1,0,9],[1,3,8]] # [[1,0],[9]]-> False

সহজ পুনরাবৃত্তির পদ্ধতির: যদি প্রথম উপাদানগুলি মেলে, লেজগুলি দিয়ে চলুন, অন্যথায় শুরু করুন তবে দ্বিতীয় তালিকার সামনের অংশে দুটি উপাদানকে সম্মতি দিন। বেস কেসগুলি হ'ল: উভয় তালিকা খালি -> True; উভয় তালিকাগুলি একটি একক উপাদানের সাথে -> তাদের তুলনা করুন; খালি একটি তালিকা খালি -> False


6

সিজেম, 19 বাইট

q~]{_,,\f>:sS.+}/-!

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

ইনপুট / আউটপুট

ইনপুট

[[1 0 9] [1 3 8]] [[1] [0 9] [1 3] [8]]

আউটপুট

1

ধারণা

নিম্নলিখিত দুটি বৈশিষ্ট্য পর্যবেক্ষণ করে প্রতিটি পার্টিশন স্বতন্ত্রভাবে চিহ্নিত করা যেতে পারে:

  • সমস্ত সাবলিস্টকে একত্রিত করে তালিকাটি তৈরি করা হয়েছে।

  • তালিকার চূড়ান্তকরণ সহ "কাটিং পয়েন্ট"।

কাটিং পয়েন্ট থেকে তালিকার শেষের দিকে উপাদানগুলির সাব-লিস্টের সাথে প্রতিটি কাটিয়া পয়েন্টকে প্রতিস্থাপন করে আমরা উভয় মানদণ্ডকে একটিতে সংযুক্ত করতে পারি।

প্রদত্ত পার্টিশনটি অন্যটির চেয়ে সূক্ষ্ম কিনা তা যাচাই করার জন্য, আমাদের কেবলমাত্র যাচাই করতে হবে যে উপরে বর্ণিত মোটা পার্টিশনটি সূক্ষ্মরূপের একটি উপসেট এবং উভয় পার্টিশনের বৃহত্তম তালিকা মিলছে কিনা match

কোড

q~]   e# Read from STDIN and evaluate.
{     e# For each array P from the input:
  _,, e#   Push [0 ... L], where L == length(P) - 1.
  \f> e#   Push [P[0:] ... P[L]].
  :s  e#   Stringify each P[k:] (flattens).
  S.+ e#   Vectorized concatenation. This appends a space to the first element.
}/    e#
-!    e# Push the logical NOT of the difference A-B to check if A is a subset of B.

ইনপুট I / O উদাহরণ হিসাবে, স্ট্যাকটি ধারণ করে

["109138 " "138"] ["109138 " "09138" "138" "8"]

চালানোর আগে -!

নোট করুন যে প্রতিটি অ্যারের প্রথম উপাদানটির একটি পিছনের স্থান রয়েছে। এটি নিশ্চিত করে যে আমরা প্রথম ইনপুটটির সম্পূর্ণ তালিকাটিকে দ্বিতীয়টির সম্পূর্ণ তালিকার সাথে তুলনা করি।


5

সিজেম, 24 বাইট

l~L\{+_a2$1<={;1>L}&}/+!

অ্যালগরিদম

এখানে আমরা কেবলমাত্র একটি লোভী অ্যালগরিদম ব্যবহার Nকরে দ্বিতীয় তালিকার প্রথম উপ-তালিকাগুলি একত্রিত করে প্রথম তালিকার প্রথম উপ-তালিকা তৈরি করতে পারি তা দেখতে see এটির সন্ধান Nপাওয়া গেলে , আমরা Nদ্বিতীয় তালিকা থেকে প্রথম উপ-তালিকাগুলি এবং প্রথম তালিকা থেকে প্রথম উপ-তালিকাটি সরিয়ে ফেলি এবং প্রক্রিয়াটি পুনরাবৃত্তি করি।

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

কোড সম্প্রসারণ

l~L\{+_a2$1<={;1>L}&}/+!
l~L\                       e# Read the line, evaluate the two lists and put an empty list
                           e# between them
    {               }/     e# Iterate over all sub-lists of the second list
     +                     e# Append the current sub-list to whatever is on stack. Originally
                           e# an empty array, but eventually the sum of first N sub-lists
      _a                   e# Copy this and wrap it in an array
        2$                 e# Copy the first list on top of stack
          1<               e# Get only its first element wrapped in an array. This approach
                           e# is exception safe in case the array was already 0 length
            ={    }&       e# If we have a match, remove both first sub-lists
              ;            e# Remove the first N sub-lists array
               1>          e# Remove the first element from the first array
                 L         e# Put an empty array on stack to repeat the process
                      +!   e# If we are left with two empty arrays, sum them and do logical
                           e# not to get 1. If any of the arrays is non-empty, logical not
                           e# gives 0

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


3

সি, 120 114 বাইট

#define C(x),x+=(*x/93)*(1+!!x[1])|1
o;R(char*s,char*t){for(o=1;*s;o&=*s==t[2*(*t==93&&93>*s)]C(s)C(t));return o;}

আমি খুব বেশি গল্ফ খেলিনি, তাই আমি ভেবেছিলাম আমি এটি চেষ্টা করে দেখি।

আমরা একটি ফাংশন সংজ্ঞায়িত করি R(char* s, char* t)যা কোনও পরিশোধিত পার্টিশন এবং অন্যথায় 1যদি ফিরে আসে । এবং প্রত্যাশা করা হয় যে বিন্যাসে যেখানে প্রতিটি অন্য একক অঙ্কের উপাদান।ts0st[DDDD...][DDDD...]...D

পরীক্ষার কোড:

#include "stdio.h"

int main(int argc, char** argv) {
    char* str1, *str2;
    str1 = "[109][138]";
    str2 = "[1][09][13][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));

    str1 = "[109][138]";
    str2 = "[1][19][13][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));

    str1 = "[109][138]";
    str2 = "[10][91][3][8]";
    printf("Input: %s, %s --> %d\n", str1, str2, R(str1, str2));
}

উপরোক্তগুলি নিম্নলিখিতগুলি মুদ্রণ করে:

Input: [109][138], [1][09][13][8] --> 1
Input: [109][138], [1][19][13][8] --> 0
Input: [109][138], [10][91][3][8] --> 0

এটি কাজ করে বলে মনে হচ্ছে, অন্তত।


3

হাস্কেল, 52 50 53 বাইট

x#y=and$zipWith(\a b->a==b||a==',')(x++"..")(y++"..")

আমার অন্যান্য সমাধান থেকে সম্পূর্ণ পৃথক । @ Edc65 এর উত্তরের মতো একই চতুর ইনপুট ফর্ম্যাটটি ব্যবহার করে , অর্থাৎ উপাদানগুলি পৃথক করা হয় ,এবং এর সাথে তালিকাবদ্ধ হয়

ব্যবহারের উদাহরণ: "1,0,9,1,3,8" # "1,0,9 1,3,8" -> True

দ্বিতীয় প্যারামিটারটি প্রথমটির একটি পরিমার্জন, যদি তাদের প্রতিটি অবস্থানে সমান উপাদান থাকে বা প্রথমটি হয় ,। আমাকে ..উভয় পরামিতিতে একটি অনন্য প্রান্ত টোকেন (-> ) যুক্ত করতে হবে, কারণ zipWithদীর্ঘতর প্যারামিটারটি কেটে যায় এবং উদাহরণস্বরূপ "1,2,3" # "1,2"এটিও হবে True


1
(\a b->a==b||a>b)ঠিক হয় (>=)
আলেফাল্ফ

কাজের "."পরিবর্তে ".."খুব যুক্ত করা হবে না ?
গর্বিত হাসেলেলার

এটি ব্যর্থ হয় "2"#"1"কারণ ফাংশনগুলি কেবলমাত্র মানগুলি বড় হলে সমান নয় তা
যাচাই করে

@ আলেফাল্ফ: ওহে প্রিয়, এটাকে উপেক্ষা করার জন্য আমার কত বোকা। তবে তা যাই হোক ভুল wrong অন্যান্য মন্তব্য দেখুন।
নিমি

টুইটার হ্যাঁ, এটি একটি বাগ। ঠিক কর. জানার জন্য ধন্যবাদ। বিটিডাব্লু, একটি ডট "."কাজ করবে না, কারণ এটি একটি মিথ্যা ধনাত্মক দেয় "2,1" # "2"যার জন্য প্রথমে প্রসারিত হবে "2,1." # "2."এবং তারপরে কাটা zipWithহবে "2," # "2."। প্রথম স্ট্রিংয়ের একটি কমা সমস্ত কিছুর সাথে মেলে।
নিমি

2

গণিত, 65 বাইট

f@__=1<0;{}~f~{}=1>0;{a_,b___}~f~{c__,d___}/;a==Join@c:={b}~f~{d}

1
সুন্দর সমাধান। এফওয়াইআই, আমি একটি 59-বাইট সমাধান পেয়েছি যা পুনরাবৃত্তি (বা একাধিক সংজ্ঞা) ব্যবহার করে না।
মার্টিন ইন্ডার

2

নিয়মিত এক্সপ্রেশন সহ গণিত মজাদার!

ES6 জাভাস্ক্রিপ্ট, 53 অক্ষর

(a,b)=>RegExp('^'+a.replace(/,/g,'[ ,]')+'$').test(b)

ভিনটেজ জাভাস্ক্রিপ্ট, 70 টি অক্ষর

function f(a,b){return RegExp('^'+a.replace(/,/g,'[ ,]')+'$').test(b)

Edc65 এর উত্তরের মতো একই ইনপুট ফর্ম্যাট ব্যবহার করে ।

এখানে সমস্ত পরীক্ষার মামলা সহ সম্পূর্ণ ডেমো।


চতুর! এই কাজের জন্য নিয়মিত প্রকাশ সম্পর্কে কখনও ভাবেননি।
edc65

আমি একটি পার্ল প্রোগ্রাম লিখেছিলাম যা একটি পুনরাবৃত্ত ফাংশন ব্যবহার করে পূর্ণসংখ্যার উপাদানগুলি ব্যাকট্র্যাকিংয়ের নিয়মিত অভিব্যক্তি ব্যবহার করে এমন প্রধান উপাদানগুলি খুঁজে পেয়েছিল ... তারা সুন্দর এবং স্পষ্টতই দ্রুত নয়, তবে তারা কিছু দুর্দান্ত জিনিস করতে পারে!
কে কে কোয়ান

আমি একটি পার্সার জেনারেটরও লিখেছি, যা একটি ভাষার স্পেসিফিকেশনকে একটি নিয়মিত অভিব্যক্তিতে রূপান্তরিত করে এবং সেই নিয়মিত এক্সপ্রেশনটি তখন নির্দিষ্ট ভাষায় এক্সপ্রেশনকে পার্স করতে ব্যবহার করা যেতে পারে। মূলত, একটি "এক্সিকিউটেবল" নিয়মিত-প্রকাশের জন্য একটি মানব-পঠনযোগ্য ভাষায় নির্দিষ্ট "সংকলন"। github.com/battlesnake/d-slap AngularJS বোধগম্য প্রকাশকে পার্স করার জন্য উত্পন্ন নিয়মিত প্রকাশটি প্রায় 400-500 অক্ষর দীর্ঘ ...
মার্ক কে কোয়ান

2

গণিত, 55 বাইট

Equal@@Join@@@#&&SubsetQ@@(Accumulate[Length/@#]&)/@##&

এটি একটি নামবিহীন ফাংশন সংজ্ঞায়িত করে, একটি একক তালিকায় দুটি পার্টিশন নিয়ে , বিপরীত ক্রমে (যেমন Yপ্রথম, Xদ্বিতীয়)।

ব্যাখ্যা

Equal@@Join@@@#

এটি পরীক্ষা করে যে উভয় পার্টিশনই একই তালিকার পার্টিশন।

SubsetQ@@(Accumulate[Length/@#]&)/@##

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


2

পাইথন 2, 68 51 বাইট

কিছু উল্লেখযোগ্য বাইট-সঞ্চয় করার জন্য xnor কে ধন্যবাদ!

বেনামে ফাংশন যা ফর্মের দুটি স্ট্রিং নেয় "1,0,9 1,3,8"( এডসি 65 এর সি উত্তর থেকে নেওয়া ) এবং ফেরত দেয় Trueবা Falsemap(None)পাইথন 3 এ আর নতুন সংস্করণ কাজ করে না।

lambda a,b:all(i in[j,","]for i,j in map(None,a,b))

পরীক্ষা স্যুট:

>>> def runTests(f):
    assert f("1,0,9 1,3,8","1 0,9 1,3 8")
    assert not f("1,0,9 1,3,8","1,0 9,1 3,8")
    assert f("1 0,9 1,3 8","1 0,9 1,3 8")
    assert not f("1 0,9 1,3 8","1,0,9 1,3,8")
    assert not f("1 0,9 1,3 8","1 0,9 1,3")
    assert not f("1 0,9 1,3,8","1 0,9 1,3")
    print("All tests pass.")


>>> runTests(lambda a,b:all(i in[j,","]for i,j in map(None,a,b)))
All tests pass.

পূর্ববর্তী 92-বাইট সমাধান যা ইনপুট নেয় "109 138":

def R(a,b):
 r=1
 for i in b.split():r&=a.find(i)==0;a=a[len(i):].strip()
 return r and""==a

আমি মনে করি আপনি কোনওটিই ম্যাপিংয়ের মাধ্যমে স্পষ্ট দৈর্ঘ্যের চেক করা এড়াতে পারবেন । যখন একটি তালিকা অন্যের চেয়ে দীর্ঘ হয় তখন তা প্রত্যাখ্যান করা হয় যেখানে একটি তালিকার মধ্যে রয়েছে Noneতবে অন্য তালিকার একটি সংখ্যা রয়েছে, যেহেতু i==j or"0">i>jধরে রাখতে পারে না।
xnor

আমি যদি কিছু মিস করি না তবে দ্বিতীয় পরীক্ষা ঠিক হতে পারে i==','। এটি আপনাকে পরীক্ষাগুলিকে একত্রিত করতে দেয় i in[',',j](আমরা করতে পারি না i in ','+j) কারণ jহতে পারে None
xnor

@ এক্সনর বাহ, ধন্যবাদ # 1 আমার কাছে ঘটেনি কারণ আমি এখন পাইথন 3 তে ভাবতে অভ্যস্ত; # 2 আমার কাছে ঘটেনি কারণ "সেই জায়গায় যদি bএকটি সংখ্যা থাকে তবে কী হবে ?" ... এই ইনপুট ফর্ম্যাটটি দিয়ে ভুলে যাওয়া, এটি সম্ভব নয়।
DLosc
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.