डोमिनोज़ झुकाव की संख्या

Question

एक प्रोग्राम या समारोह है कि दिए गए सकारात्मक लिखें एन और मीटर वैध अलग डोमिनो टाइलिंग आप एक में फिट कर सकते हैं की संख्या की गणना करता है n द्वारा मीटर आयत। यह पूर्णांक अनुक्रमों के ऑनलाइन विश्वकोश में A099390 अनुक्रम है । आप किसी भी उचित प्रारूप में फ़ंक्शन तर्क (ओं), सीएलए या स्टड पर इनपुट ले सकते हैं। आपको आउटपुट के रूप में एक पूर्णांक वापस करना होगा या प्रिंट करना होगा।

प्रत्येक टाइलिंग को कोई अंतराल नहीं छोड़ना चाहिए, और हर अलग-अलग टाइलिंग की गणना की जाती है, जिसमें घुमाव, प्रतिबिंब आदि शामिल हैं। उदाहरण के लिए, 2x3 के लिए झुकाव हैं:

|--    |||    --| 
|--    |||    --|

उदाहरण इनपुट / आउटपुट:

1,  9 -> 0
2,  2 -> 2
2,  3 -> 3
4,  4 -> 36
4,  6 -> 281
6,  6 -> 6728
7, 10 -> 53175517

आपके प्रोग्राम को सैद्धांतिक रूप से किसी भी n और m के लिए काम करना चाहिए , लेकिन अगर आपके प्रोग्राम को बहुत अधिक मेमोरी या आपके डेटा प्रकार की आवश्यकता है, तो यह बहाना है। आपके कार्यक्रम को किसी भी n, m <= 8 के लिए सही ढंग से काम करना चाहिए ।

---

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

आप हमारे जीवन को बहुत आसान बना सकते थे यदि आपने केवल 2n x 2 मीटर क्षेत्रों की अनुमति दी थी , तो अच्छी चुनौती!

— 12

इस सवाल की तरह ही कोडगॉल्फ.स्टैकएक्सचेंज.com/q/51067/15599 केवल छोटा, और धीमा

— लेवल रिवर सेंट

@ edc65 Damnit = / मैं कुछ भी उपन्यास के बारे में नहीं सोच सकता ... लगभग हर चुनौती जो मुझे लगता है कि पहले से ही किसी न किसी रूप में हो चुकी है। किसी भी तरह से, चुनौतियां बिल्कुल वैसी नहीं हैं क्योंकि मेरा सवाल एक कोड गोल्फ है, और आपको झुकाव की खोज करने की आवश्यकता नहीं है - केवल उनमें से राशि। हो सकता है कि लोग ब्रूटफोर लिखने के बजाय अच्छे फॉर्मूले का इस्तेमाल कर सकते हैं।

— orlp

सहमत - अन्य टिप्पणी को हटाने के लिए

— edc65

Copied bilbo की टिप्पणी (जिसे उन्होंने 1 प्रतिनिधि के कारण उत्तर के रूप में पोस्ट किया): "यह समस्या एक SPOJ चुनौती है: spoj.com/problems/MNILE SPOJ पर सबसे छोटा कोड awk में 98 बाइट्स है।" । मुझे लगता है कि मैं दोगुना अनजान हूँ - मैं अनजान था।

— orlp

Answer 1

अजगर, 30 29 बाइट्स

L?bsmy-tb]dfq1.a-VThbb1y*FUMQ

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

सभी उदाहरण इनपुट ऑनलाइन संकलक में चलते हैं। अंतिम हालांकि कुछ सेकंड लगते हैं।

स्पष्टीकरण:

अपने कोड में मैं एक पुनरावर्ती कार्य को परिभाषित करूंगा y। फ़ंक्शन y2D-निर्देशांक की एक सूची लेता है और इन निर्देशांक का उपयोग करके विभिन्न डोमिनोज़ झुकाव की संख्या देता है। जैसे y([[0,0], [0,1]]) = 1(एक क्षैतिज डोमिनोज़), y([[0,0], [1,1]]) = 0(निर्देशांक आसन्न नहीं हैं) और y([[0,0], [0,1], [1,0], [1,1]]) = 2(या तो दो क्षैतिज या दो ऊर्ध्वाधर डोमिनोज़)। फ़ंक्शन को परिभाषित करने के बाद, मैं इसे सभी निर्देशांक के [x,y]साथ कॉल करूंगा x in [0, 1, m-1], y in [0, 1, n-1]।

पुनरावर्ती कार्य कैसे कार्य करता है? यह काफी सरल है। यदि कोर्डर्स की सूची खाली है, तो वास्तव में एक मान्य टाइलिंग और yरिटर्न है 1।

अन्यथा मैं सूची में पहला समन्वय लेता हूं b[0], और पड़ोसियों के लिए शेष निर्देशांक खोजता हूं । यदि कोई पड़ोसी नहीं है b[0], तो कोई छेड़छाड़ संभव नहीं है, इसलिए मैं वापस लौटता हूं। 0. यदि एक या एक से अधिक पड़ोसी हैं, तो झुकाव की संख्या है (झुकाव की संख्या जहां मैं b[0]एक पड़ोसी के माध्यम से एक डोमिना से जुड़ता हूं , प्लस) झुकाव की संख्या जहां मैं b[0]दूसरे पड़ोसी के साथ जुड़ता हूं , प्लस ...) इसलिए मैं प्रत्येक पड़ोसी के लिए संक्षिप्त सूची के साथ फ़ंक्शन को पुन: कॉल करता हूं (दो सहयोगियों b[0]और पड़ोसी को हटाकर )। बाद में मैं सभी परिणामों को समेटता हूं और उन्हें वापस करता हूं।

कोर्ड्स के आदेश के कारण हमेशा केवल दो पड़ोसी संभव होते हैं, एक दाईं ओर और एक नीचे। लेकिन मेरे एल्गोरिथ्म के बारे में परवाह नहीं है।

                          UMQ  convert the input numbers into ranges
                        *F     Cartesian product (coords of each square)
L                              define a function y(b):
 ?b                              if len(b) > 0:
           f         b             filter b for squares T, which satisfy:
              .a-VThb                Euclidean distance between T and b[0]
            q1                       is equal to 1 (direct neighbors)
    m                              map each neighbor d to:
      -tb]d                          remove d from b[1]
     y                               and call recursively y with the rest
   s                               sum all those values and return them
                                 else:
                      1            return 1 (valid domino tiling found)
                       y*FUMQ  Call y with all coords and print the result  

Comments

क्या आप हमें थोड़ा और बता सकते हैं कि आपका कार्यक्रम कैसे काम करता है? मैं टिप्पणियों से आपके एल्गोरिथ्म का पता नहीं लगा सका।

— दोष

@flawr मैंने अपने एल्गोरिथ्म का स्पष्टीकरण जोड़ा।

— जकुब

@Jaketube स्पष्टीकरण के लिए धन्यवाद, मैं वास्तव में पुनरावर्ती दृष्टिकोण पसंद करता हूं!

— दोष

Answer 2

मतलाब, 292

मुझे यकीन है कि इसे केवल दूसरी भाषा में पोर्ट करके इसे बहुत छोटा किया जा सकता है।

मूल विचार क्रूर है: मैं m*n/2एक m*nबोर्ड पर डोमिनोज़ ईंटों को रखने के सभी तरीकों की गणना के साथ आया था । लेकिन इस गणना में कई अवैध झुकाव भी शामिल हैं (ईंटें जो ओवरलैप करती हैं या बोर्ड के बाहर जाती हैं।) इसलिए कार्यक्रम उन सभी झुकावों का निर्माण करता है, और केवल मान्य लोगों को गिनता है। रनटाइम जटिलता के बारे में है O(2^(m*n/2) * m*n)। मेमोरी कोई समस्या नहीं है 8x8क्योंकि इसमें केवल O(m*n)मेमोरी की आवश्यकता होती है। लेकिन इसके लिए आवश्यक समय 8x8लगभग 20 दिन है।

यहां पूरी तरह से टिप्पणी वाला संस्करण है जो बताता है कि क्या चल रहा है।

पुनश्च: अगर किसी को पता है कि मतलाब सिंटैक्स हाइलाइटिंग का काम कैसे करना है, तो कृपया इस उत्तर में संबंधित टैग को शामिल करें!

function C=f(m,n)
d = ceil(m*n/2);%number of dominoes
%enumeration: %the nth bit in the enumeration says whether the nth 
% domino pice is upright or not. we enumerate like this:
% firt piece goes top left:
% next piece goes to the left most column that has an empty spot, in the
% top most empty spot of that column
C=0;%counter of all valid tilings
for e=0:2^d-1 %go throu all enumerations
    %check whether each enumeration is valid
    A = ones(m,n);
    %empty spots are filled with 1
    %filled spots are 0 (or if overlapping <0) 
    v=1;%flag for the validity. hte grid is assumed to be valid until proven otherwise
    for i=1:d %go throu all pieces, place them in A
        %find the column where to place:
        c=find(sum(A)>0,1);
        %find the row where to place:
        r=find(A(:,c)>0,1);
        %find direction of piece:
        b=de2bi(e,d);
        if b(i)
            x=0;y=1;
        else
            x=1;y=0;
        end
        %fill in the piece:
        try
            A(r:r+y,c:c+x)=A(r:r+y,c:c+x)-1;
        catch z
            v=0;break;
        end
        %check whether A has no overlapping pieces
        if any(A(:)<0)
            v=0;break;
        end
    end
    %if valid, count it as valid
    if v && ~norm(A(:))
        disp(A)
        C=C+1;
    end
end

यहाँ पूरी तरह से एक गोल्फ है:

function C=f(m,n);m=4;n=6;d=ceil(m*n/2);C=0;for e=0:2^d-1;A=ones(m,n);v=1;for i=1:d;c=find(sum(A)>0,1);r=find(A(:,c)>0,1);b=de2bi(e,d);if b(i);x=0;y=1;else;x=1;y=0;end;try;A(r:r+y,c:c+x)=A(r:r+y,c:c+x)-1;catch z;v=0;break;end;if any(A(:)<0);v=0;break;end;end;if v && ~norm(A(:));C=C+1;end;end

Answer 3

C89, 230 बाइट्स

f(n,m,b)int*b;{int s,i;s=i=0;
while(b[i])if(++i==n*m)return 1;
if(i/n<m-1){b[i]=b[i+n]=1;s+=f(n,m,b);b[i]=b[i+n]=0;}
if(i%n<n-1&&!(b[i]|b[i+1])){b[i]=b[i+1]=1;s+=f(n,m,b);b[i]=b[i+1]=0;}
return s;}
g(n,m){int b[99]={};return f(n,m,b);}

पठनीयता के लिए मैंने यह उत्तर दिया - 230 बाइट्स प्राप्त करने के लिए सभी नई सूचियों को सुरक्षित रूप से हटाया जा सकता है।

एक फ़ंक्शन को परिभाषित करता है int g(int n, int m)जो झुकाव की संख्या लौटाता है। यह एक हेल्पर फ़ंक्शन का उपयोग करता fहै जो एक डोमिनोज़ को रखकर और फिर एक साझा बोर्ड पर डोमिनोज़ को हटाकर सभी मान्य झुकावों पर निर्भर करता है।

Answer 4

अजगर 243

मैंने एक क्रूर बल दृष्टिकोण का विकल्प चुना:

• मी * एन / 2 दिशाएं उत्पन्न करें;
• कोशिश करें और एम * एन बोर्ड पर डोमिनोज़ फिट करें।

यदि वे सभी फिट हैं और कोई स्थान नहीं बचा है तो हमारे पास एक वैध प्रविष्टि है।

यहाँ कोड है:

import itertools as t
m,n=input()
c,u=0,m*n
for a in t.product([0,1],repeat=u/2):
 l,k,r,h=[' ',]*u,0,'-|',[1,m]
 for t in a:
  l[k]=r[t]
  k+=h[t]   
  if k%m<m and k/m<n and l[k]==' ':l[k]=r[t]
  k=''.join(l).find(' ',1)
 if k<0:c+=1
print c