एक आयत के भीतर अद्वितीय ईंट झुकाव

Question

मैं Stackoverflow ब्राउज़ कर रहा था और एक MxN आयत टाइलिंग के बारे में यह प्रश्न देखा था , और मुझे लगा कि यह गोल्फ के लिए बहुत अच्छा होगा। यहाँ कार्य है।

आयाम M और N को देखते हुए, एक ऐसा प्रोग्राम लिखें, जो यह बताता है कि MxN आयत कितने अनूठे तरीके हैं (N, पंक्तियों की संख्या है, कॉलम नहीं। ऐसा नहीं है कि यह वास्तव में मायने रखता है) इन बाधाओं को देखते हुए टाइल किया जा सकता है।

1. सभी टाइलें 2x1 या 3x1 हैं
2. सभी टाइलें उनकी पंक्ति में रहती हैं (अर्थात वे सभी क्षैतिज हैं)
3. प्रत्येक दो आसन्न पंक्तियों के बीच दो छोरों को छोड़कर, टाइल्स को गठबंधन नहीं किया जाना चाहिए
4. एम और एन कम से कम 1 होने की गारंटी है

उदाहरण के लिए, एक 8x3 मैट्रिक्स की वैध टाइलिंग होगी

  2    3     3
  |    |     |
  v    v     v
 _______________
|___|_____|_____| 
|_____|_____|___|
|___|_____|_____|

लेकिन निम्नलिखित अमान्य होगा, क्योंकि पंक्तियाँ संरेखित होती हैं

  2    3     3
  |    |     |
  v    v     v
 _______________
|___|_____|_____| 
|_____|___|_____|
|_____|_____|___|

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

8x3: 4

3x1: 1

1x1: 0

9x4: 10

कोड गोल्फ, इतना कम जवाब जीतता है।

Comments

टाइलों के आकार का आपका वर्णन आयत के आकार से एक अलग सम्मेलन का उपयोग करता है। क्या टाइल्स वास्तव में 2x1या हैं 3x1? 4x1शून्य के लिए आउटपुट भी है ?

— FryAmTheEggman

स्वागत हे। अच्छी चुनौती की अवधारणा है, हालांकि आमतौर पर सैंडबॉक्स का उपयोग करने के लिए उन्हें मुख्य पोस्ट करने से पहले चुनौती विचारों को बाहर निकालना सबसे अच्छा है ।

— बीफस्टर

@FryAmTheEggman ऐसा लगता है कि OP ने |पंक्ति की लंबाई में योगदान नहीं करने की कोशिश की है , इस तरह एक प्रतिनिधित्व का उपयोग करके (जहां, अगर वहाँ एक पाइप नहीं है ( |), एक स्थान है)।

— आउटगोल्फर

संबंधित: एक स्थिर ईंट की दीवार बनाएँ

— xnor

एसओ पर संदर्भित प्रश्न अब और नहीं है।

— अरनौलद

Answer 1

जेली , 20 बाइट्स

2*ḃ€2‘ÄṪ⁼¥Ƈ⁸ṗfƝẸ$€ċ0

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

Comments

मुझे पता है कि गति कल्पना का हिस्सा नहीं थी, लेकिन यह 11x10 पर भी समय समाप्त हो गया जब टियो पर चलाया गया। मुझे यह समझने के लिए स्पष्टीकरण में दिलचस्पी होगी कि क्यों।

— निक केनेडी

@NickKennedy यह बहुत बड़ा इनपुट है। चौड़ाई 11 के लिए, प्रत्येक पंक्ति में 9 अलग-अलग झुकावों में से एक हो सकता है। चौड़ाई 11 और ऊंचाई 10 के लिए, वहाँ 9¹⁰ = 3486784401 संभव दीवारें हैं, जिनमें अमान्य हैं। कि कार्टेशियन शक्ति कैसे काम करती है। जाहिर है, टीआईओ के पास यह समय नहीं है कि वह मेरे घोल को दीवारों की पूरी व्यूह रचना (60 सेकंड के बाद का समय) दें। जब मुझे समय मिलेगा, मैं एक स्पष्टीकरण जोड़ूंगा।

— एग आउटोलॉफ़र

धन्यवाद। मैंने जेली को थोड़ा देखा है, लेकिन इस समय मैं लोगों की कोड क्या करता हूं यह समझने के लिए टिप्पणी स्पष्टीकरण पर भरोसा कर रहा हूं। मैंने मान लिया था कि आपके कोड ब्रूट के समाधान के लिए समय की समस्या है, जो कोड आवश्यकताओं को कम करने का एक समझदार तरीका है।

— निक केनेडी

ब्याज से बाहर मैंने आपके कोड के पहले भाग का उपयोग करके मेरे R कोड में जेली में विधि को फिर से बनाया है। यह ऑनलाइन कोशिश करो! और जबकि यह आपकी तुलना में काफी लंबा है, यह बड़ी संख्या को संभालता है। ध्यान दें कि यह वर्तमान में 1 पंक्ति को ठीक से नहीं संभालता है। मुझे संदेह है कि यह अधिक संक्षिप्त हो सकता है, लेकिन मैं जेली के लिए नया हूं।

— निक कैनेडी

Answer 2

जावास्क्रिप्ट (ईएस 6),  119 110 106 96  91 बाइट्स

रूप में इनपुट लेता है ।$(N,M)$

f=(n,m,p=0,g=(w,h=x=>g(p[g[w-=x]=1,w]||w)*g[w]--)=>w>3?h(2)+h(1):w>1&&f(n,m-1,g))=>m?g(n):1

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

टिप्पणी की गई

NB: यह कोड 3 अलग-अलग फ़ंक्शन का उपयोग करता है जो एक दूसरे को कॉल करते हैं। इससे चरों के दायरे पर नज़र रखना थोड़ा मुश्किल हो जाता है। ध्यान रखें कि को के दायरे में परिभाषित किया गया है और को के दायरे में परिभाषित किया गया है ।$g$$f$$h$$g$

f = (                    // f is a recursive function taking:
  n,                     //   n = number of columns
  m,                     //   m = number of rows
  p = 0,                 //   p = object holding the previous row
  g = (                  //   g = recursive function taking:
    w,                   //     w = remaining width that needs to be filled in the
                         //         current row
    h = x =>             //     h = helper function taking x
                         // h body:
      g(                 //   recursive call to g:
        p[g[w -= x] = 1, //     subtract either 2 or 1 from w and mark this width as used
          w              //     test p[w]
        ]                //     pass p[w] if p[w] = 1 (which will force the next iteration
                         //     to fail immediately)
        || w             //     otherwise, pass w
      )                  //   end of recursive call
      * g[w]--           //   then restore g[w] to 0
  ) =>                   // g body:
    w > 3 ?              //   if w > 3, we need to insert at least 2 more bricks:
      h(2) + h(1)        //     invoke h with x = 2 and x = 1
    :                    //   else:
      w > 1              //     this is the last brick; we just check if it can be inserted
      &&                 //     abort if w is equal to 1 (a brick does not fit in there)
      f(                 //     otherwise, do a recursive call to f:
        n,               //       n is unchanged
        m - 1,           //       decrement m
        g                //       pass g as the new reference row
      )                  //     end of recursive call
) =>                     // f body:
  m ? g(n) : 1           //   yield 1 if we made it to the last row or call g otherwise

Answer 3

आर , 243 231 बाइट्स

function(m,n,i=2*0:(m%/%6)+m%%2,j=i+(m-3*i)/2,M=Map)`if`(m<2,0,sum((e=eigen(lengths(outer(p<-unlist(M(M,list(function(x,y)cumsum(2+1:y%in%x)),M(combn,j,i,s=F),j),F),p,Vectorize(intersect)))<2))$ve%*%diag(e$va^(n-1))%*%solve(e$ve)))

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

लाइन विराम के साथ संस्करण:

function(m,n,i=2*0:(m%/%6)+m%%2,j=i+(m-3*i)/2,M=Map)`if`(m<2,0,
sum((e=eigen(lengths(outer(p<-unlist(M(M,list(function(x,y)cumsum(2+1:y%in%x)),
M(combn,j,i,s=F),j),F),p,Vectorize(intersect)))<2))$ve%*%diag(e$va^(n-1))%*%solve(e$ve)))

नोट कोई पुनरावृत्ति नहीं है, और मीटर और n के काफी बड़े मूल्यों को संभालता है (जैसे 24x20 -> 3.3e19)

यहाँ एक टिप्पणी का जवाब है जो उपरोक्त के समान ही काम करता है, लेकिन मैंने सभी कार्यों को अनसुना कर दिया है, इसलिए यह वास्तव में पठनीय है:

f <- function(m,n) {
  # First work out what potential combinations of 2s and 3s add up to m
  i <- 2*0:(m %/% 6) + m %% 2 # Vector with numbers of possible 3s
  j <- i + (m - 3 * i) / 2 # Vector with total number of 2s and 3s
  if (m < 2) {
    0 # If wall less than 2 wide, no point in continuing because answer is 0
  } else {
    # Work out all possible positions of threes for each set
    positions_of_threes <- Map(combn, j, i, simplify = FALSE)
    # Function to work out the cumulative distance along the wall for a given
    # Set of three positions and number of bricks
    make_cumulative_bricks <- function(pos_threes, n_bricks) {
      bricks <- 1:n_bricks %in% pos_threes
      cumsum(2 + bricks)
    }
    # Find all possible rows with cumulative width of wall
    # Note because this is a `Map` with depth two that needs to be vectorised
    # for both `positions_of_threes` and `j`, and we're using base R, the
    # function `make_cumulative_bricks` needs to be placed in a list
    cum_bricks <- Map(Map, list(make_cumulative_bricks), positions_of_threes, j)
    # Finally we have the list of possible rows of bricks as a flat list
    cum_bricks_unlisted <- unlist(cum_bricks, recursive = FALSE)
    # Vectorise the intersect function
    intersect_v <- Vectorize(intersect, SIMPLIFY = FALSE)
    # Find the length of all possible intersects between rows
    intersections <- outer(cum_bricks_unlisted, cum_bricks_unlisted, intersect_v)
    n_intersections <- lengths(intersections)
    # The ones not lined up will only have a single intersect at `m`
    not_lined_up <- n_intersections == 1
    # Now use method described at /programming//a/9459540/4998761
    # to calculate the (matrix of TRUE/FALSE for lined-up) to the power of `n`
    eigen_nlu <- eigen(not_lined_up)
    final_mat <- eigen_nlu$vectors %*%
      diag(eigen_nlu$values ^ (n - 1)) %*%
      solve(eigen_nlu$vectors)
    # The sum of this matrix is what we're looking for
    sum(final_mat)
  }
}
f(20,20)

एक मैट्रिक्स लेने और बार-बार इसे खुद से गुणा करने की विधि स्टैकओवरफ़्लो पर एक प्रश्न से है । यह दृष्टिकोण यहाँ काम करता है क्योंकि यह प्रभावी रूप से ईंटों की विभिन्न संभावित पंक्तियों के माध्यम से शाखाओं की संचयी संख्या की गणना करता है।

अगर बाहरी पैकेज की अनुमति है, तो मैं इसे 192 तक ले सकता हूं:

function(m,n,i=2*0:(m%/%6)+m%%2,j=i+(m-3*i)/2,M=purrr::map2)`if`(m<2,0,sum(expm::`%^%`(lengths(outer(p<-unlist(M(M(j,i,combn,s=F),j,M,~cumsum(2+1:.y%in%.)),F),p,Vectorize(intersect)))<2,n-1)))

Answer 4

जेली , 26 बाइट्स

2*ḃ€2‘ÄṪ⁼¥Ƈ⁸œ&L¬ɗþ`æ*⁴’¤SS

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

टूटा:

हटाए गए अंत के साथ संचयी रकम के रूप में संभावित दीवारों की एक सूची बनाएं:

2*ḃ€2‘ÄṪ⁼¥Ƈ⁸

एक दूसरे के खिलाफ सभी संभावित दीवारों की बाहरी तालिका खोजें जिसमें कोई चौराहा न हो:

œ&L¬ɗþ`

इस मैट्रिक्स को (N-1) की शक्ति पर ले जाएं और फिर इसे पूरा करें:

æ*⁴’¤SS

संभावित दीवारों की सूची उत्पन्न करने के लिए @ EriktheOutgolfer के उत्तर से पहले बिट का उपयोग करता है, और फिर मेरे R उत्तर से मैट्रिक्स प्रतिच्छेदन और मैट्रिक्स घातांक दृष्टिकोण का उपयोग करता है। जैसे, यह बड़े एन के साथ भी अच्छा काम करता है। यह मेरा पहला जेली उत्तर है, और मुझे संदेह है कि यह अधिक गोल्फ हो सकता है। मैं आदर्श रूप से पहले खंड को बदलना चाहता हूं ताकि समय और स्मृति आवश्यकताओं को एम के साथ तेजी से स्केल न करें।

Answer 5

05AB1E , 42 बाइट्स

Åœʒ23yåP}€œ€`Ùε.¥¦¨}IиI.ÆÙεøyíø‚€€üQOO_P}O

मुझे यह पोस्ट करने में लगभग शर्म आ रही है, और यह निश्चित रूप से ए लॉट द्वारा एक अलग दृष्टिकोण के साथ गोल्फ हो सकता है, लेकिन चूंकि इसे पूरा करने में कुछ समय लगा, मैंने इसे वैसे भी पोस्ट करने का फैसला किया और इसे यहां से नीचे गोल्फ कर दिया। चुनौती आसान है क्योंकि यह इमो है, लेकिन मैं निश्चित रूप से यहां एक गलत दृष्टिकोण का उपयोग कर रहा हूं और मुझे लग रहा है कि 05AB1E लगभग 25 बाइट्स कर सकता है।

इसे ऑनलाइन आज़माएं। नोट: न केवल यह लंबा है, यह भी अक्षम है, क्योंकि 9x4परीक्षण का मामला TIO पर लगभग 40 सेकंड में चलता है।

स्पष्टीकरण:

Ŝ             # Get all possible ways to sum to the (first) implicit input
               #  i.e. 8 → [[1,1,1,1,1,1,1,1],[1,1,1,1,1,1,2],[1,1,1,1,1,3],[1,1,1,1,2,2],[1,1,1,1,4],[1,1,1,2,3],[1,1,1,5],[1,1,2,2,2],[1,1,2,4],[1,1,3,3],[1,1,6],[1,2,2,3],[1,2,5],[1,3,4],[1,7],[2,2,2,2],[2,2,4],[2,3,3],[2,6],[3,5],[4,4],[8]]
  ʒ23yåP}      # Only leave those consisting of 2s and/or 3s
               #  → [[2,2,2,2],[2,3,3]]
         €œ    # For each: get all permutations
           €`  # Flatten this list of lists once
             Ù # And uniquify it (leaving all possible distinct rows of bricks)
               #  → [[2,2,2,2],[3,3,2],[3,2,3],[2,3,3]]
ε    }         # For each:
 .¥            #  Get the cumulative sum
   ¦¨          #  With the leading 0 and trailing first input removed
               #   → [[2,4,6],[3,6],[3,5],[2,5]]
      Iи       # Repeat this list the second input amount of times
               #  i.e. 3 → [[2,4,6],[3,6],[3,5],[2,5],[2,4,6],[3,6],[3,5],[2,5],[2,4,6],[3,6],[3,5],[2,5]]
        I.Æ    # Get all combinations of lists the size of the second input
           Ù   # And uniquify the result (leaving all possible distinct walls)
               #  → [[[2,4,6],[3,6],[3,5]],[[2,4,6],[3,6],[2,5]],[[2,4,6],[3,6],[2,4,6]],[[2,4,6],[3,6],[3,6]],[[2,4,6],[3,5],[2,5]],[[2,4,6],[3,5],[2,4,6]],[[2,4,6],[3,5],[3,6]],[[2,4,6],[3,5],[3,5]],[[2,4,6],[2,5],[2,4,6]],[[2,4,6],[2,5],[3,6]],[[2,4,6],[2,5],[3,5]],[[2,4,6],[2,5],[2,5]],[[2,4,6],[2,4,6],[3,6]],[[2,4,6],[2,4,6],[3,5]],[[2,4,6],[2,4,6],[2,5]],[[2,4,6],[2,4,6],[2,4,6]],[[3,6],[3,5],[2,5]],[[3,6],[3,5],[2,4,6]],[[3,6],[3,5],[3,6]],[[3,6],[3,5],[3,5]],[[3,6],[2,5],[2,4,6]],[[3,6],[2,5],[3,6]],[[3,6],[2,5],[3,5]],[[3,6],[2,5],[2,5]],[[3,6],[2,4,6],[3,6]],[[3,6],[2,4,6],[3,5]],[[3,6],[2,4,6],[2,5]],[[3,6],[2,4,6],[2,4,6]],[[3,6],[3,6],[3,5]],[[3,6],[3,6],[2,5]],[[3,6],[3,6],[2,4,6]],[[3,6],[3,6],[3,6]],[[3,5],[2,5],[2,4,6]],[[3,5],[2,5],[3,6]],[[3,5],[2,5],[3,5]],[[3,5],[2,5],[2,5]],[[3,5],[2,4,6],[3,6]],[[3,5],[2,4,6],[3,5]],[[3,5],[2,4,6],[2,5]],[[3,5],[2,4,6],[2,4,6]],[[3,5],[3,6],[3,5]],[[3,5],[3,6],[2,5]],[[3,5],[3,6],[2,4,6]],[[3,5],[3,6],[3,6]],[[3,5],[3,5],[2,5]],[[3,5],[3,5],[2,4,6]],[[3,5],[3,5],[3,6]],[[3,5],[3,5],[3,5]],[[2,5],[2,4,6],[3,6]],[[2,5],[2,4,6],[3,5]],[[2,5],[2,4,6],[2,5]],[[2,5],[2,4,6],[2,4,6]],[[2,5],[3,6],[3,5]],[[2,5],[3,6],[2,5]],[[2,5],[3,6],[2,4,6]],[[2,5],[3,6],[3,6]],[[2,5],[3,5],[2,5]],[[2,5],[3,5],[2,4,6]],[[2,5],[3,5],[3,6]],[[2,5],[3,5],[3,5]],[[2,5],[2,5],[2,4,6]],[[2,5],[2,5],[3,6]],[[2,5],[2,5],[3,5]],[[2,5],[2,5],[2,5]]]
ε              # Map all walls `y` to:
 ø             #  Zip/transpose; swapping rows and columns
 yí            #  Reverse each row in a wall `y`
   ø           #  Also zip/transpose those; swapping rows and columns
 ‚             #  Pair both
  €            #  For both:
   €           #   For each column:
    ü          #    For each pair of bricks in a column:
     Q         #     Check if they are equal to each other (1 if truthy; 0 if falsey)
    O          #    Then take the sum of these checked pairs for each column
   O           #   Take the sum of that entire column
   _           #   Then check which sums are exactly 0 (1 if 0; 0 if anything else)
   P           #   And check for which walls this is only truthy by taking the product
}O             # After the map: sum the resulting list
               # (and output it implicitly as result)

Answer 6

चारकोल , 89 बाइट्स

Ｎθ⊞υ⟦⟧≔⟦⟧ηＦυＦ⟦²¦³⟧«≧⁺∧Ｌι§ι⁰κ¿⁼κθ⊞ηι¿‹κθ⊞υ⁺⟦κ⟧ι»≔Ｅη⟦ι⟧ζＦ⊖Ｎ«≔ζι≔⟦⟧ζＦιＦη¿¬⊙§κ⁰№λμ⊞ζ⁺⟦λ⟧κ»ＩＬζ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। TIO पर लगभग 12 तक आकार की आयतों के लिए काम करता है, लेकिन सूची चौराहे के बजाय बिट ट्विडलिंग का उपयोग करके 2 बाइट्स की लागत के बारे में तीन गुना तेजी से बनाया जा सकता है। स्पष्टीकरण:

Ｎθ

चौड़ाई इनपुट करें।

⊞υ⟦⟧

बिना ईंटों वाली पंक्ति से शुरू करें।

≔⟦⟧η

पूर्ण पंक्तियों के साथ प्रारंभ करें।

Ｆυ

पंक्तियों पर लूप।

Ｆ⟦²¦³⟧«

ईंटों के ऊपर लूप।

≧⁺∧Ｌι§ι⁰κ

वर्तमान पंक्ति की चौड़ाई में ईंट की चौड़ाई जोड़ें।

¿⁼κθ⊞ηι

यदि इनपुट चौड़ाई में यह परिणाम है तो इस पंक्ति को पूर्ण पंक्तियों की सूची में जोड़ें।

¿‹κθ⊞υ⁺⟦κ⟧ι»

अन्यथा यदि यह अभी भी इनपुट की चौड़ाई से कम है तो नई पंक्ति को पंक्तियों की सूची में जोड़ें, इस प्रकार इसे बाद के प्रवाह द्वारा उठाया जा सकता है।

≔Ｅη⟦ι⟧ζ

एक पंक्ति की दीवारों की एक सूची बनाओ।

Ｆ⊖Ｎ«

ऊंचाई से एक से कम पर लूप।

≔ζι

दीवारों की सूची सहेजें।

≔⟦⟧ζ

दीवारों की सूची साफ़ करें।

Ｆι

दीवारों की सहेजी गई सूची पर लूप करें।

Ｆη

पूर्ण पंक्तियों पर लूप करें।

¿¬⊙§κ⁰№λμ⊞ζ⁺⟦λ⟧κ»

यदि पंक्ति को इस दीवार में जोड़ा जा सकता है तो दीवारों की सूची में जोड़ दें।

ＩＬζ

दीवारों की अंतिम सूची की लंबाई का उत्पादन।