अवरोधों के साथ पूर्णांकों के सभी संभव ग्रिडों की गणना करें

Question

मुसीबत

गैर-नकारात्मक पूर्णांक के 3 ग्रिड द्वारा एक वर्ग 3 पर विचार करें। प्रत्येक पंक्ति iके लिए पूर्णांकों का योग होना तय है r_i। इसी तरह प्रत्येक स्तंभ के jलिए उस स्तंभ में पूर्णांकों का योग होना तय है c_j।

कार्य पंक्ति और स्तंभ योग बाधाओं को देखते हुए पूर्णांक के सभी संभव विभिन्न असाइनमेंटों की गणना करने के लिए कोड लिखना है। आपके कोड को एक समय में एक असाइनमेंट आउटपुट करना चाहिए।

इनपुट

आपके कोड को पंक्ति अवरोधों को निर्दिष्ट करने वाले 3 गैर-नकारात्मक पूर्णांक और कॉलम की बाधाओं को निर्दिष्ट करने वाले 3 गैर-नकारात्मक पूर्णांक लेना चाहिए। आप यह मान सकते हैं कि ये वैध हैं, यानी कि योग या पंक्ति की बाधाएं स्तंभ की कमी के योग के बराबर होती हैं। आपका कोड किसी भी तरह से ऐसा कर सकता है जो सुविधाजनक हो।

उत्पादन

आपके कोड को अपनी पसंद के किसी भी मानव पठनीय प्रारूप में गणना करने वाले विभिन्न 2d ग्रिड का उत्पादन करना चाहिए। पाठ्यक्रम के बेहतर prettier। आउटपुट में डुप्लिकेट ग्रिड नहीं होना चाहिए।

उदाहरण

यदि सभी पंक्ति और स्तंभ बाधाएं ठीक हैं, 1तो केवल 6अलग-अलग संभावनाएं हैं। पहली पंक्ति के लिए आप 1पहले तीन कॉलम में से किसी एक में डाल सकते हैं, दूसरी पंक्ति के लिए अब 2विकल्प हैं और अंतिम पंक्ति अब पूरी तरह से पिछले दो द्वारा निर्धारित की गई है। ग्रिड में अन्य सभी चीजें निर्धारित की जानी चाहिए 0।

कहें कि इनपुट 2 1 0पंक्तियों के 1 1 1लिए और कॉलम के लिए है। एपीएल के सुंदर आउटपुट प्रारूप का उपयोग करके, संभव पूर्णांक ग्रिड हैं:

┌─────┬─────┬─────┐
│0 1 1│1 0 1│1 1 0│
│1 0 0│0 1 0│0 0 1│
│0 0 0│0 0 0│0 0 0│
└─────┴─────┴─────┘

अब कहते हैं कि इनपुट 1 2 3पंक्तियों और 3 2 1स्तंभों के लिए है। संभव पूर्णांक ग्रिड हैं:

┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│0 0 1│0 0 1│0 0 1│0 1 0│0 1 0│0 1 0│0 1 0│1 0 0│1 0 0│1 0 0│1 0 0│1 0 0│
│0 2 0│1 1 0│2 0 0│0 1 1│1 0 1│1 1 0│2 0 0│0 1 1│0 2 0│1 0 1│1 1 0│2 0 0│
│3 0 0│2 1 0│1 2 0│3 0 0│2 1 0│2 0 1│1 1 1│2 1 0│2 0 1│1 2 0│1 1 1│0 2 1│
└─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Answer 1

एपीएल (डायलॉग) , 42 बाइट्स

{o/⍨(⍵≡+/,+⌿)¨o←3 3∘⍴¨(,o∘.,⊢)⍣8⊢o←⍳1+⌈/⍵}

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

उपयोग ⎕IO←0जो कई प्रणालियों पर डिफ़ॉल्ट है। शीर्ष लेख में अन्य सामग्री मैट्रिसेस (बॉक्सिंग डिस्प्ले) के लिए बहुत सुंदर मुद्रण है।

इनपुट छह मानों की सूची है, पंक्तियाँ पहले sums, फिर स्तंभ रकम।

कैसे?

o←⍳1+⌈/⍵- इनपुट की अधिकतम ( ) oसीमा 0होती है⌈/

,o∘.,⊢- कार्टेसियन उत्पाद oऔर समतल ( ,)

⍣8 - आठ बार दोहराया गया

3 3∘⍴¨ - हर 9-आइटम सूची को 3 × 3 मैट्रिक्स में आकार दें

¨o←- इन मैट्रीस को oऔर प्रत्येक के लिए सेव करें

+/,+⌿- जाँच करें कि क्या पंक्तियाँ ( +/) स्तम्भ स्तम्भों से समरूप है ( +⌿)

⍵≡ - इनपुट के अनुरूप

o/⍨- oसत्य मूल्यों द्वारा फ़िल्टर (मेट्रिसेस सरणी)

Comments

यह बहुत अच्छा लगने वाला उत्तर स्पष्टीकरण (कृपया) की आवश्यकता है।

@Lembik स्पष्टीकरण जोड़ा

— ऊरीएल

धन्यवाद। तो आप सभी संभावित मैट्रिम्स को एन्यूमरेट करते हैं और उन लोगों की जांच करते हैं जो इस कमी को पूरा करते हैं। सबसे कुशल नहीं है, लेकिन यह काम करता है।

@ लिम्बिक युप, वह सबसे छोटा है। मैं सभी 3-आइटम सूचियों को प्राप्त करके थोड़ा अधिक कुशल प्रबंधन कर सकता हूं जो कि रकम से मेल खा सकती हैं, फिर उन लोगों को चुनें जो पहली पंक्ति के योग को फिट करते हैं, फिर पहले कॉलम के योग से मेल खाने वाले (पिछले संयोजनों में से प्रत्येक के लिए) चुनें। और आगे और पीछे। यह नॉन-ब्रूट-फोर्स जनरल एल्गोरिथम होगा।

— ऊरीएल

@EriktheOutgolfer धन्यवाद, मैं हमेशा अपने बाइट गिनती अद्यतन करने के लिए भूल जाते हैं

— ऊरीएल

Answer 2

हस्क , 20 17 बाइट्स

fȯ=⁰mΣS+Tπ3π3Θḣ▲⁰

-3 बाइट्स @ H.PWiz को धन्यवाद

xsबाधाओं को एन्कोडिंग करने वाली सूची के रूप में इनपुट लेता है [r_1,r_2,r_3,c_1,c_2,c_3], इसे ऑनलाइन आज़माएं!

व्याख्या

जानवर बल दृष्टिकोण: प्रविष्टियों के साथ सभी 3x3 ग्रिड उत्पन्न करें [0..max xs]:

f(=⁰mΣS+T)π3π3Θḣ▲⁰  -- input ⁰, for example: [1,1,1,1,1,1]
                ▲⁰  -- max of all constraints: 1
               ḣ    -- range [1..max]: [1]
              Θ     -- prepend 0: [0,1]
            π3      -- 3d cartesian power: [[0,0,0],...,[1,1,1]]
          π3        -- 3d cartesian power: list of all 3x3 matrices with entries [0..max] (too many)
f(       )          -- filter by the following predicate (eg. on [[0,0,1],[1,0,0],[0,1,0]]):
      S+            --   append to itself, itself..: [[0,0,1],[1,0,0],[0,1,0],..
        T           --   .. transposed:             ..[0,1,0],[0,0,1],[1,0,0]]
      mΣ            --   map sum: [1,1,1,1,1,1]
    =⁰              --   is it equal to the input: 1

Answer 3

ब्रेकीलॉग , 17 बाइट्स

{~⟨ṁ₃{ℕᵐ+}ᵐ²\⟩≜}ᶠ

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

चेतावनी: जल्द ही बाहर! बाहर मत करो, यह अभी भी मानव-पठनीय है, मुझे कितना खाता है, इसकी आवश्यकता नहीं है। ;)

किसी कारण से मुझे समझ में आने की उम्मीद की तुलना में बहुत लंबा होना चाहिए (13 बाइट्स):

⟨ṁ₃{ℕᵐ+}ᵐ²\⟩ᶠ

यह बाद वाला संस्करण, अगर यह काम करता है, तो इसके बजाय आउटपुट (यानी कमांड-लाइन तर्क) से इनपुट लिया होगा।

Comments

@ रिकर ओपी के "आउटपुट" अनुभाग को पढ़ें। यकीन है, यह अभी भी ब्रैकेट को अलग करने वाले कोष्ठक है, यह उन्हें भी छीन सकता है और आउटपुट अभी भी कोई डेटा नहीं खोएगा ...

— Outgolfer

Answer 4

पायथन 2 , 149 145 142 141 138 136 बाइट्स

lambda s:[i for i in product(range(max(sum(s,[]))+1),repeat=9)if[map(sum,(i[j:j+3],i[j/3::3]))for j in 0,3,6]==s]
from itertools import*

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

सूची की सूची के रूप में इनपुट लेता है: [[r1, c1], [r2, c2], [r3, c3]]

Answer 5

हास्केल, 94 88 84 79 बाइट्स

q=mapM id.(<$"abc")
f r=[k|k<-q$q$[0..sum r],(sum<$>k)++foldr1(zipWith(+))k==r]

एकल फ्लैट 6-तत्व सूची के रूप में पंक्तियों और स्तंभों की रकम लेती है [r1,r2,r3,c1,c2,c3]।

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

q=mapM id.(<$"abc")         -- helper function 

f r =                       -- 
  [k | k <-   ,    ]        -- keep all k
    q$q$[0..sum r]          --   from the list of all possible matrices with
                            --   elements from 0 to the sum of r
                            -- where
    (sum<$>k) ++            --   the list of sums of the rows followed by
    foldr1(zipWith(+))k     --   the list of sums of the columns
    == r                    -- equals the input r

जैसा कि परीक्षण करने के लिए मेट्रिसेस के तत्व ऊपर जाते हैं r, कोड बड़ी पंक्ति / स्तंभ राशि के लिए उचित समय में समाप्त नहीं होता है। यहां एक संस्करण है rजो अधिकतम तक जाता है जो तेज है, लेकिन 4 बाइट्स लंबा है: इसे ऑनलाइन आज़माएं!

Answer 6

गणितज्ञ, 81 बाइट्स

Select[0~Range~Max[s=#,t=#2]~g~3~(g=Tuples)~3,(T=Total)@#==s&&T@Transpose@#==t&]&

तत्वों के साथ सभी 3x3 मेट्रिसेस पाता है। 0.मैक्स और सही वाले का चयन करता है
इसका मतलब है कि (Max+1)^9मेट्रिसेस को जांचना होगा

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

Comments

क्या आप एक स्पष्टीकरण जोड़ सकते हैं।

@ लेम्बिक मैं आपके द्वारा कुछ परीक्षण मामलों को जोड़ने के बाद और यहां के सभी लोगों के लिए इस चुनौती को "स्पष्ट" बना दूंगा। मैंने फिर से वोट दिया लेकिन आप उन सभी के लिए इसे बेहतर बनाने की कोशिश नहीं करते जिन्हें मदद की ज़रूरत है

— J42161217

अब प्रश्न में जोड़ा गया।

क्या अभी भी स्पष्ट नहीं है? / GridTIO के साथ भी काम करते हैं ToString। इसे ऑनलाइन आज़माएं!

— user202729

@ user202729 मेरे लिए कुछ नहीं, लेकिन परीक्षण के मामले गायब थे

— J42161217

Answer 7

आर , 115 110 बाइट्स

function(S)for(m in unique(combn(rep(0:max(S),9),9,matrix,F,3,3)))if(all(c(rowSums(m),colSums(m))==S))print(m)

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

c(r1,r2,r3,c1,c2,c3)एक एकल के रूप में इनपुट लेता है vector, और मैट्रिस को स्टडआउट में प्रिंट करता है।

यह यूरिल के एपीएल उत्तर के समान है , लेकिन यह 3x3 ग्रिड को कुछ अलग तरीके से उत्पन्न करता है।

आज्ञा देना M=max(S), यह वेक्टर उत्पन्न करता है 0:M, फिर repइसे 9 बार यानी [0..M, 0...M, ..., 0...M]नौ बार खाता है । फिर यह उस नए वेक्टर के सभी संयोजनों का चयन करता है जो एक बार में 9 ले लिए गए, matrix, 3, 3प्रत्येक 9-संयोजन को एक 3x3मैट्रिक्स में परिवर्तित करने के लिए , और simplify=Fएक सरणी के बजाय एक सूची वापस करने के लिए मजबूर किया गया। यह तब इस सूची को विशिष्ट बनाता है और इसे सहेजता है m।

फिर यह mउन लोगों के लिए फ़िल्टर करता है जहां पंक्ति / स्तंभ रकम इनपुट के समान होती है, जो कि हैं और जो नहीं हैं उनके लिए कुछ भी नहीं कर रहे हैं।

चूंकि यह choose(9*(M+1),9)विभिन्न संभावित ग्रिडों ( (M+1)^9संभावनाओं से अधिक ) की गणना करता है , यह नीचे दिए गए अधिक कुशल (लेकिन कम गोल्फ वाले) उत्तर की तुलना में स्मृति / समय से अधिक तेज़ी से चलेगा:

आर , 159 बाइट्स

function(S,K=t(t(expand.grid(rep(list(0:max(S)),9)))))(m=lapply(1:nrow(K),function(x)matrix(K[x,],3,3)))[sapply(m,function(x)all(c(rowSums(x),colSums(x))==S))]

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

Comments

आर बहुत स्वागत है!

Answer 8

MATL , 35 22 बाइट्स

-13 बाइट्स लुइस मेंडो की बदौलत

X>Q:q9Z^!"@3et!hsG=?4M

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

लिंक कोड के एक संस्करण के लिए है जो थोड़ा और अच्छी तरह से प्रिंट करता है; यह संस्करण सिर्फ उन सभी मैट्रिसेस को प्रिंट करेगा, जिनके बीच एक ही नई पंक्ति है।

के रूप में इनपुट लेता है [c1 c2 c3 r1 r2 r3]।

जाहिर है, यह घातांक X^के 0...max(input)साथ कार्टेशियन पावर 9और ट्रांसपोज़िंग की गणना करता है !। फिर यह "कॉलम पर लूप करता है, प्रत्येक @को 3x3 मैट्रिक्स के रूप में फिर से आकार देना 3e, डुप्लिकेट करना t, ट्रांसपोज़ करना !और क्षैतिज रूप से उन्हें समतल करना h। फिर यह कॉलम रकम की गणना करता है s, जिसके परिणामस्वरूप वेक्टर होगा [c1 c2 c3 r1 r2 r3]। हम इनपुट के लिए तत्व की समानता करते हैं G=, और यदि ?सभी गैर- अक्ष हैं, तो हम फ़ंक्शन !द्वारा इनपुट का चयन करके सही मैट्रिक्स को पुनर्प्राप्त करते हैं 4M।

Answer 9

बैच, 367 बाइट्स

@echo off
for /l %%i in (0,1,%1)do for /l %%j in (%%i,1,%1)do for /l %%k in (%%i,1,%4)do call:c %* %%i %%j %%k
exit/b
:c
set/a"a=%1-%8,c=%4-%9,f=%8-%7,g=%9-%7,l=%5-f,m=%2-g,l^=m-l>>31&(m^l),m=%5+c-%3-f,m&=~m>>31
for /l %%l in (%m%,1,%l%)do set/a"b=%2-g-%%l,d=%5-f-%%l,e=%6-a-b"&call:l %7 %%l
exit/b
:l
echo %1 %f% %a%
echo %g% %2 %b%
echo %c% %d% %e%
echo(

शीर्ष बाएं 2 × 2 वर्ग परिणाम को मजबूर करता है, इसलिए सबसे अच्छा तरीका शीर्ष बाएँ पूर्णांक के लिए सभी मान उत्पन्न करना है, शीर्ष बाएँ और शीर्ष मध्य पूर्णांक के योग के लिए सभी मान्य मान, शीर्ष के योग के लिए सभी मान्य मान। बाएँ और मध्य बाएँ पूर्णांक, और मध्य पूर्णांक के लिए मान्य मानों की श्रेणी की गणना करें, फिर, सभी उपयुक्त सीमाओं के माध्यम से लूप होने के बाद, बाधाओं से शेष मानों की गणना करें।

Answer 10

पायथन 2 , 118 बाइट्स

def f(v,l=[],i=0):n=len(l);V=v*1;V[~n/3]-=i;V[n%3]-=i;return[l][any(V):]if n>8else V*-~min(V)and f(V,l+[i])+f(v,l,i+1)

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

---

पायथन 2 , 123 बाइट्स

V=input()
n=max(V)+1
for k in range(n**9):
 m=[];exec"m+=[k%n,k/n%n,k/n/n%n],;k/=n**3;"*3
 if map(sum,m+zip(*m))==V:print m

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