27

1গুলি এবং -1এর একটি তালিকা দেওয়া , এটি একটি বৈধ ওভিএসএফ কোড কিনা তা নির্ধারণ করুন (সত্যবাদী বা মিথ্যা মান আউটপুট করে)।

ওভিএসএফ কোডগুলি নিম্নলিখিত হিসাবে সংজ্ঞায়িত করা হয়েছে:

[1] এটি একটি ওভিএসএফ কোড।
যদি Xকোনও ওভিএসএফ কোড হয়, তবে X ++ Xএবং X ++ -Xউভয়ই ওভিএসএফ কোড।

এখানে ++তালিকার সংমিশ্রণ রয়েছে এবং তালিকার -প্রতিটি উপাদানকে এড়িয়ে চলেছে।
অন্য কোনও তালিকা বৈধ ওভিএসএফ কোড নয়।

আপনি ধরে নিতে পারেন ইনপুট তালিকায় কেবল -1এবং রয়েছে 1, তবে আপনাকে অবশ্যই খালি তালিকাটি সঠিকভাবে পরিচালনা করতে হবে, পাশাপাশি সেই তালিকাও রয়েছে যার দৈর্ঘ্য 2 এর শক্তি নয়।

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

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

[] -> False
[1] -> True
[-1] -> False
[1, 1] -> True
[1, -1] -> True
[1, 1, 1, 1] -> True
[1, 1, 1, 1, 1] -> False
[1, -1, -1, 1, -1, 1, 1, -1] -> True
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1] -> True

code-golf array-manipulation decision-problem

— লিন
সূত্র

5

"ওভিএসএফ" কী বোঝায়?

— NoOneIs এখানে

5

অরথোগোনাল ভেরিয়েবল স্প্রেডিং ফ্যাক্টর , যা তাদের ব্যবহারের উপায় এবং তাদের কাছে থাকা একটি দরকারী সম্পত্তিকে বোঝায় । এটি খুব প্রাসঙ্গিক বলে মনে হয় নি, তবে উইকিপিডিয়া লিঙ্কটি এটি সমস্ত ব্যাখ্যা করেছে (অস্পষ্টভাবে)।

— লিন

8

জেলি , 18 16 14 11 বাইট

^2/Eam2µḊ¿Ṭ

[1]OVSF কোডগুলির জন্য আউটপুট (সত্যবাদী), []অন্যথায় (মিথ্যা)।

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

পটভূমি

ভালো লেগেছে @ LuisMendo এর MATL উত্তর এবং @ xnor এর পাইথন উত্তর , এই জমা যাচাই "ভিতরে বাইরে থেকে" ইনপুট অ্যারের।

দুই বা ততোধিক দৈর্ঘ্যের একটি ওভিএসএফ কোডের প্রতিটি (অ-ওভারল্যাপিং) জুটির জুটি হ'ল একই চিহ্ন বা উভয় চিহ্নের সাথে অদলবদল করে প্রথমে প্রথম জোড়াটির অনুলিপি হয়। একইভাবে, চার বা ততোধিক দৈর্ঘ্যের ওভিএসএফ কোডের প্রতিটি (ওভারল্যাপিং) 4-টিপল মূলত একই চিহ্নগুলি বা উভয় চিহ্নই অদলবদল করে প্রথমে প্রথম 4-টিপলের একটি অনুলিপি হয়। ওভিএফএস কোডের দৈর্ঘ্য অবধি 8-টিউপলস, 16 টি-টিপলস ইত্যাদির ক্ষেত্রেও এটি একই।

এটি যাচাই করার একটি উপায় হ'ল সমষ্টিটির জন্য সমস্ত জোড় সাইন ইন করার জন্য প্রথমে যাচাই করা, তারপরে প্রতিটি জোড়ের দ্বিতীয় উপাদানটি (যা এখন অপ্রয়োজনীয় তথ্য) সরান। আমরা যদি আরও একবার এই প্রক্রিয়াটির পুনরাবৃত্তি করি, আমরা মূলত সমস্ত 4 টি-টিপল পরীক্ষা করছি। পরবর্তী পুনরাবৃত্তিতে, আমরা 8-টিপলস ইত্যাদির সাথে তুলনা করছি

অবশেষে, যদি সমস্ত প্রয়োজনীয় 2 ^কে- টিপলস সমান মডিউল ছিল এবং চিহ্নটি অ্যারে কমিয়ে একটি সিঙ্গলটনে রেখে দেওয়া হয়েছিল, তবে অবশিষ্ট উপাদানটি 1 আছে কিনা তা পরীক্ষা করা যথেষ্ট ।

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

^2/Eam2µḊ¿Ṭ  Main link. Argument: A (array of 1's and -1's)

       µḊ¿   While dequeuing A (removing its first element) yields a non-empty
             array, execute the monadic chain to the left, updating A with the
             return value after each iteration.
^2/            Compute the bitwise XOR of each non-overlapping pair of elements of
               A. Note that 1 ^ 1 = 0 = -1 ^ -1 and 1 ^ -1 = -2 = -1 ^ 1.
               For an array of even length that consists of the same pairs modulo
               the sign, this returns either an array of 0's or an array of -2's.
               If the length is odd, it will also contain the last element, which
               is either a 1 or a -1.
   E           Test the elements of the result for equality. This yields 1 if the
               array consists solely of 0's or solely of -2's, 0 otherwise.
    a          Take the logical AND of the previous result and every element of A.
               This returns A if it passed the previous test, but replaces all of
               its elements with 0's otherwise.
     m2        Modulo 2; select every second element of A, starting with the first.
             At this point, the last return value can be:
               • [  ] if the input was empty
               • [ 1] if the input was a valid OVSF code
               • [-1] if the input was the negative of a valid OVSF code.
               • [ 0] in all other cases.
           Ṭ  Untruth; yield an array with 1's at the specified indices.
              Indexing is 1-based in Jelly, so [1] returns [1], the array with a 1
              at index 1. Since the indices -1 and 0 are non-canonical, the arrays
              [-1] and [0] are mapped to []. The empty array remains empty.

— ডেনিস
সূত্র

14

গণিত, 52 47 45 বাইট

বাইট গণনাটি সিপি -1222 এনকোডিং ধরে এবং $CharacterEncodingসেট করে WindowsANSI(উইন্ডোজ ইনস্টলেশনতে ডিফল্ট)।

±___=!(±1=1>0)
a__±b__/;a!==b!||{a}==-{b}:=±a

এটি একটি বৈকল্পিক ফাংশন সংজ্ঞায়িত করে PlusMinus, যা ইনপুট তালিকাটিকে আর্গুমেন্টের ফ্ল্যাট তালিকা হিসাবে গ্রহণ করে এবং একটি বুলিয়ান প্রদান করে, যেমন PlusMinus[1, -1, -1, 1]দেয় True। এটা তোলে তাত্ত্বিক এছাড়াও একটি অপারেটর হিসাবে ব্যবহারযোগ্য এর ±, কিন্তু যে অপারেটর, শুধুমাত্র ইউনারী ও বাইনারি প্রেক্ষিতে চিহ্নগুলি সিন্টেক্সের বৈধ তাই কলিং সম্মেলন অদ্ভুত পেতে হবে: ±##&[1,-1,-1,1]। এটি উপেক্ষা করা যেতে পারে এমন একগুঁয়ে সতর্কতা ফেলে দেবে।

এটি কিছু সতর্কতাও ফেলে দেবে যা উপেক্ষা করা যেতে পারে।

সেখানে পারে কিছুটা বিরক্তিকর কমান দূরে থাকতে a!==b!||{a}==-{b}অংশ, কিন্তু আমি কিছুই মুহূর্তে খোঁজার করছি। কীওয়ার্ডগুলি পছন্দ SubsetQএবং MatrixRankখুব দীর্ঘ। : /

ব্যাখ্যা

সমাধানটি মূলত ম্যাথমেটিকার প্যাটার্ন ম্যাচারে সমস্ত ছদ্মবেশী বিষয়গুলিকে পিছনে দেয় এবং তাই স্টাইলে এটি খুব ঘোষিত rative প্রথম লাইনে কিছু গল্ফিউটিড ছাড়াও এটি অপারেটরের জন্য কেবল তিনটি পৃথক সংজ্ঞা যুক্ত করেছে ±:

±___=False;
±1=True;
a__±b__/;a!==b!||{a}==-{b}:=±a

প্রথম দুটি সারি সংক্ষিপ্ত করে সংজ্ঞাগুলি নীড় করে এবং Trueহিসাবে প্রকাশ করেছিল 1>0।

আমাদের PlusMinusকেবল এটি অ্যানারি এবং বাইনারি অপারেটর স্বরলিপি ব্যবহার করে কীভাবে এটি একটি ভেরাদাদি ফাংশনটি সংজ্ঞায়িত করে তা আরও ডিকনস্ট্রাক্ট করা উচিত । ধরাটি হ'ল সমস্ত অপারেটরগুলি সম্পূর্ণ এক্সপ্রেশনগুলির জন্য কেবল সিনট্যাকটিক চিনি। আমাদের ক্ষেত্রে ±সম্পর্কিত PlusMinus। নিম্নলিখিত কোডটি 100% সমতুল্য:

PlusMinus[___]=False;
PlusMinus[1]=True;
PlusMinus[a__,b__]/;a!==b!||{a}==-{b}:=PlusMinus[a]

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

সংজ্ঞা অনুযায়ী:

প্রথম সংজ্ঞাটি কেবল ফ্যালব্যাক ( ___আর্গুমেন্টের একটি স্বেচ্ছাসেবী তালিকার সাথে মেলে)। নীচে আরও নির্দিষ্ট সংজ্ঞা দিয়ে মিলছে না এমন কিছু দেবে False।

দ্বিতীয় সংজ্ঞাটি ওভিএসএফের বেস কেস, কেবলমাত্র তালিকাটি রয়েছে 1। আমরা এটি হতে সংজ্ঞায়িত True।

শেষ অবধি, তৃতীয় সংজ্ঞাটি কেবলমাত্র সেই তালিকাগুলিতেই প্রযোজ্য যাগুলি দ্রবীভূত হতে পারে X ++ Xবা এর X ++ -Xজন্য ফলাফলটি পুনরাবৃত্তভাবে ব্যবহার করে X। সংজ্ঞা নিশ্চিত তারা subsequences বিভক্ত করা পারে এই তালিকাগুলি সীমাবদ্ধ aএবং bসঙ্গে a__±b__এবং তারপর শর্ত (সংযোজনের /;) যে পারেন {a}=={b}বা {a}==-{b}। ডিফাইনিং PlusMinusএকটি অপারেটর এর মাধ্যমে এই অদ্ভুত ভাবে একটি variadic ফাংশন হিসাবে একটি খুব বড় সংরক্ষণ 5 একটি ইউনারী অপারেটর সংজ্ঞা উপর বাইট ±তালিকা করেন।

তবে অপেক্ষা করুন, আরও কিছু আছে। আমরা এর a!==b!পরিবর্তে ব্যবহার করছি {a}=={b}। স্পষ্টতই, আমরা এটি করছি কারণ এটি দুটি বাইট ছোট, তবে আকর্ষণীয় প্রশ্নটি এটি কেন কাজ করে। আমি উপরে ব্যাখ্যা করেছি, সমস্ত অপারেটর একটি মাথা দিয়ে কিছু এক্সপ্রেশন জন্য কেবল সিনট্যাকটিক চিনি। {a}হয় List[a]। তবে aএটি একটি সিকোয়েন্স (যেমন আমি বলেছি, অন্যান্য ভাষায় ছড়িয়ে ছিটিয়ে থাকা মতো) তাই যদি aহয় 1,-1,1তবে আমরা পাই List[1,-1,1]। এখন পোস্টফিক্স !হয় Factorial। সুতরাং এখানে, আমরা পেতে চাই Factorial[1,-1,1]। তবে Factorialযখন এটির তুলনায় একের চেয়ে বিভিন্ন যুক্তি রয়েছে তখন কী করতে হবে তা জানে না, তাই এটি কেবল অপরিবর্তিত থাকে। ==উভয় পক্ষের জিনিসগুলি তালিকাভুক্ত হলে সত্যিই যত্নশীল হয় না, এটি কেবলমাত্র প্রকাশের সাথে তুলনা করে এবং যদি তারা সমান হয় তবে এটি দেয়True( Falseএক্ষেত্রে , এটি না দিলে এটি আসলে দেয় না, তবে শর্ত ব্যতীত অন্য কোনও কিছু ফেরত দিলে প্যাটার্নগুলি মেলে না True)। সুতরাং এর অর্থ, তালিকায় কমপক্ষে দুটি উপাদান থাকলে সাম্যতা পরীক্ষা করা এখনও কাজ করে। সেখানে যদি কেবল একটাই থাকে? যদি aহয় 1তবে a!এখনও আছে 1। যদি aহয় -1তবে a!দেয় ComplexInfinity। এখন, নিজের সাথে তুলনা 1করা এখনও অবশ্যই ঠিক কাজ করে। কিন্তু ComplexInfinity == ComplexInfinityঅবমূল্যায়িত থেকে যায়, এবং সত্য দেয় না যদিও a == -1 == b। ভাগ্যক্রমে, এটি কোনও ব্যাপার নয়, কারণ এটির মধ্যে দেখা যাচ্ছে কেবলমাত্র পরিস্থিতি PlusMinus[-1, -1]যা কোনওভাবেই বৈধ ওভিএসএফ নয়! (যদি শর্তটি ফিরে আসে Trueতবে পুনরাবৃত্ত কলটি রিপোর্ট করবেFalseসর্বোপরি, সুতরাং এটি পরীক্ষা করে না যে চেকটি কার্যকর হয় না)) আমরা একই কৌশলটি ব্যবহার করতে পারি না {a}==-{b}কারণ -থ্রেডটি থ্রেড হবে না Factorial, এটি কেবল থ্রেড করে List।

প্যাটার্ন ম্যাচারটি বিশ্রামের যত্ন নেবে এবং প্রয়োগ করার জন্য সঠিক সংজ্ঞাটি সন্ধান করবে।

— মার্টিন ইন্ডার
সূত্র

9

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

q=length
f l=l==until((>=q l).q)(\s->s++map(*l!!q s)s)[1]

ইনপুট তালিকা দেওয়া l, একটি OVSF কোড বৃদ্ধি sথেকে শুরু করে [1]এবং বারবার concatenating পারেন sবা -sযেটা যে প্রথম উপাদান ম্যাচ করে তোলে, l। তারপরে, ফলাফলটি lশেষে রয়েছে তা পরীক্ষা করে। এটি একবার sঅন্তত দৈর্ঘ্য দৈর্ঘ্য হয় যাচাই করা হয় l।

কিছু বিকল্প পুনরাবৃত্ত স্ট্রাকচার 57 প্রদানের ক্ষেত্রে ঘটেছিল:

(s%i)l|length l<=i=s==l|j<-2*i=(s++map(*l!!i)s)%j$l
[1]%1

q=length
s%l|q s>=q l=s==l|r<-s++map(*l!!q s)s=r%l
([1]%)

q=length
g s l|q s<q l=g(s++map(*l!!q s)s)l|1>0=s==l
g[1]

— xnor
সূত্র

6

ম্যাটল্যাব / অষ্টাভে , 94 বাইট

function a=f(r);n=nnz(r);m=log2(n);a=0;if fix(m)-m==0;for c=hadamard(n);a=a+all(r==c');end;end

এটি একটি নতুন পদ্ধতির ব্যবহার করছে: দৈর্ঘ্য মঞ্জুরিপ্রাপ্ত OVSF কোড Nপ্রদর্শিত log2(N)-th ওয়ালশ-ম্যাট্রিক্স , তারা মূলত একই পুনরাবৃত্তির দ্বারা সংজ্ঞায়িত করা হয়:

$H(2^k) = H(2)\otimes H(2^{k-1})$

যদি দুটি পাওয়ার হয় তবে ওয়ালশ ম্যাট্রিকগুলি হাদামার্ড-ম্যাট্রিকের আকারের বিশেষ ক্ষেত্রে । (এছাড়া আরও কিছু আকারের Hadamard ম্যাট্রিক্স আছে।) ম্যাটল্যাব এবং অক্টেভ ক্রিয়াকাণ্ড, সংখ্যাসূচক আলগোরিদিম পরীক্ষা বৈশিষ্ট্য পরীক্ষা ম্যাট্রিক্স উৎপন্ন মধ্যে তাদের হয় সালে নির্মিত বিভিন্ন আছে । ভাগ্যক্রমে দুটি ম্যাটল্যাবের ইউজএক্সের পাওয়ারের জন্য ঠিক ওয়েলশ-ম্যাট্রিক্সের নির্মাণ।N x NNhadamard()hadamard()

সুতরাং এই ফাংশনটি প্রথমে ইনপুটগুলির দৈর্ঘ্য দুটি হ'ল কিনা তা পরীক্ষা করে দেখেছে এবং যদি এটি হয় তবে এটি এটি একই আকারের ওয়েলশ-ম্যাট্রিক্সের সারি কিনা তা পরীক্ষা করে।

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

— flawr
সূত্র

5

পাইথন, 64 বাইট

f=lambda l:[]<l[1::2]==[x*l[1]for x in l[::2]]*f(l[::2])or[1]==l

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

বেস কেসের ক্ষেত্রে, যদি চেক ব্যর্থ হয় তবে তালিকাটি না থাকলে প্রত্যাখ্যান করে [1]। অসীম লুপ এড়াতে খালি তালিকাটিও বিশেষভাবে প্রত্যাখ্যান করা হয়।

আমার হাস্কেল উত্তরের মতো একটি ভিন্ন কৌশল 66 বাইট দেয়:

f=lambda l,i=1,s=[1]:l[i:]and f(l,i*2,s+[x*l[i]for x in s])or s==l

— xnor
সূত্র

2

হাস্কেল , 106 91 87 86 বাইট

g n|n<1=[[1]]|m<-g(n-1)=foldl(\a b->[b++map(0-)b,b++b]++a)[]m++m
f l=elem l$g$length l

ফাংশন তালিকাগুলির পুনরাবৃত্তি gতৈরি করে n(তুলনামূলকভাবে অযোগ্যভাবে, যেহেতু length $ g n == 3^n, আমরা যদি নকলগুলি মুছে ফেলতাম, আমরা পেয়ে যাব 2^n), fআমাদের তালিকা তাদের কোনও একটিতে আছে কিনা তা পরীক্ষা করে। কয়েকটি ইঙ্গিতের জন্য @ জিগ্রাবকে ধন্যবাদ!

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

— flawr
সূত্র

সর্বশেষ 2 টি পরীক্ষার কেস চালানো আমার পক্ষে ফলাফল দেয় নি।

— অলিভার

@ ওবরকন ইয়েপ, এটি অত্যন্ত অদক্ষ এবং কারণ gএটি একটি টন নকল তৈরি করে। ( ডিবাগ বিভাগটি পরীক্ষা করুন , এটি সম্ভবত সময় বা মেমরির সীমাবদ্ধতার কারণে))

— flawr

2

জাভাস্ক্রিপ্ট (ES6), 130 93 87 85 83 বাইট

f=a=>(b=a.slice(0,l=a.length/2),c=a.slice(l)+"",a==1||l&&b==c|b.map(i=>-i)==c&f(b))

ডেমো

f=a=>(b=a.slice(0,l=a.length/2),c=a.slice(l)+"",a==1||l&&b==c|b.map(i=>-i)==c&f(b)),[[],[1],[-1],[1,1],[1,-1],[1,1,1,1],[1,1,1,1,1],[1,-1,-1,1,-1,1,1,-1],[1,1,1,1,-1,-1,-1,-1,1,1,1,1],[1,1,1,1,-1,-1,-1,-1,1,1,1,1,1,1,1,1],[1,1,1,1,-1,-1,-1,-1,1,1,1,1,-1,-1,-1,-1]].map(a=>console.log(`[${a}] -> ${!!f(a)}`))

স্নিপেট প্রসারিত করুন

— প্যাট্রিক রবার্টস
সূত্র

2

জাভাস্ক্রিপ্ট (ES6), 85 61 বাইট

a=>(l=a.length)&&!(l&l-1)&a.every((e,i)=>e==a[j=i&-i]*a[i-j])

পূর্ববর্তী সংস্করণ তা নিশ্চিত করার জন্য তারা ছিল উপাদান চেক করা 1বা -1:

a=>(l=a.length)&&!(l&l-1)&a.every((e,i)=>i?(j=i&-i)<i?e==a[j]*a[i-j]:e==1|e==-1:e==1)

ব্যাখ্যা:

দৈর্ঘ্য শূন্য হতে পারে না
দৈর্ঘ্য 2 এর শক্তি হতে হবে
প্রথম উপাদানটি 1 হতে হবে
2 এর শক্তির পজিশনে উপাদানগুলি 1 বা -1 হওয়া আবশ্যক
অন্যান্য অবস্থানকে উপাদানসমূহ বিট-মাস্কের, যেমন সংশ্লিষ্ট অবস্থানকে সব উপাদান এই প্রক্রিয়ার উপজাত a[22] == a[2] * a[4] * a[16]। যেহেতু a[20] == a[4] * a[16]ইতিমধ্যে চেক করা হয়েছে, কেবলমাত্র a[22] == a[2] * a[20]চেক করা দরকার।
উপরের চেকটি iকমপক্ষে দুটি বিট সেট না করার জন্য অধঃপতিত ফলাফল দেয় । শূন্য বিটস সেট এর ক্ষেত্রে এটি যাচাই করে a[0] == a[0] * a[0]যা এটি মিথ্যা a[0] == -1, অন্যদিকে কিছু বিটের ক্ষেত্রে এটি পরীক্ষা করে a[i] == a[0] * a[i]।

— নিল
সূত্র

আপনি 4 বাইট সংরক্ষণ করতে পরিবর্তন (l=a.length)&&!(l&l-1)করতে পারেন(l=a.length)&-l==l

— প্যাট্রিক রবার্টস

@ পেট্রিকরবার্টস এর পক্ষে কি সত্য নয় l==0?

— নিল

ওহ আপনি ঠিক. আচ্ছা তাহলে (l=a.length)&&l&-l==l? 1 বাইট সংরক্ষণ করতে ...

— প্যাট্রিক রবার্টস

আসলে কিছুই নয়, [1,1,1,1,-1,-1,-1,-1,1,1,1,1,1,1,1,1]এমনকি আমার পরামর্শ ছাড়াই আপনার কার্যকারিতা ব্যর্থ হয় ।

— প্যাট্রিক রবার্টস

@ পেট্রিকরবার্টস l&-l==lকাজ করে না কারণ ==এর চেয়ে বেশি অগ্রাধিকার রয়েছে &। এবং পরীক্ষার কেসটি টাইপোর কারণে কাজ করে না যা ঠিক করতে আমার একটি বাইট লাগবে।

— নিল

2

এমএটিএল , 21 20 বাইট

`2eZ}yy=&=tn1>hh]1X=

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

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

কোডটি অ্যারেটিকে দুটি সমান-দৈর্ঘ্যের টুকরোতে বিভক্ত করে: প্রথমটি বিজোড়-সূচকযুক্ত এন্ট্রি সহ, দ্বিতীয়টি সম-সূচকযুক্ত এন্ট্রি সহ। দুটি টুকরা সমান দৈর্ঘ্য করতে বাধ্য হয়, প্রয়োজনে দ্বিতীয়টিতে প্যাডিং শূন্য সহ। তারপরে কোডটি এটি পরীক্ষা করে

দুটি টুকরো সম্পর্কিত এন্ট্রিগুলি হয় সমস্ত সমান বা সমস্ত আলাদা;
দ্বিতীয় অংশে কোনও প্রবেশ শূন্য নয়;
টুকরাগুলির দৈর্ঘ্য 1 ছাড়িয়ে গেছে।

এই তিনটি শর্ত পূরণ করা হলে, প্রক্রিয়া আবার প্রথম টুকরা প্রয়োগ করা হয়। যদি লুপটি প্রস্থান করা হয় কারণ দৈর্ঘ্য ইতিমধ্যে 1 ছিল, ইনপুটটি একটি অফএসভি কোড। অন্যথায় এটি না।

শর্ত 1 পুনরুক্তি করা হল ওভিএসএফ কোডগুলির সংজ্ঞায়িত সংস্থার সমতুল্য সংস্করণ। দৈর্ঘ্য ৮ এর অ্যারের জন্য, সোজা পদ্ধতিতে পরীক্ষা করা উচিত যে 1,2,3,4 এন্ট্রি যথাক্রমে 5,6,7,8 এন্ট্রিগুলিতে (এটিই সংজ্ঞায়িত সম্পত্তি) equal তবে আমরা সমানভাবে পরীক্ষা করতে পারি যে 1,3,5,7 এন্ট্রি যথাক্রমে 2,4,6,8 এন্ট্রিতে সমস্ত সমান বা পৃথক; এবং এটি কম বাইট ব্যবহার করে।

শর্ত 2 নিশ্চিত করে যে ইনপুট দৈর্ঘ্য 2 এর শক্তি: এটি যদি না হয় তবে কোনও পর্যায়ে শূন্য শূন্য প্রবর্তিত হবে।

`        % Do...while loop
  2e     %   Reshape as a two-row matrix, with a padding zero if needed
         %   Row 1 contains the original odd-indexed entries, row 2 the
         %   even-indexed
  Z}     %   Split matrix into two vectors, one corresponding to each row
  yy     %   Duplicate those two vectors
  =      %   Check if corresponding entries are equal or not
  &=     %   Matrix of all pairwise comparisons. This will give a matrix
         %   filled with ones if and only if the previous check gave all
         %   true or all false (condition 1)
  tn1>   %   Duplicate and push true if size exceeds 1, or false otherwise
         %   (condition 3)
  hh     %   Concatenate condition 1, condition 3, and the original copy of
         %   the second piece (condition 2). The resulting vector is truthy
         %   if and only if it doesn't contain any zero
]        % End
1X=      % True if top of the stack is a single 1, false otherwise

— লুইস মেন্ডো
সূত্র

2

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

হ্যাঁ, অনন্ত তালিকা!

o=[1]:(o>>= \x->[x++map(0-)x,x++x])
f l=l`elem`take(2*2^length l)o

বিকল্প সংস্করণ:

o=[1]:(o<**>map(>>=flip(++))[map(0-),id])
f=Data.List.Ordered.hasBy(comparing length)o

— Bergi
সূত্র

(0-)কৌতুকের জন্য ধন্যবাদ , আমি negateবা আটকে ছিলাম((-1)*)

— বার্গি

1

এপিএল, 46 বাইট

{0::0⋄⍵≡,1:1⋄⍬≡⍵:0⋄(∇Z↑⍵)∧(∇Y)∨∇-Y←⍵↓⍨Z←.5×⍴⍵}

মোটামুটি সহজবোধ্য:

বেস কেসগুলি:
- 0::0: যদি কোনও ত্রুটি দেখা দেয় তবে 0 ফিরে আসুন
- ⍵≡,1:1: যদি ইনপুটটি ঠিক হয় [1], ফিরে 1
- ⍬≡⍵:0: যদি ইনপুটটি খালি তালিকা হয় তবে 0 এ ফিরে আসুন
পুনরাবৃত্তির ক্ষেত্রে:
- Z←.5×⍴⍵: Zইনপুট অর্ধেক দৈর্ঘ্য
- Y←⍵↓⍨Z: Yইনপুটটির শেষ অর্ধেক ( ⍴⍵ব্যতিক্রম হ্যান্ডলারটি ট্রিগার করে এটি অসম হলে এটি ব্যর্থ হয়)
- (∇Y)∨∇-Y: হয় তালিকার শেষ অর্ধেক, বা তালিকার শেষ অর্ধেকের অস্বীকৃতি অবশ্যই একটি ওভিএসএফ কোড হতে হবে
- (∇Z↑⍵)∧: এবং তালিকার প্রথমার্ধটি অবশ্যই একটি ওভিএসএফ কোড হতে হবে।

— সামুদ্রিক
সূত্র

1

আমি মনে করি না দ্বিতীয়ার্ধের জন্য ওভিএসএফ-কোডেনেস পরীক্ষা করার পক্ষে এটি যথেষ্ট; এটি প্রথমার্ধের বা তার অবহেলার সমান হওয়া উচিত।

— জগারব

1

তারা বলেছে বেসিকটি একটি উচ্চ স্তরের হ্রাস এবং এপিএল একটি উচ্চ স্তরের যন্ত্রণা: ')

— বিড়াল

তারা বলেছে বেসিকটি একটি উচ্চ স্তরের হ্রাস এবং এপিএল একটি উচ্চ স্তরের যন্ত্রণা: ')

— বিড়াল

1

হাস্কেল, 69 68 বাইট

g x=any(elem x)$scanr(\_->concat.mapM(\y->[y++y,y++map(0-)y]))[[1]]x

ব্যবহারের উদাহরণ: g [-1,1]-> False।

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

take 10 $ c $ scanr(\_->concat.mapM(\y->[y++y,y++map(0-)y]))[[1]] [1..4]

যা ফিরে আসে

[[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
 [1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1],
 [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
 [1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1],
 [1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1],
 [1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1],
 [1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1],
 [1,-1,-1,1,1,-1,-1,1,1,-1,-1,1,1,-1,-1,1],
 [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
 [1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1]]

অর্থাত্ তালিকাটি 16 টি উপাদান তালিকা দিয়ে শুরু হয় (4 বার সংক্ষিপ্ত আকারের কারণে [1..4]), সমস্ত 8 এলিমেন্টের তালিকা এবং তাই শেষ না হওয়া অবধি অবিরত থাকে [1]।

সম্পাদনা করুন: @ এক্সনর একটি বাইট সংরক্ষণ করেছেন। ধন্যবাদ!

— nimi
সূত্র

আহ, আমি পুরোপুরি ভুলে গেছি scanr!

— flawr

আমার মনে হয় আপনি করছেন দ্বারা একটি বাইট কেটে যাবে any(elem x)পরিবর্তে elem x$cএবং সংজ্ঞা c।

— xnor

1

পাইথন 2 , 78 75 বাইট

def f(x):l=len(x)/2;return[n*x[l]*f(x[:l])for n in x[l:]]==x[:l]>[]or[1]==x

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

— ডেনিস
সূত্র

0

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

f=(l,k=[1])=>l+l==k+k||l[k.length]&&f(l,k.concat(k))|f(l,k.concat(k.map(v=>-v)))

পুনরাবৃত্তভাবে প্রতিটি তালিকা তৈরি করে ইনপুট তালিকার দৈর্ঘ্য পর্যন্ত পরীক্ষা করে দেখুন [1]।

ফেরত মান জাতীয় truthy বা falsey, নির্দিষ্টভাবে হয় 1বা trueবৈধ হলে, 0বা falseঅথবা undefinedযদি বৈধ না।

পরীক্ষা

f=(l,k=[1])=>l+l==k+k||l[k.length]&&f(l,k.concat(k))|f(l,k.concat(k.map(v=>-v)))

test=`[] -> False
[1] -> True
[-1] -> False
[1, 1] -> True
[1, -1] -> True
[1, 1, 1, 1] -> True
[1, 1, 1, 1, 1] -> False
[1, -1, -1, 1, -1, 1, 1, -1] -> True
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1] -> False
[1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1] -> True`
.split('\n')

test.forEach(r=>{
  input = r.match(/-?1/g)||[]
  check = r.slice(-4) == 'True'
  result = f(input)
  console.log(result, check, '['+input+']')
})

স্নিপেট প্রসারিত করুন

— edc65
সূত্র

0

ক্লোজার, 118 বাইট

(defn f[C](or(=(count C)1)(let[l(/(count C)2)[a b](split-at l C)](and(> l 0)(=(count b)l)(apply =(map * a b))(f a)))))

cদুটি অংশে ইনপুট বিভক্ত করে aএবং bতাদের উপাদান অনুসারে পণ্যগুলি সমস্ত অভিন্ন কিনা তা পরীক্ষা করে। যদি তা হয় তবে প্রথমার্ধটি বৈধ ক্রম।

এটি একটি 142 বাইট তবে আমি এটি আরও আকর্ষণীয় বলে মনে করেছি:

#((set(nth(iterate(fn[I](mapcat(fn[i][(concat i i)(concat i(map - i))])I))[[1][-1]])(loop[l(count %)i 0](if(< l 2)i(recur(/ l 2)(inc i))))))%)

loopইনপুটটির log_2দৈর্ঘ্যের গণনা iterateকরে, সংজ্ঞা অনুসারে বহু পুনরাবৃত্তির ক্রম উত্পন্ন করে। এটি কোনও বৈধ ক্রম এবং nilঅন্যথায় যদি ইনপুট আর্গুমেন্টটি দেয় ।

— NikoNyrh
সূত্র

এটি কি ওভিএসএফ কোড?

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

জেলি , 18 16 14 11 বাইট

পটভূমি

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

গণিত, 52 47 45 বাইট

ব্যাখ্যা

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

ম্যাটল্যাব / অষ্টাভে , 94 বাইট

পাইথন, 64 বাইট

হাস্কেল , 106 91 87 86 বাইট

জাভাস্ক্রিপ্ট (ES6), 130 93 87 85 83 বাইট

ডেমো

জাভাস্ক্রিপ্ট (ES6), 85 61 বাইট

এমএটিএল , 21 20 বাইট

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

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

এপিএল, 46 বাইট

হাস্কেল, 69 68 বাইট

পাইথন 2 , 78 75 বাইট

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

ক্লোজার, 118 বাইট