विभाजन सरणियों और कार्यक्रमों को आधे में

Question

परिचय

आपको एक प्रोग्राम लिखने का काम सौंपा गया है जो आयताकार पूर्णांक सरणी को समान रूप से आधे हिस्से में विभाजित करता है (जो भी कारण हो)। यह कार्य कम्प्यूटेशनल रूप से गहन है, लेकिन सौभाग्य से गणना करने के लिए आपके पास एक दोहरे कोर मशीन है। समानता के लाभों को अधिकतम करने के लिए, आप कार्यक्रम को समान रूप से आधे में विभाजित करने का निर्णय लेते हैं और प्रत्येक कोर को स्वतंत्र रूप से एक हिस्से को चलाने देते हैं।

इनपुट और आउटपुट

आपका इनपुट कम से कम 1 × 1 आकार के गैर-पूर्णांक के आयताकार 2 डी सरणी है , जो किसी भी उचित प्रारूप में लिया गया है। एक बंटवारे में इस तरह के एक सरणी के एक उपसर्ग और प्रत्यय (जिनमें से या तो खाली हो सकता है) में प्रत्येक क्षैतिज पंक्ति बंटवारे से प्राप्त की है। एक विभाजन के लिए वैध होने के लिए, दो आसन्न पंक्तियों को एक ही सूचकांक या आसन्न सूचकांकों में विभाजित किया जाना चाहिए। उदाहरण के लिए, सरणी पर विचार करें

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)

इनपुट के सभी मान्य विभाजन पर।

नियम और स्कोरिंग

आप एक ही भाषा में दो कार्यक्रम (या तो पूर्ण कार्यक्रम या कार्य) लिखेंगे , जिनके बीच कोई साझा कोड नहीं होना चाहिए। उन्हें कहते हैं P1 और P2 । प्रोग्राम P1 इनपुट सरणी लेता है, और कुछ आउटपुट करता है । प्रोग्राम पी 2 इसे कुछ इनपुट के रूप में लेता है, और इनपुट सरणी के लिए उपरोक्त कार्य के उत्तर को आउटपुट करता है।

आपका स्कोर P1 और P2 की बाइट काउंट की अधिकतम सीमा है , कम स्कोर बेहतर है।

कुछ स्पष्टीकरण:

• आप दो पूर्ण prorgams, एक फ़ंक्शन और एक पूर्ण प्रोग्राम, या दो फ़ंक्शन लिख सकते हैं।
• दो पूर्ण कार्यक्रमों के मामले में, के पूरे उत्पादन P1 को खिलाया P2 इनपुट के रूप में, यूनिक्स पाइप लाइन में के रूप में 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

Comments

एक पल के लिए, मुझे लगा कि यह एक बहु-सूत्रीय प्रश्न था। मैं आगे भी ऐसे ही देख रहा हूं।

— आदाम

Answer 1

हास्केल, 102 बाइट्स

समारोह 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

जाँच करने के लिए हार्डकोड पूर्णांक सरणी सहित, इसे पूर्ण कार्यक्रम बनाने के लिए F1 के लिए बॉयलर बॉयलरप्लेट गुम होना:

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]]

और F2 के लिए:

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

नोट: दूसरे फ़ंक्शन को थोड़ा और अधिक गोल्फ किया जा सकता है, लेकिन यह स्कोर को नहीं बदलता है।