অর্ধে অ্যারে এবং প্রোগ্রামগুলি বিভক্ত করুন

ভূমিকা

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

ইনপুট এবং আউটপুট

আপনার ইনপুটটি কোনও যুক্তিসঙ্গত বিন্যাসে নেওয়া ন্যূনতম 1 non 1 আকারের nonnegative পূর্ণসংখ্যার একটি আয়তক্ষেত্র 2D অ্যারে । একটি বিভাজন যেমন একটি অ্যারের একটি উপসর্গ এবং একটি প্রত্যয় (যা উভয় ফাঁকা হতে পারে) প্রতিটি অনুভূমিক সারি বিভাজন দ্বারা প্রাপ্ত হয়। একটি বিভাজন বৈধ হওয়ার জন্য, দুটি সংলগ্ন সারি একই সূচক বা সংলগ্ন সূচকগুলিতে বিভক্ত করতে হবে। উদাহরণস্বরূপ, অ্যারে বিবেচনা করুন

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

এটি একটি বৈধ বিভাজন:

 2;4 5 5 6 3
;9 7 1 7 7 0
;0 0 3 6 7 8
 1;2 4 7 6 1
 6 6;8 2 0 0

এটি বৈধ বিভাজনও:

2 4 5 5 6 3;
9 7 1 7 7;0
0 0 3 6 7;8
1 2 4 7;6 1
6 6 8;2 0 0

এটি বৈধ বিভাজন নয়:

2 4;5 5 6 3
9 7 1;7 7 0
0;0 3 6 7 8
1 2;4 7 6 1
6 6;8 2 0 0

আপনার আউটপুট হবে সর্বনিম্ন মান

abs(sum_of_prefixes - sum_of_suffixes)

ইনপুট সমস্ত বৈধ বিভক্ত উপর।

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

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

আপনার স্কোরটি P1 এবং P2 এর বাইট সংখ্যাগুলির সর্বোচ্চ , কম স্কোরটি আরও ভাল।

কিছু স্পষ্টতা:

আপনি দুটি পূর্ণ prorgams লিখতে পারেন, একটি ফাংশন এবং একটি সম্পূর্ণ প্রোগ্রাম, বা দুটি ফাংশন।
দুটি পূর্ণ প্রোগ্রামের ক্ষেত্রে, ইউ 1 পাইপলাইন হিসাবে, পি 1 এর সম্পূর্ণ আউটপুট পি 2 কে ইনপুট হিসাবে খাওয়ানো হয় P1 | P2। দুটি পৃথক উত্স ফাইল থেকে সংকলিত / ব্যাখ্যা করা থাকলে প্রোগ্রামগুলি অবশ্যই সঠিকভাবে কাজ করবে।
উভয়ই প্রোগ্রাম যদি কোনও ফাংশন হয় তবে প্রয়োজনীয় বয়লারপ্লিট কোড যুক্ত করে এটি একটি সম্পূর্ণ প্রোগ্রামে রূপান্তরিত হয় এবং উপরের নিয়মটি এটি প্রয়োগ করা হয়। বিশেষত, দুটি ফাংশন ভাগ করা সহায়ক ফাংশন, ভাগ করা আমদানি বিবৃতি, বা ভাগ করা বৈশ্বিক ভেরিয়েবল ব্যবহার করতে পারে না।

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

[[1]] -> 1
[[4,5],[8,3]] -> 4
[[8],[11],[8],[10],[4]] -> 1
[[5,7,0,9,11,2,1]] -> 7
[[146,194,71,49],[233,163,172,21],[121,173,14,302],[259,169,26,5],[164,30,108,37],[88,55,15,2]] -> 3
[[138,2,37,2],[168,382,33,77],[31,199,7,15],[192,113,129,15],[172,88,78,169],[28,6,97,197]] -> 7
[[34,173,9,39,91],[169,23,56,74,5],[40,153,80,60,28],[8,34,102,60,32],[103,88,277,4,2]] -> 0
[[65,124,184,141],[71,235,82,51],[78,1,151,201],[12,24,32,278],[38,13,10,128],[9,174,237,113]] -> 2
[[164,187,17,0,277],[108,96,121,263,211],[166,6,57,49,73],[90,186,26,82,138],[173,60,171,265,96]] -> 8

code-challenge array-manipulation optimization

— Zgarb
সূত্র

এক মুহুর্তের জন্য, আমি ভেবেছিলাম এটি একটি বহু-থ্রেডিং প্রশ্ন। আমি এই জাতীয় আরও প্রতীক্ষিত ছিলাম।

— অ্যাডাম

হাস্কেল, ১০২ বাইট

ফাংশন 1 (102 বাইট):

l=length
[]#i=[[]]
(r:s)#i=id=<<[(splitAt j r:)<$>s#j|j<-[i-1..i+1],j>=0,j<l r]
f r=(r#)=<<[0..l$r!!0]

ফাংশন 2 (90 বাইট):

g::[[([Int],[Int])]]->Int 
g a=minimum$map(\(x,y)->abs$sum(sum<$>x)-sum(sum<$>y))$unzip<$>a

হার্ড-কোডড পূর্ণসংখ্যা অ্যারে সহ এটি পরীক্ষা করার জন্য এফ 1 এ এটি একটি সম্পূর্ণ প্রোগ্রাম তৈরি করতে অনুপস্থিত বয়লারপ্লেট:

main = print $ f [[164,187,17,0,277],[108,96,121,263,211],[166,6,57,49,73],[90,186,26,82,138],[173,60,171,265,96]]

এবং এফ 2 এর জন্য:

main = print . g . read =<< getContents

এখন আপনি কল করতে পারেন runhaskell f1.hs | runhaskell f2.hsযা আউটপুট 8।

এটি কীভাবে কাজ করে: fপূর্ণসংখ্যার তালিকার একটি তালিকা নেয়।

f r = (r#)=<<[0..l$r!!0]          -- for each index [0 .. length r] call # with
                                  -- the first parameter being r and
                                  -- collect the results in a single list

[]#i=[[]]                         -- base case. If the list of lists is empty, stop
(r:s)#i                           -- else let r be the first list, s all others
           j<-[i-1..i+1],         -- foreach possible index j for the next line
                 j>=0,j<l r       --    (skipping out of range indices)
     (splitAt j r:)<$>            -- split the current line at j into a pair of
                                  -- lists and prepend it to every element of
                      s#j         -- a recursive call with s and j
id=<<                             -- flatten into a single list

এখন আমাদের কাছে সমস্ত সম্ভাব্য বিভাজনের একটি তালিকা রয়েছে, উদাহরণস্বরূপ প্রথমটি এবং মাঝখানে থেকে এলোমেলো একটি

[([],[164,187,17,0,277]),                  [([164,187],[17,0,277]),
 ([],[108,96,121,263,211]),                 ([108,96],[121,263,211]),
 ([],[166,6,57,49,73]),                     ([166],[6,57,49,73]),
 ([],[90,186,26,82,138]),                   ([90,186],[26,82,138]),
 ([],[173,60,171,265,96])]                  ([173,60,171],[265,96])]

ফাংশন gযেমন একটি তালিকা লাগে এবং

                    unzip<$>a       -- turn every pair of lists into a list of pairs
  map(\(x,y)->                      -- foreach such pair     
      abs$sum(sum<$>x)-sum(sum<$>y) -- calculate the score
minimum                             -- and find the minimum

দ্রষ্টব্য: দ্বিতীয় ফাংশনটি আরও কিছুটা গল্ফ করা যেতে পারে, তবে এটি স্কোর পরিবর্তন করে না।

— nimi
সূত্র