न्यूनतम लागत ब्लॉक विकर्ण

Question

बाइनरी ब्लॉक विकर्ण मेट्रिसेस पर विचार करें जिनके मुख्य विकर्ण पर 1s के वर्ग ब्लॉक हैं, और हर जगह 0 हैं। आइए ऐसे मेट्रिक्स को "वैध" मैट्रेस कहते हैं।

उदाहरण के लिए, यहां कुछ मान्य 4x4 मैट्रेस हैं:

1 0 0 0     1 1 0 0     1 0 0 0     1 0 0 0     1 1 0 0    1 1 1 1
0 1 0 0     1 1 0 0     0 1 1 0     0 1 1 1     1 1 0 0    1 1 1 1
0 0 1 0     0 0 1 0     0 1 1 0     0 1 1 1     0 0 1 1    1 1 1 1
0 0 0 1     0 0 0 1     0 0 0 1     0 1 1 1     0 0 1 1    1 1 1 1

ध्यान दें कि इस तरह के मैट्रिक्स का वर्णन करने का एक वैकल्पिक तरीका यह है कि शीर्ष-बाएं से नीचे-दाएं, स्पर्श कोने से कोने तक वर्ग 1 ब्लॉक की एक श्रृंखला है और हर जगह 0 है।

इसके विपरीत, यहां कुछ अमान्य 4x4 मैट्रेस हैं:

1 0 1 0     1 0 1 0     1 1 0 0     0 1 1 1     1 1 0 0    0 0 0 0
0 1 1 1     0 1 0 1     1 1 0 0     0 1 1 1     1 1 0 0    0 0 0 0
1 0 0 1     1 0 1 0     0 0 0 0     0 1 1 1     1 1 0 0    0 0 0 0
0 0 1 0     0 1 0 1     0 0 0 1     1 0 0 0     0 0 1 1    0 0 0 0

आपको द्विआधारी मैट्रिक्स nद्वारा nइनपुट के रूप में दिया जाएगा - एक वैध मैट्रिक्स प्राप्त करने के लिए 0आपको न्यूनतम बिट्स की क्या आवश्यकता होगी 1?

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

यह कोड-गोल्फ है , इसलिए लक्ष्य आपके कार्यक्रम में बाइट्स की संख्या को कम करना है।

उदाहरण

उदाहरण के लिए, यदि इनपुट है

0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 1

तब उत्तर 5 है, क्योंकि आप पाने के 0लिए पांच बिट्स सेट कर सकते 1हैं:

1 0 0 0 0
0 1 1 0 0
0 1 1 0 0
0 0 0 1 0
0 0 0 0 1

और यह आवश्यक न्यूनतम संख्या है। हालांकि, अगर इनपुट था

0 0 0 0 1
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0

तब उत्तर 24 है, एकमात्र वैध 5x5 मैट्रिक्स के बाद से जहां शीर्ष-दाएं 1सभी 1s का मैट्रिक्स है ।

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

टेस्ट यहां पूर्णांक के 2 डी सरणी के रूप में दर्शाए गए हैं।

[[0]] -> 1
[[1]] -> 0
[[0,1],[0,0]] -> 3
[[1,0],[0,0]] -> 1
[[0,0,0],[0,1,0],[0,0,0]] -> 2
[[0,1,0],[0,0,0],[0,1,0]] -> 7
[[0,1,0],[1,0,0],[0,0,1]] -> 2
[[1,1,1],[1,1,1],[1,1,1]] -> 0
[[0,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,0]] -> 4
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]] -> 8
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,0,1,0]] -> 14
[[0,0,1,0],[0,0,0,0],[0,0,0,0],[0,1,0,0]] -> 14
[[0,0,0,0,0],[0,0,0,0,0],[0,1,0,0,0],[0,0,0,0,1],[0,0,0,0,0]] -> 7
[[0,0,0,0,0],[0,0,0,0,0],[1,0,0,0,0],[0,0,0,0,1],[0,0,0,0,0]] -> 11
[[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,1]] -> 5
[[0,0,0,0,1],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] -> 24
[[0,0,0,1,0],[0,0,0,0,1],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]] -> 23
[[0,1,0,0,0],[1,0,0,0,0],[0,0,1,0,0],[0,0,0,0,1],[0,0,0,1,0]] -> 4
[[0,1,1,1,0],[0,1,1,0,1],[0,1,1,1,0],[0,1,0,0,1],[0,0,0,0,0]] -> 14

टिप्पणियाँ

• संबंधित चुनौती: एक ब्लॉक-विकर्ण मैट्रिक्स प्रिंट करें
• प्रेरणा: स्वतंत्रता कारखाना, Google कोड जाम 2016 समस्या 2 डी

Answer 1

MATL , 46 43 बाइट्स

nX^tQt:qZ^!tsb=Z)"@!"@1$l]@n$YdG-Q?6MG>zvX<

पंक्ति विभाजक के रूप में इनपुट अर्धवृत्त के साथ एक 2D सरणी है। उदाहरण के लिए, अंतिम परीक्षण मामले के लिए इनपुट है

[0,1,1,1,0;0,1,1,0,1;0,1,1,1,0;0,1,0,0,1;0,0,0,0,0]

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (सभी इनपुट लेने के लिए थोड़ा संशोधित कोड; परिणाम कुछ सेकंड के बाद दिखाई देते हैं)

व्याख्या

इनपुट N × N मैट्रिक्स होने दें। कोड पहले ब्लॉक आकार के सभी ( एन +1) -tuples की गणना करता है जो उपयुक्त मैट्रिक्स आकार का उत्पादन करते हैं। उदाहरण के लिए, के लिए एन = 4 tuples हैं 0 0 0 0 4, 0 0 0 1 3, ..., 4 0 0 0 0। प्रत्येक टपल के लिए यह उन ब्लॉक आकारों के साथ ब्लॉक-विकर्ण मैट्रिक्स बनाता है। यह तब जांचता है कि क्या मैट्रिक्स 1इनपुट में सभी प्रविष्टियों को कवर करता है , और यदि ऐसा है तो उन 1प्रविष्टियों की संख्या पर ध्यान दें जो इनपुट में मौजूद नहीं थीं। अंतिम परिणाम सभी प्राप्त संख्याओं में से न्यूनतम है।

nX^      % Implicit input  an N×N matrix. Get N
t        % Duplicate N
Qt:q     % Vector [0 1 ... N]
Z^       % Cartesian power. Gives 2D array
!ts      % Transpose, duplicate, sum of each column
b=       % Logical vector that equals true if the sum is N
Z)       % Filter columns according to that. Only keep columns that sum to N. Each 
         % column is the size of one block
"        % For each column
  @      %   Push that column
  "      %   For each entry of that column
    @    %     Push that entry
    1$l  %     Square matrix with that size, filled with 1
  ]      %   End
  @n     %   Column size. This is the number of blocks in the block-diagonal matrix
  $Yd    %   Build block-diagonal matrix from those blocks
  G-Q    %   Subtract input matrix element-wise, and add 1
  ?      %   If all entries are nonzero (this means each that entry that is 1 in the
         %   block-diagonal matrix is also 1 in the input matrix)
    6M   %   Push block-diagonal matrix again
    G>   %   For each entry, gives 1 if it exceeds the corresponding entry of the
         %   input, that is, if the block-diagonal matrix is 1 and the input is 0
    z    %   Number of 1 entries
    v    %   Concatenate vertically with previous values
    X<   %   Take minimum so far
         %   Implicit end
         % Implicit end
         % Implicit display

Answer 2

सुन्न के साथ अजगर, 102

from numpy import*
lambda M:sum(diff([k for k in range(len(M)+1)if(M|M.T)[:k,k:].any()-1])**2)-M.sum()

एक कुशल एल्गोरिथ्म। विकर्ण पर "गर्दन के बिंदु" को ढूँढता है जो ब्लॉक को अलग कर सकता है। इनमें सभी 0 से ऊपर और दाएं, साथ ही नीचे और बाएं हैं। गर्दन के बिंदुओं के बीच न्यूनतम ब्लॉक होते हैं।

??000
??000
00???
00???
00???

एक ब्लॉक की लंबाई लगातार गर्दन के बिंदुओं के बीच का अंतर है, इसलिए इन के वर्गों के योग का उनका कुल क्षेत्रफल। मूल मैट्रिक्स के योग को घटाकर फिर 0 से 1 तक आवश्यक फ़्लिप की संख्या देता है।

Answer 3

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

[e-mail]1sQTms.b^+LsYN2d+0._ds.pM./lQss

मुश्किल काम है, इसलिए यह काफी लंबा है।

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

s.pM./lQके सभी पूर्णांक विभाजन की गणना करता है len(matrix)। ms.b^+LsYN2d+0._dउन्हें समन्वय-जोड़े में परिवर्तित करता है। उदाहरण के लिए विभाजन [1, 2, 2]में 5परिवर्तित हो जाता है [[0,0], [1,1], [1,2], [2,1], [2,2], [3,3], [3,4], [4,3], [4,4]।

[e-mail]1sQTफिर विभाजन के लिए फ़िल्टर, जो पूरी तरह से मैट्रिक्स को ओवरलैप करता है (मैट्रिक्स .DRlQx1sQमें सक्रिय कोशिकाओं के सभी समन्वय-जोड़े की गणना करता है)।

-hSlM...ss प्रत्येक शेष विभाजन की कोशिकाओं को गिना जाता है, कम से कम कोशिकाओं के साथ एक को चुनता है, और पहले से सक्रिय कोशिकाओं को घटाता है।

Answer 4

मैट्रिक , 180 बाइट्स ( नॉनकमेटिंग )

मैट्रिक एक नई इज़ांग है जिसे मैंने हाल ही में मैट्रिक्स समस्याओं (जैसे यह एक) से निपटने के लिए बनाया है, केवल 2 डेटा प्रकारों से: फ़्लोट और मैट्रिक। यह पूरी तरह से अभी तक चित्रित नहीं है, और अभी भी बहुत सारे लापता ऑपरेशन हैं (मुझे इस चुनौती के लिए कुछ कार्यक्षमता जोड़ना था)। वैसे भी, यहाँ कोड है:

il=1:j3;:bdx;;;s1::L;j1;;
b{q:1;mgr:c;|gc:r;|(r=c)|(gr-1:c;|gr:c+1;)&(rec)|(gr+1:c;|gr:c-1;)&(cer):l:L;};z:(l-1)/2;B1;s1::g1:;-1;ig1:;=0:j2;:j1;;
s1::d{q:1;};;kg1:;-g:;;
kg:;*-1+1;

व्याख्या

पहला भाग, il=1:j3;:...;जाँचता है कि सरणी का आकार 1 है। यदि यह है, तो यह अंतिम पंक्ति में कूदता है kg:;*-1+1;, जो कि एक साधारण 0 <-> 1कार्य है।

अन्यथा, यह बाकी कोड के साथ जारी है। bdx;;;सेल 0,0को वर्तमान राशि पर सेट करता है , और s1::L;j1;नीचे पंक्ति में सेल में एक काउंटर बनाता है।

अगली पंक्ति थोड़ी अधिक जटिल है। यह एक लूप है जो मैट्रिक्स के आकार के होते हुए n, कई बार चलता है n। मैं उदाहरण के तौर पर 3rd टेस्ट केस का उपयोग करूंगा। जब हम पहली बार दूसरी पंक्ति में आते हैं, तो मैट्रिक्स इस तरह दिखता है:

1 0 1
2 0 0

सबसे पहले, हम मैट्रिक्स की समझ में जाते हैं {q:1;m...;}। यह विकर्ण बनाता है, और 0 को साफ करने की पूरी कोशिश करता है जिसमें भरने की आवश्यकता होती है। यह सब साधारण बूलियन ऑपरेटरों का उपयोग करके पूरा किया जाता है। फिर, हम इसे देते हुए, इसे वर्तमान मैट्रिक्स में प्रस्तुत करते हैं:

    V--data we want to keep
1 1 1 0 1 <-|
1 1 2 0 0 <-- old matrix

फिर, हम उपयोग करते हुए पुराने मैट्रिक्स को काटते हैं z:(l-1)/2;, और पूरे मैट्रिक्स को बाईं ओर घुमाते हैं B1;। यह हमें अगले मैट्रिक्स के लिए तैयार मैट्रिक्स देता है, जैसे कि:

1 1 1
2 1 1

अंत में, हम काउंटर को घटाते हैं, इसकी जांच करते हैं, और जारी रखते हैं ig1:;=0:j2;:j1;;

एक बार लूप के टूट जाने के बाद, हम नई राशि पाते हैं और काउंटर के पुराने स्थान को सेट करते हैं s1::d{q:1;};;। अंत में, हम अंतर लेते हैं और वापस लौटते हैं kg1:;-g:;;। kवर्तमान सरणी को एक मान पर सेट करता है, और मुद्रण निहित है।

...

जैसा कि आप देख सकते हैं, मैट्रिक काफी क्रियात्मक है, और बहुत अच्छी गोल्फिंग भाषा नहीं है। लेकिन बिल्ली, मैं इसे दिखाना चाहता था।