আমরা নিম্নলিখিত বৈশিষ্ট্যগুলি সন্তুষ্ট করে এমন অ্যারে হিসাবে একটি বাইনারিকে সংজ্ঞায়িত করি :

এটি খালি নেই
প্রথম মান হ'ল ক 1
শেষ মান a 1
সব অন্যান্য মান পারেন 0বা1

উদাহরণস্বরূপ, অ্যারেটি [ 1, 1, 0, 1 ]একটি বৈধ বাইনারি ।

কাজটি

একটি খালি অ্যারের দেওয়া একটি অ নেতিবাচক পূর্ণসংখ্যার এবং পূর্ণসংখ্যা একটি ইতিবাচক এন , আপনার কাজ একটি খুঁজে পেতে binarray বি দৈর্ঘ্যের এন জেনারেট করতে পারবেন যা একটি কপি একজন অবাধ সংখ্যা summing দ্বারা বি , একটি অবাধ সংখ্যা দ্বারা স্থানান্তরিত অবস্থান।

উদাহরণ

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") এর সাথে বা ছাড়াই বাইনারি স্ট্রিং হতে পারে
আপনার কেবলমাত্র একটি বৈধ বাইনারি মুদ্রণ করতে হবে বা ফিরে আসতে হবে । বিকল্পভাবে, আপনি বেশ কয়েকটি সমাধান উপস্থিত থাকলে সেগুলি মুদ্রণ বা ফিরিয়ে দিতে পছন্দ করতে পারেন ।
আপনাকে এমন ইনপুটগুলি সমর্থন করার দরকার নেই যা কোনও সমাধানের দিকে নিয়ে যায় না।
যোগফলে অন্তর্নিহিত শূন্যগুলি অন্তর্ভুক্ত থাকতে পারে যা বি এর কোনও অনুলিপি দিয়ে ওভারল্যাপ হয় না । উপরের যোগফলের দ্বিতীয় শূন্যটি এমন একটি অন্তর্নিহিত শূন্য।
তোমার অনুমান করতে পারেন সর্বাধিক মাপ একটি 100 এবং সর্বাধিক মাপ বি 30।
এটি কোড-গল্ফ, তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর ins স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।

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

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কি যুক্তিসঙ্গতভাবে সমর্থন করা উচিত?

— নীল

@Neil আমি উভয় A এবং B. উপর মাপ সীমা জুড়েছেন

— Arnauld

1

@ fəˈnɛtɪ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ɛtɪk এই সংখ্যাগুলি বেস 2 তে লিখিত হয়নি তাই পাটিগণিতের নিয়ম প্রযোজ্য নয়। উদাহরণস্বরূপ, যোগ করার সময় আপনি সুস্পষ্টভাবে বহন করতে পারবেন না।

— বলপয়েন্টবেন

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

পিএইচপি, 105 92 90 86 বাইট

জার্জির সমাধান স্থির এবং গল্ফড:

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

পিএইচপি , 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]=$_GETপরিবর্তে পিএইচপি 7.1 ব্যবহার করে বাইটসlist($g,$z)=$_GET

— জার্গ হালসারম্যান
সূত্র

দেখে মনে হচ্ছে এটি শেষ পরীক্ষার ক্ষেত্রে বৈধ ( [1,0,1,0,1,0,1,0,1]) এবং একটি অবৈধ উত্তর ( [1,0,0,0,1,0,1,1,1]) উভয়কেই আউটপুট করে ।

— আর্নল্ড

-8 বাইট: while($_GET[0])$s+=2**$i++*array_pop($_GET[0]);। -5 বাইট: range(1|.5*$m=2**$_GET[1],$m,2)।

— তিতাস

@ আর্নল্ড হ্যাঁ, আউটপুট হিসাবে আমার দেওয়া উচিত কেবল সর্বোচ্চ বাইনারিও এই সমাধানটিকে বৈধ করে তুলতে পারে

— জার্গ হালসারম্যান

2

@ fəˈnɛtɪ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
ভি = 1 000 000 001

অন্যান্য উত্তরদাতাদের অনেকে যেমন লক্ষ্য করেছেন, বি যদি একটি বৈধ উত্তর হয় তবে আপনি v দ্বারা বিভাজ্য । এক্ষেত্রে,

u = 1 002 001 002 ⋅ v

এই ভাগফলটি অ্যারেতে ফিরে অনুবাদ [1, 2, 1, 2], আমাদের জানায় ঠিক কত বিলি আমাদের প্রতিটি পজিশনে স্থানান্তরিত করতে হবে।

  [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 001 002
ভি = 1 001 001 001
ইউ = 1 000 999 002 ⋅ বনাম

গাণিতিকভাবে বলতে গেলে, আমরা এখনও সেই ভাগটিকে অ্যারে [1, 1, −1, 2] এ ফিরে অনুবাদ করতে পারি, যা আমাদের বি এর নেতিবাচক অনুলিপি ব্যবহার করার অনুমতি দিলে ঠিকঠাক কাজ করে:

  [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 হতে হবে This এটি গ্যারান্টি দেয় যে ভাগফলটি ননজেটিভ উপাদানগুলির সাথে একটি অ্যারেতে ফিরে অনুবাদ করে।

— অ্যান্ডারস ক্যাসরগ
সূত্র

1

বেস রূপান্তরটি আরও সহজ করতে বেস হিসাবে 10 এর বৃহত শক্তি ব্যবহার করার আপনার কৌশলটি আমি পছন্দ করি।

— নিল

2

পিএইচপি, 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);

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

পিএইচপি, 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

— জার্গ হালসারম্যান
সূত্র

এটি এন ≥ 2 এর পক্ষে কাজ করে বলে মনে হচ্ছে তবে এন = 1 ক্ষেত্রে ব্যর্থ হয়েছে যেমন চ্যালেঞ্জের প্রথম পরীক্ষার ক্ষেত্রে।

— অ্যান্ডারস ক্যাসরগ

@ অ্যান্ডারস ক্যাসরগ এখন এটি এন = 1 কেসগুলিকে সমর্থন করে কেবল =সংক্ষিপ্ত সংস্করণের জন্য প্রথম লুপটিতে একটি সেট করা দরকার বৃহত্তর সংস্করণে এটি চারটি বাইট মুছে ফেলতে হবে

— জার্গ হালসারম্যান

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

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

— নিল
সূত্র

ঠিক আছে, আমি মনে করি এটি একটি আসল কাউন্টারিক্স নমুনা: f([1, 1, 1, 0, 0, 0, 1, 1, 1], 3)ভুলভাবে ফিরিয়ে দেয় 101।

— অ্যান্ডারস ক্যাসরগ

@ অ্যান্ডারস ক্যাসরগ হুম, লুপ সাহায্যের ক্রমটিকে বিপরীত করে না, বা অ্যালগরিদমটি এখনও মৌলিকভাবে ভেঙে গেছে?

— নিল

আমি মনে করি এটি অতিরিক্ত চেক ছাড়া মৌলিকভাবে ভেঙে গেছে। বিপরীত রূপটি ব্যর্থ হয় 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

@ আন্ডারস ক্যাসরগ আহা হ্যাঁ, যখন জিসিডি (কে, এন) = 1, (x^kn-1)/(x^k-1)সর্বদা (x^n-1)/(x-1)একটি উপাদান হিসাবে থাকে, যা @ f innɛ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 ⋅ যোগ (এ) ব্যবহার করতে পারি , এবং সরাসরি পরীক্ষা করে দেখতে পারি যে ভাগফল্যের প্রতিটি অঙ্ক সর্বাধিক যোগফল (A) )।

— অ্যান্ডারস ক্যাসরগ
সূত্র

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। তারপর ভাজক থেকে বেছে bpolynomials dযেমন যে এর কোফিসিয়েন্টস dসব 1এবং 0, এবং কোফিসিয়েন্টস b / dসব নন-নেগেটিভ হয়, এবং d(0) = 1, এবং deg(d) = n + 1। অবশেষে এগুলি আবার অ্যারেতে রূপান্তরিত করে।

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

— alephalpha
সূত্র

বাইনারি খুজে দাও!

কাজটি

উদাহরণ

বিধি

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

পিএইচপি, 105 92 90 86 বাইট

পিএইচপি , 219 বাইট

পাইথন, 166 বাইট

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

পিএইচপি, 213 বাইট

পিএইচপি, 344 বাইটস প্রথম কাজ করছে

ভাঙ্গন

পাইথন, 205 বাইট

পাইথ, 32 বাইট

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

পরী / জিপি , 77 74 96 80 বাইট