हम एक बिनार्रे को निम्न गुणों को संतुष्ट करने वाले एक सरणी के रूप में परिभाषित करते हैं:

यह गैर-खाली है
पहला मान है a 1
अंतिम मान है a 1
अन्य सभी मूल्य 0या तो हैं1

उदाहरण के लिए, सरणी [ 1, 1, 0, 1 ]एक वैध द्वैध है ।

काम

गैर-नकारात्मक पूर्णांक A और एक ऋणात्मक पूर्णांक N के एक गैर-खाली सरणी को देखते हुए , आपका काम लंबाई N की एक दूरदर्शी बी को खोजना है, जो कि एक अप्रतिबंधित संख्या द्वारा स्थानांतरित B की प्रतियों की अप्रतिबंधित संख्या को जोड़कर A को उत्पन्न करने की अनुमति देता है । पदों।

उदाहरण

A = [ 1, 1, 2, 4, 1, 2, 2, 1, 0, 1, 0, 1, 1, 0, 1 ]
N = 4

इस इनपुट के लिए, बिनारे B = [ 1, 1, 0, 1 ] एक वैध उत्तर होगा क्योंकि हम कर सकते हैं:

  [ 1, 1, 0, 1 ]
+       [ 1, 1, 0, 1 ]
+       [ 1, 1, 0, 1 ]
+          [ 1, 1, 0, 1 ]
+                   [ 1, 1, 0, 1 ]
+                                  [ 1, 1, 0, 1 ]
  -----------------------------------------------
= [ 1, 1, 2, 4, 1, 2, 2, 1, 0, 1, 0, 1, 1, 0, 1 ]

नियम

इनपुट किसी भी उचित प्रारूप में लिया जा सकता है।
आउटपुट या तो एक देशी सरणी हो सकता है (उदाहरण के लिए [1, 1, 0, 1]) या एक विभाजक के साथ या बिना एक बाइनरी स्ट्रिंग (जैसे "1,1,0,1"या "1101")
आपको केवल एक वैध बिनार को प्रिंट या वापस करना आवश्यक है । वैकल्पिक रूप से, आप कई समाधानों के मौजूद होने पर उन सभी को प्रिंट या वापस करने का विकल्प चुन सकते हैं।
आपको उन इनपुट का समर्थन करने की आवश्यकता नहीं है जो किसी भी समाधान के लिए नेतृत्व नहीं करते हैं।
इस राशि में निहित शून्य शामिल हो सकते हैं जो बी की किसी भी प्रति के साथ ओवरलैप नहीं होते हैं । उपरोक्त योग में दूसरा शून्य एक अंतर्निहित शून्य है।
आप मान सकते हैं कि A का अधिकतम आकार 100 है और B का अधिकतम आकार 30 है।
यह कोड-गोल्फ है, इसलिए बाइट्स में सबसे कम जवाब जीतता है। मानक खामियों को मना किया जाता है।

परीक्षण के मामलों

Input : N = 1 / A = [ 1, 2, 3, 4, 5 ]
Output: [ 1 ]

Input : N = 2 / A = [ 1, 2, 100, 99 ]
Output: [ 1, 1 ]

Input : N = 3 / A = [ 1, 1, 1 ]
Output: [ 1, 1, 1 ]

Input : N = 3 / A = [ 1, 1, 3, 2, 2 ]
Output: [ 1, 1, 1 ]

Input : N = 3 / A = [ 1, 0, 2, 1, 1, 1, 0, 0, 1, 0, 1 ]
Output: [ 1, 0, 1 ]

Input : N = 4 / A = [ 1, 2, 2, 2, 1 ]
Output: [ 1, 1, 1, 1 ]

Input : N = 4 / A = [ 1, 1, 2, 4, 1, 2, 2, 1, 0, 1, 0, 1, 1, 0, 1 ]
Output: [ 1, 1, 0, 1 ]

Input : N = 4 / A = [ 1, 1, 0, 2, 1, 0, 1 ]
Output: [ 1, 0, 0, 1 ] or [ 1, 1, 0, 1 ]

Input : N = 5 / A = [ 1, 3, 6, 9, 8, 6, 3, 4 ]
Output: [ 1, 1, 1, 0, 1 ]

Input : N = 8 / A = [ 2, 1, 0, 2, 3, 3, 1, 2, 1 ]
Output: [ 1, 0, 0, 1, 1, 1, 0, 1 ]

Input : N = 10 / A = [ 1, 2, 1, 2, 2, 1, 3, 3, 3, 2, 3, 0, 2, 1, 1, 0, 1 ]
Output: [ 1, 1, 0, 1, 0, 1, 1, 1, 0, 1 ]

Input : N = 13 / A = [ 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1 ]
Output: [ 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 ]

Input : N = 5 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 1, 1, 1, 1 ]

Input : N = 6 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 0, 0, 0, 0, 1 ]

Input : N = 7 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 1, 0, 0, 0, 1, 1 ]

Input : N = 9 / A = [ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ]
Output: [ 1, 0, 1, 0, 1, 0, 1, 0, 1 ]

code-golf array-manipulation polynomials

— Arnauld
स्रोत

Nयथोचित समर्थन किया जाना चाहिए इसका सबसे बड़ा मूल्य क्या है ?

— नील

@ नील मैंने A और B. दोनों पर आकार सीमाएँ जोड़ दी हैं

— Arnauld

1

@ f @n youtɪk हो सकता है, लेकिन इसके लिए N=4, A = [ 1, 1, 2, 4, 1, 2, 2, 2, 1, 2, 2, 1, 2, 0, 1 ], आपको 30459 मिलता है जो 11 और 13 दोनों से विभाज्य है और अभी तक केवल एक ही है [ 1, 1, 0, 1 ]और [ 1, 0, 1, 1 ]एक वैध उत्तर है।

— नील

1

@ f @n basetɪk ये संख्याएँ आधार 2 में नहीं लिखी गई हैं इसलिए अंकगणित के नियम लागू नहीं होते हैं। उदाहरण के लिए, आप स्पष्ट रूप से जोड़ते समय नहीं ले जा सकते।

— BallpointBen

2

कृपया इन परीक्षण मामलों को जोड़ें, जो लगभग सभी पोस्ट किए गए उत्तरों को तोड़ते प्रतीत होते हैं: एन = 3, ए = [1, 0, 2, 0, 2, 0, 1], आउटपुट = [1, 0, 1]; एन = 3, ए = [1, 1, 1, 0, 0, 0, 1, 1, 1], आउटपुट = [1, 1, 1]।

— एंडर्स कासोर्ग

8

PHP, 105 92 90 86 बाइट्स

Jörg solutions समाधान तय और गोल्फ:

for($b=1+2**$argv[1];;)--$argc>1?$s+=$argv[$argc]*2**$i++:$s%($b-=2)||die(decbin($b));

Nपहले कमांड लाइन तर्क से लेता है, उसके बाद के मान; इसे ऑनलाइन चलाएं -rया परीक्षण करें ।
बाइनरी नंबर (प्रारूप 10001) प्रिंट करता है ; अमान्य समाधान प्रिंट करता है या कोई वैध समाधान न होने पर मृत हो जाता है।

पहला संस्करण (अब 97 बाइट्स) जो अमान्य इनपुट के लिए कुछ भी प्रिंट नहीं करता है: इसे ऑनलाइन परीक्षण करें

for($b=1+$m=2**$argv[1];$m/2<=$b;)--$argc>1?$s+=$argv[$argc]*2**$i++:$s%($b-=2)||die(decbin($b));

टूट - फूट

for($b=1+$m=2**$argv[1];$m/2<=$b;)  # second loop: loop $b from 2^N-1 by -2 to 2^(N-1)
--$argc>1                           # first loop: decrease $argc ...
    ?$s+=$argv[$argc]*2**$i++           # while $argc>1: binary sum from last to 2nd argument
    :$s%($b-=2)||die(decbin($b));       # later: if $b divides $s, print in binary and exit

— टाइटस
स्रोत

क्या आप 100 के नीचे बाइट की गिनती तक नहीं पहुंच सकते हैं?

— जोर्ज हल्सरमैन

1

@ JörgHülsermann मैं कर सकता था।

— टाइटस

भारी सोच। मुझे इससे पहले पता है कि आप बेहतर हैं। मुझे आशा है कि आप सबसे कम बाइट की गिनती कर सकते हैं

— जोर्ग हल्सरमैन

1

एन = 3, ए = [1, 0, 2, 0, 2, 0, 1] पर, यह गलत तरीके से लौटता है111 जहां एकमात्र सही परिणाम [1, 0, 1] है।

— एंडर्स केसरग

8

PHP , 219 बाइट्स

<?for(list($g,$z)=$_GET,$d=~-$l=2**$z;$d>=$l/2;max(array_diff_assoc($r,$g)?:[0])?:$o[]=$b,$d-=2)for($r=[],$b=decbin($d),$k=0;$k<count($g);$k++)for($u=$g[$k]-$r[$k],$i=0;$i<$z;$i++)$u<1?:$r[$k+$i]+=$u*$b[$i];print_r($o);

इसे ऑनलाइन आज़माएं!

-4 बाइट्स का उपयोग [$g,$z]=$_GETPHP 7.1 के बजायlist($g,$z)=$_GET

— जार्ग हुल्सरमैन
स्रोत

ऐसा लगता है कि यह अंतिम परीक्षण मामले के लिए वैध ( [1,0,1,0,1,0,1,0,1]) और अमान्य उत्तर ( [1,0,0,0,1,0,1,1,1]) दोनों का आउटपुट देता है ।

— Arnauld

-8 बाइट्स: while($_GET[0])$s+=2**$i++*array_pop($_GET[0]);। -5 बाइट्स range(1|.5*$m=2**$_GET[1],$m,2):।

— टाइटस

@ अर्नुलद हाँ, मुझे आउटपुट के रूप में केवल उच्चतम बिनार भी देना चाहिए जो इस समाधान को वैध

— बनाता

2

@ f @n mathtɪk मैं आपके गणित से सहमत हूं, लेकिन चुनौती एक ऐसे पैटर्न को खोजने के बारे में है, जिसे ए के बराबर सम्‍मिलित किया जा सकता है, समतुल व्यवस्था नहीं। यहाँ, हम मिलेगा [ 1,0,1,1,1,0,2,2,2,2,2,1 ]।

— अरनौलद

1

-1 बाइट के साथ for($g=$_GET[0];$g;)।

— टाइटस

3

पायथन, 166 बाइट्स

def f(a,n):
 for i in range(1<<n-1,1<<n):
  b=bin(i)[2:];u,v=(int(('0{:0>%d}'%sum(a)*len(s)).format(*s))for s in[a,b])
  if u%v<1>int(str(u//v*10)[::~sum(a)]):yield b

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

A और B को आधार k संख्या u और v के अंकों के रूप में देखें । उदाहरण के लिए (हम चित्रण के लिए k = 1000 का उपयोग करेंगे ):

ए = [1, 2, 1, 3, 2, 1, 2]
बी = [1, 0, 0, 1]
यू = 1 002 001 003 002 001 002
v = 1 000 000 001

जैसा कि अन्य उत्तरदाताओं ने देखा, यदि बी एक मान्य उत्तर है, तो यू वी द्वारा विभाज्य है । इस मामले में,

u = 1 002 001 002 1 v

यह भागफल, सरणी में वापस अनुवादित [1, 2, 1, 2], हमें बताता है कि B की कितनी प्रतियाँ हमें प्रत्येक स्थिति में स्थानांतरित करने की आवश्यकता हैं।

  [1, 0, 0, 1]
+    [1, 0, 0, 1]
+    [1, 0, 0, 1]
+       [1, 0, 0, 1]
+          [1, 0, 0, 1]
+          [1, 0, 0, 1]
-----------------------
  [1, 2, 1, 3, 2, 1, 2]

(क्यों? क्योंकि है कि वास्तव में कितनी देर गुणा काम करता है आधार में कश्मीर ।)

अन्य उत्तरदाता जो नोटिस करने में विफल रहे, वह यह है कि उपरोक्त स्थिति पर्याप्त नहीं है । उदाहरण के लिए:

ए = [1, 2, 1, 3, 2, 1, 2]
बी = [1, 1, 1, 1]
यू = 1 002 001 003 002 002 002
v = 1 001 001 001
u = 1 0002 002 2 v

गणितीय रूप से, हम अभी भी उस भागफल को सरणी में वापस अनुवाद कर सकते हैं [1, 1, we1, 2], जो ठीक काम करता है यदि हमें B की नकारात्मक प्रतियों का उपयोग करने की अनुमति है:

  [1, 1, 1, 1]
+    [1, 1, 1, 1]
−       [1, 1, 1, 1]
+          [1, 1, 1, 1]
+          [1, 1, 1, 1]
-----------------------
  [1, 2, 1, 3, 2, 1, 2]

लेकिन निश्चित रूप से चुनौती नकारात्मक प्रतियों की अनुमति नहीं देती है। इसलिए हमें एक अतिरिक्त जांच की आवश्यकता है।

कि अंत की ओर, हम एक आधार का चयन कश्मीर = 10 ^ई जहां कश्मीर > 10 ⋅ राशि (ए), और आधार हैं कि कोई भी जाँच कश्मीर अगले आधार में अंक अतिप्रवाह कश्मीर दस से जब हम गुणा भागफल अंकों। यही है, हर ई आधार बेस डिजिट, जो अंत में शुरू होता है, भागफल समय दस के बेस टेन प्रतिनिधित्व में, 0. होना चाहिए। यह गारंटी देता है कि भागफल नॉनगेटिव तत्वों के साथ एक सरणी में वापस अनुवाद करता है।

— एंडर्स कसीगोर
स्रोत

1

मैं आधार रूपांतरण को आसान बनाने के लिए आधार के रूप में 10 की एक बड़ी शक्ति का उपयोग करने की आपकी चाल को पसंद करता हूं।

— नील

2

PHP, 213 बाइट्स

एक ही रास्ता थोड़ा गोल्फ

<?for($b=2**~-$l=$_GET[1];$b<2**$l;array_filter($t[$b++])?:$d[]=$o)for($g=count($t[$b]=$_GET[$i=0]);min($t[$b])>-1&$i<=$g-$l;$i++)for($e=$t[$b][$i],$k=0,$o=decbin($b);$k<$l;)$t[$b][$k+$i]-=$o[$k++]*$e;print_r($d);

इसे ऑनलाइन आज़माएं!

PHP, 344 बाइट्स पहले काम कर रहे हैं

मेरे पहले उत्तर के बाद मैंने एक लंबा प्रयास करने का निर्णय लिया है जो सभी मान्य समाधानों को वापस देता है।

<?foreach(range(2**($l=$_GET[1])-1,2**($l-1))as$b){$t[$b]=($g=$_GET[0]);for($i=0;$t[$b]&&$i<=count($g)-$l;$i++){$e=reset($y=array_slice($t[$b],$i,$l));foreach(str_split(decbin($b))as$k=>$v)$t[$b][$k+$i]=$y[$k]-$e*$v;if(min($t[$b])<0)unset($t[$b]);}}foreach($t as$k=>$v)if(max($v)>0)unset($t[$k]);echo join(",",array_map(decbin,array_keys($t)));

ऑनलाइन संस्करण

टूट - फूट

foreach(
    range(2**($l=$_GET[1])-1
    ,2**($l-1)
    ) # make decimal range of a binarray with given length
    as$b){
$t[$b]=($g=$_GET[0]); # make a copy for each possible solution pattern
    for($i=0;$t[$b]&&$i<=count($g)-$l;$i++){ # Loop till solution is valid or reach last digit
        $e=reset($y=array_slice($t[$b],$i,$l)); # take first value of a sequence with the length
        foreach(str_split(decbin($b))as$k=>$v)
            $t[$b][$k+$i]=$y[$k]-$e*$v; # replace values in copy
        if(min($t[$b])<0)unset($t[$b]); # kill solution if a minimum <0 exists
    }
}
foreach($t as$k=>$v)if(max($v)>0)unset($t[$k]); # drop all solutions where the sum is not zero 


echo join(",",array_map(decbin,array_keys($t))); #Output all solutions

— जार्ग हुल्सरमैन
स्रोत

यह N, 2 के लिए काम करता है, लेकिन N = 1 मामलों में विफल रहता है, जैसे कि चुनौती में पहला परीक्षण मामला।

— एंडर्स कासोर्ग

@AndersKaseorg अब यह N = 1 मामलों का समर्थन करता है, इसे केवल =छोटे संस्करण के लिए पहले लूप में सेट करने की आवश्यकता है । अधिक से अधिक संस्करण में इसे चार बाइट्स हटाने की आवश्यकता है

— Jörg Hülsermann

1

पायथन, 205 बाइट्स

def f(a,l):
 b=lambda s:b(s[:-1])*sum(a)*8+int(s[-1])if s else 0
 c=lambda n:n and(n/sum(a)/4%2 or c(n/sum(a)/8))
 for i in range(2**~-l,2**l):
  j=bin(i)[2:]
  if b(a)%b(j)<1 and not c(b(a)/b(j)):return j

विभाजक के बिना एक बाइनरी स्ट्रिंग लौटाता है। जैसा कि @AndersKaseorg बताते हैं, ऐसे इनपुट हैं जिनके लिए @ fɛnɪtndk का समाधान काम नहीं करता है क्योंकि विभाजन एक नकारात्मक गुणांक का प्रतिनिधित्व करता है जो कि अस्वीकृत है। इसके चारों ओर काम करने के लिए, मैं एक बहुत बड़े आधार का उपयोग करता हूं और परीक्षण करता हूं कि विभाजन में कोई उधार नहीं है।

— नील
स्रोत

ठीक है, मुझे लगता है कि यह एक वास्तविक प्रतिधारण है: f([1, 1, 1, 0, 0, 0, 1, 1, 1], 3)गलत तरीके से रिटर्न 101।

— एंडर्स कासोर्ग

@AndersKaseorg Hmm, लूप की मदद के क्रम को उलट देता है, या एल्गोरिथ्म अभी भी मौलिक रूप से टूट गया है?

— नील

मुझे लगता है कि यह अतिरिक्त जांच के बिना मौलिक रूप से टूट गया है। रिवर्स वेरिएंट विफल रहता है f([1, 0, 2, 0, 2, 0, 1], 3), और आगे और रिवर्स दोनों वेरिएंट विफल हो जाते हैं f([1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0], 5)।

— एंडर्स कासोर्ग

और यहां तक कि अगर आप जांचते हैं कि iयह अजीब है, तो आगे और पीछे दोनों तरह के वेरिएंट विफल हो जाते हैं f([1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0]*10, 5)।

— एंडर्स कासोर्ग

1

@AndersKaseorg आह हाँ, जब gcd (k, n) = 1, (x^kn-1)/(x^k-1)हमेशा (x^n-1)/(x-1)एक कारक के रूप में होता है, जो किसी भी आधार में @ f fooln @tɪk के समाधान को मूर्ख बनाता है।

— नील

1

पायथ, 32 बाइट्स

f!|%FKiRJysQ,QT>#sQj/FKJ+L1^U2tE

इसे ऑनलाइन आज़माएं

यह काम किस प्रकार करता है

                           ^U2tE   Cartesian power [0, 1]^(N - 1)
                        +L1        prepend 1 to every list
f                                  filter for lists T such that:
          sQ                         sum(A)
         y                           double
        J                            assign to J
      iR    ,QT                      convert [A, T] from base J
     K                               assign to K
   %F                                fold modulo
  |                                  logical OR with
                    /FK                fold integer division over K
                   j   J               convert to base J
               >#sQ                    filter for digits greater than sum(A)
 !                                   logical NOT

रणनीति मेरे पायथन उत्तर के समान है , सिवाय इसके कि चूंकि पायथ ने आधार रूपांतरण के लिए निर्माण किया है, हम एक अधिक कुशल आधार k = 2 (राशि (ए) का उपयोग कर सकते हैं , और सीधे जांच सकते हैं कि भागफल का प्रत्येक अंक सबसे अधिक राशि पर है (ए) )।

— एंडर्स कसीगोर
स्रोत

1

परी / जीपी , 77 74 96 80 बाइट्स

n->a->[v|d<-divisors(b=Pol(a)),(v=Vec(d))%2==v&&vecmin(Vec(b/d))>=0&&d%x&&#d==n]

सभी समाधान लौटाता है।

पहले सरणी aको एक बहुपद में परिवर्तित करता है b। फिर भाजक bसे बहुपदों को चुनता है dजैसे कि गुणांक dसभी हैं 1और 0, और गुणांक b / dसभी गैर-वाचक हैं, और d(0) = 1, और deg(d) = n + 1। अंत में, उन्हें वापस सरणियों में परिवर्तित करता है।

इसे ऑनलाइन आज़माएं!

— alephalpha
स्रोत

द्विज का पता लगाएं!

काम

उदाहरण

नियम

परीक्षण के मामलों

PHP, 105 92 90 86 बाइट्स

PHP , 219 बाइट्स

पायथन, 166 बाइट्स

यह काम किस प्रकार करता है

PHP, 213 बाइट्स

PHP, 344 बाइट्स पहले काम कर रहे हैं

टूट - फूट

पायथन, 205 बाइट्स

पायथ, 32 बाइट्स

यह काम किस प्रकार करता है

परी / जीपी , 77 74 96 80 बाइट्स