অনন্য অপসারণযোগ্য উপসর্গ

25

ভূমিকা

পূর্ণসংখ্যার ক্রম এবং এর একটি অনুচ্ছেদে বিবেচনা করুন, এ = [4 2 2 4 4 6 5] এবং বি = [2 4 5] বলুন । আমরা A এর থেকে বি এর উপাদানগুলি ক্রমানুসারে সরাতে চাই এবং এটি করার বিভিন্ন উপায় রয়েছে:

A = 4 2 2 4 4 6 5
B =   2   4     5
 -> 4   2   4 6

A = 4 2 2 4 4 6 5
B =     2 4     5
 -> 4 2     4 6

A = 4 2 2 4 4 6 5
B =   2     4   5
 -> 4   2 4   6

A = 4 2 2 4 4 6 5
B =     2   4   5
 -> 4 2   4   6

সমস্ত ক্ষেত্রে, অবশিষ্ট ক্রম একই, [4 2 4 6] । যদি সেটা হয়, আমরা যদি বলি য়ে বি হল থেকে স্বতন্ত্র অপসারণযোগ্য একটি ।

কাজটি

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

আপনার আউটপুট একটি truthy মান হইবে যদি বি থেকে স্বতন্ত্র অপসারণযোগ্য হয় একটি , এবং একটি falsy মান যদি না।

বিধি এবং স্কোরিং

আপনি একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন লিখতে পারেন। সর্বনিম্ন বাইট গণনা জিতেছে।

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

[] [] -> True
[0,3] [] -> True
[1,0,1] [1] -> False
[0,2] [0,2] -> True
[2,2,1,1,2,2,2] [2,1] -> True
[4,2,2,4,4,6,5] [4,5] -> False
[10,5,10,10,5,10] [10,5,10] -> False
[4,2,2,4,4,6,5] [2,4,5] -> True
[1,1,1,0,0,0,1,1,1,0] [1,0,1,1] -> True
[0,1,0,0,0,0,1,1,0,1] [1,0,1,1] -> False
[0,4,0,0,4,1,4,2,2] [0,0,0,1,4] -> True
[0,2,2,25,0,2,2,26,0,0,2] [2,0,0,0,2] -> True
[1,1,1,3,2,1,3,2,2,3,3,2] [1,1,2,3,2] -> False
[0,3,2,0,1,3,2,0,0,0,3,2] [0,1,2,0,3] -> False
[5,7,2,7,7,1,7,7,5,2,7,7,5,2,2,7,5] [2,7,5,7,7,2] -> False
[5,4,0,5,4,5,4,1,0,4,2,1,1,2,4,4,0,2,2,1] [4,0,1,1,2,1] -> False
[0,1,4,0,1,4,0,1,5,1,4,4,2,0,0,1,1,1,2,4] [0,1,0,0,2,0,1,4] -> True
code-golf  array-manipulation  decision-problem  subsequence 
— Zgarb
সূত্র

উত্তর:

6

হাস্কেল, 90 84 বাইট

a%[]=[a]
(t:z)%x@(s:y)=[a|a<-z%y,t==s]++[t:s|s<-z%x]
_%_=[]
((all=<<(==).head).).(%)

নির্বিঘ্নে সব সম্ভাব্য বিয়োগফল ক্রমের তালিকা তৈরি করুন এবং সেগুলি সব সমান কিনা তা পরীক্ষা করে দেখুন।

ব্যবহার: 

*Main> mapM_(\(a,b)->let r=(((all=<<(==).head).).(%)) a b in putStrLn$concat[show a," ",show b," -> ",show r]) [([],[]), ([0,3],[]), ([1,0,1],[1]), ([0,2],[0,2]), ([2,2,1,1,2,2,2],[2,1]), ([4,2,2,4,4,6,5],[4,5]), ([10,5,10,10,5,10],[10,5,10]), ([4,2,2,4,4,6,5],[2,4,5]), ([1,1,1,0,0,0,1,1,1,0],[1,0,1,1]), ([0,1,0,0,0,0,1,1,0,1],[1,0,1,1]), ([0,4,0,0,4,1,4,2,2],[0,0,0,1,4]), ([0,2,2,25,0,2,2,26,0,0,2],[2,0,0,0,2]), ([1,1,1,3,2,1,3,2,2,3,3,2],[1,1,2,3,2]), ([0,3,2,0,1,3,2,0,0,0,3,2],[0,1,2,0,3]), ([5,7,2,7,7,1,7,7,5,2,7,7,5,2,2,7,5],[2,7,5,7,7,2]), ([5,4,0,5,4,5,4,1,0,4,2,1,1,2,4,4,0,2,2,1],[4,0,1,1,2,1]), ([0,1,4,0,1,4,0,1,5,1,4,4,2,0,0,1,1,1,2,4],[0,1,0,0,2,0,1,4])]
[] [] -> True
[0,3] [] -> True
[1,0,1] [1] -> False
[0,2] [0,2] -> True
[2,2,1,1,2,2,2] [2,1] -> True
[4,2,2,4,4,6,5] [4,5] -> False
[10,5,10,10,5,10] [10,5,10] -> False
[4,2,2,4,4,6,5] [2,4,5] -> True
[1,1,1,0,0,0,1,1,1,0] [1,0,1,1] -> True
[0,1,0,0,0,0,1,1,0,1] [1,0,1,1] -> False
[0,4,0,0,4,1,4,2,2] [0,0,0,1,4] -> True
[0,2,2,25,0,2,2,26,0,0,2] [2,0,0,0,2] -> True
[1,1,1,3,2,1,3,2,2,3,3,2] [1,1,2,3,2] -> False
[0,3,2,0,1,3,2,0,0,0,3,2] [0,1,2,0,3] -> False
[5,7,2,7,7,1,7,7,5,2,7,7,5,2,2,7,5] [2,7,5,7,7,2] -> False
[5,4,0,5,4,5,4,1,0,4,2,1,1,2,4,4,0,2,2,1] [4,0,1,1,2,1] -> False
[0,1,4,0,1,4,0,1,5,1,4,4,2,0,0,1,1,1,2,4] [0,1,0,0,2,0,1,4] -> True

6 জ্যাকেট বাঁচানোর জন্য @ জগারবকে ধন্যবাদ!

— Angs
সূত্র
আপনি জিনিসগুলি পুনর্বিন্যাস করতে পারেন এবং x%_=xদ্বিতীয় ক্ষেত্রেও রাখতে পারেন %। এছাড়াও, আমি মনে করি মূল কার্যটি সংক্ষিপ্ত আকারে সংক্ষিপ্ত হবে।
— Zgarb
@ জগারব x%_=xকাজ করবে না কারণ প্রকারগুলি মেলে না তবে _%_=[]একটি বাইট সংরক্ষণ করে।
— অ্যাঙ্গস
4

জাভাস্ক্রিপ্ট (ES6), 141 152 156 159

রিকার্সিভ ফাংশন - বেশ দীর্ঘ

f=(a,b,i=0,j=0,r=a,S=new Set)=>(1/b[j]?1/a[i]&&f(a,b,i+1,j,r,S,a[i]-b[j]||f(a,b,i+1,j+1,r=[...r],r[i]=S)):S.add(0+r.filter(x=>1/x)),S.size<2)

কম গল্ফড

f=(a, b, 
   i = 0, // current position to match in a
   j = 0, // current position to match in b
   r = a, // current result so far, A with elements of B removed - start == A
   S = new Set // set of possible "A removed B"
) => (
    1 / b[j] // check if j is still inside B
    ? 1 / a[i] // if i is inside A
      && (
        // in any case try to find current element of B in the remaining part of A
        f(a, b, i+1, j, r, S),
        a[i] == b[j] // if match was found between A and B
        && 
          // mark current element in a copy of r and 
          // look for the next element of B in the remaining part of A
          f(a, b, i+1, j+1, r=[...r], r[i]=S),
      )
    // else - j is not inside B, we have a solution in r
    // use filter to get a copy without the marked elements
    //  (note: 1/any_number == number_not_0, 1/Object == NaN)
    // then convert to string, to use as a key in S
    : S.add(0+a.filter(x=>1/x)),
    S.size<2 // return true if S has only 1 element
)

পরীক্ষা

f=(a,b,i=0,j=0,r=a,S=new Set)=>(1/b[j]?1/a[i]&&f(a,b,i+1,j,r,S,a[i]-b[j]||f(a,b,i+1,j+1,r=[...r],r[i]=S)):S.add(0+r.filter(x=>1/x)),S.size<2)


out=(...x)=>O.textContent+=x.join` `+'\n'
;`[] [] -> True
[0,3] [] -> True
[1,0,1] [1] -> False
[0,2] [0,2] -> True
[2,2,1,1,2,2,2] [2,1] -> True
[4,2,2,4,4,6,5] [4,5] -> False
[10,5,10,10,5,10] [10,5,10] -> False
[4,2,2,4,4,6,5] [2,4,5] -> True
[1,1,1,0,0,0,1,1,1,0] [1,0,1,1] -> True
[0,1,0,0,0,0,1,1,0,1] [1,0,1,1] -> False
[0,4,0,0,4,1,4,2,2] [0,0,0,1,4] -> True
[0,2,2,25,0,2,2,26,0,0,2] [2,0,0,0,2] -> True
[1,1,1,3,2,1,3,2,2,3,3,2] [1,1,2,3,2] -> False
[0,3,2,0,1,3,2,0,0,0,3,2] [0,1,2,0,3] -> False
[5,7,2,7,7,1,7,7,5,2,7,7,5,2,2,7,5] [2,7,5,7,7,2] -> False
[5,4,0,5,4,5,4,1,0,4,2,1,1,2,4,4,0,2,2,1] [4,0,1,1,2,1] -> False
[0,1,4,0,1,4,0,1,5,1,4,4,2,0,0,1,1,1,2,4] [0,1,0,0,2,0,1,4] -> True`
.split('\n').forEach(t=>{
  var [a,b,_,k]=t.match(/\S+/g)
  var r=f(eval(a),eval(b))
  out(r==(k[0]=='T')?'OK':'KO',a,b,r,k)
})
<pre id=O></pre>
স্নিপেট প্রসারিত করুন

— edc65
সূত্র
3

জাভাস্ক্রিপ্ট (ES6), 116 114 113 বাইট

রিটার্ন falseবা true।

(a,b,p)=>((F=(a,i,m)=>1/b[i]?a.map((n,j)=>m>j|n-b[i]||F(a.filter((_,k)=>j-k),i+1,j)):p?r|=p!=a:p=a+'')(a,r=0),!r)

ফর্ম্যাট এবং মন্তব্য

(                                     // given:
  a, b,                               // - a, b = input arrays
  p                                   // - p = reference pattern, initially undefined
) => (                                //
  (F = (                              // F is our recursive search function, with:
    a,                                // - a = current working copy of the main array
    i,                                // - i = index in 'b'
    m                                 // - m = minimum index of matching values in 'a'
  ) =>                                //
    1 / b[i] ?                        // if we haven't reached the end of 'b':
      a.map((n, j) =>                 //   for each element 'n' at index 'j' in 'a':
        m > j | n - b[i] ||           //     if 'n' is a valid matching value,
        F(                            //     do a recursive call to F(), using:
          a.filter((_, k) => j - k),  //     - a copy of 'a' without the current element
          i + 1,                      //     - the next index in 'b'
          j                           //     - 'j' as the new minimum index in 'a'
        )                             //
      )                               //
    :                                 // else:
      p ?                             //   if the reference pattern is already set:
        r |= p != a                   //     check if it's matching the current 'a'
      :                               //   else:
        p = a + ''                    //     set the current 'a' as the reference pattern
  )(a, r = 0),                        //  initial call to F() + initialization of 'r'
  !r                                  //  yields the final result
)                                     //

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

কোড স্নিপেট দেখান

— Arnauld
সূত্র
কি দারুন! আমি এ এর ​​হ্রাসকৃত অনুলিপি দিয়ে
— পুনরাবৃত্তি
1

জাভাস্ক্রিপ্ট (ফায়ারফক্স 30+), 159 147 বাইট

f=(a,b,i=f(a,b,0))=>i?i.every(x=>x+""==i[0]):b+b?a+a&&[for(n of a)if(a[i++]==b[0])for(x of f(a.slice(i),b.slice(1),0))[...a.slice(0,i-1),...x]]:[a]

এখানে দু'জন বেনাম ফাংশন, একাধিক বিকল্প পন্থা:

(a,b,f=(a,b,i=0)=>b+b?a+a&&[for(n of a)if(a[i++]==b[0])for(x of f(a.slice(i),b.slice(1)))[...a.slice(0,i-1),...x]]:[a],c=f(a,b))=>c.every(x=>x+""==c[0])
(a,b,f=(a,b,i=0)=>b+b?a+a&&[for(n of a)if(a[i++]==b[0])for(x of f(a.slice(i),b.slice(1)))[...a.slice(0,i-1),...x]]:[a])=>new Set(f(a,b).map(btoa)).size<2

পরীক্ষার স্নিপেট

কোড স্নিপেট দেখান

— ETHproductions
সূত্র
আমি স্নিপেটটিও পছন্দ করি
— edc65
1

গণিত, 128 বাইট

h=Length;n=ToExpression;g=ToString;y=Array;h@Union@ReplaceList[#2,n@Riffle[y["a"<>g@#<>"___"&,t=h@#+1],#]->n@y["a"<>g@#&,t]]==1&

দু'টি তালিকা যুক্তি নিয়ে নামহীন ফাংশন, যেখানে প্রথমটি হ'ল প্রথমটি এবং দ্বিতীয়টি সম্পূর্ণ ক্রম; আউটপুটTrue বা False।

মূল অংশটি নিম্নোক্ত ক্রম, পাঠযোগ্যতার জন্য অবরুদ্ধ:

ReplaceList[#2, ToExpression @
  Riffle[
    Array["a" <> ToString@# <> "___" &, Length@# + 1]
    , #
  ] -> ToExpression @ 
    Array["a" <> ToString@#& , Length@# + 1 ]
]

এখানে উপসর্গের #প্রতিনিধিত্ব করে example উদাহরণস্বরূপ {2,4,5},। প্রথমArray কমান্ড স্ট্রিংয়ের মতো একটি তালিকা তৈরি করে {"a1___","a2___","a3___","a4___"}যা এর পরে Riffleএকসাথে #একটি অদ্ভুত তালিকা তৈরি করতে {"a1___",2,"a2___",4,"a3___",5,"a4___"}; তারপরে এই তালিকাটি একটি আসল গণিতের প্রকাশের জন্য ফেলে দেওয়া হয়েছে। উদাহরণস্বরূপ {2,4,5}, এই মূল কোডটির একটি আংশিক মূল্যায়ন

ReplaceList[#2, {a1___,2,a2___,4,a3___,5,a4___} -> {a1,a2,a3,a4}]

যা ঠিক subsequence মুছে ফেলার জন্য সম্ভাব্য সব উপায়ে একটি তালিকা দেয় {2,4,5}থেকে #2এবং একা তালিকার বিশ্রাম ছেড়ে।

এই তালিকাটি উত্পন্ন হওয়ার পরে, আমরা সহজেই ব্যবহার করে সদৃশগুলি সরিয়ে ফেলি Unionএবং ফলাফলটি আউটপুটটির দৈর্ঘ্য 1 হয় কি না তা পরীক্ষা করি।

— গ্রেগ মার্টিন
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.