একটি আয়তক্ষেত্রের মধ্যে অনন্য ইট টিলিংস

Question

আমি স্ট্যাকওভারফ্লো ব্রাউজ করছিলাম এবং এমএক্সএন আয়তক্ষেত্রটি টাইলিংয়ের বিষয়ে এই প্রশ্নটি দেখেছি এবং আমি ভেবেছিলাম এটি গল্ফের জন্য দুর্দান্ত। এখানে কাজটি করা হচ্ছে।

এম এবং এন মাত্রা দেওয়া, একটি প্রোগ্রাম লিখুন যা একটি এমএক্সএন আয়তক্ষেত্রটি কতগুলি অনন্য উপায়ে আউটপুট করে (এন সারিগুলির সংখ্যা, কলাম নয় not এটি সত্যিকার অর্থে গুরুত্বপূর্ণ নয়) এই সীমাবদ্ধতাগুলি দেখিয়ে টাইল করা যেতে পারে।

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

স্বাগত. দুর্দান্ত চ্যালেঞ্জ ধারণাটি, তবে সাধারণত স্যান্ডবক্সকে চ্যালেঞ্জ আইডিয়াগুলিকে প্রধানতে পোস্ট করার আগে হাতুড়ি দেওয়ার জন্য ব্যবহার করা ভাল ।

— গরুর মাংস 21

@ ফ্রাইআম দ্য এজিগম্যান দেখে মনে হচ্ছে ওপি এই জাতীয়| প্রতিনিধিত্ব ব্যবহার করে (যেখানে, যদি পাইপ না থাকে ), সেখানে কোনও স্থান থাকে) সারিটির দৈর্ঘ্যে অবদান না দেওয়ার চেষ্টা করে । |

— এরিক দি আউটগল্ফার

সম্পর্কিত: একটি স্থির ইটের প্রাচীর তৈরি করুন

— xnor

এসও-তে রেফারেন্স করা প্রশ্ন আর নেই।

— আর্নল্ড

Answer 1

জেলি , 20 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Comments

আমি জানি গতি অনুমানের অংশ ছিল না, তবে টিওতে চালিত হওয়ার পরে এটি 11x10 এও শেষ হয়েছে। কেন তা বোঝার জন্য আমি একটি ব্যাখ্যায় আগ্রহী।

— নিক কেনেডি

@ নিক কেনেডি এটি অনেক বড় একটি ইনপুট। প্রস্থ 11 এর জন্য, প্রতিটি সারিতে 9 টির মধ্যে একটি আলাদা টিলিং থাকতে পারে। প্রস্থ 11 এবং উচ্চতা 10 এর জন্য, 9 invalid = 3486784401 সম্ভাব্য দেয়াল রয়েছে, অবৈধগুলি সহ। কার্তেসিয়ান শক্তি এইভাবে কাজ করে। স্পষ্টতই, টিআইওর কাছে আমার সমাধানটি দেয়ালের পুরো অ্যারে গণনা করার সময় নেই (এটি 60 সেকেন্ড পরে বেরিয়ে যায়)। সময় পেলে আমি একটি ব্যাখ্যা যুক্ত করব।

— এরিক দি আউটগল্ফার

ধন্যবাদ। আমি জেলির দিকে একটু তাকালাম, তবে এই মুহুর্তে আমি জনগণের কোড কী করে তা বোঝার জন্য মন্তব্য করা মন্তব্যের উপর নির্ভরশীল। আমি সময় ইস্যুতে ধরে নিয়েছি যে আপনার কোড ব্রুট সমাধানটিকে জোর করে, যা কোডের প্রয়োজনীয়তা হ্রাস করার একটি বুদ্ধিমান উপায়।

— নিক কেনেডি

আগ্রহের বাইরে আমি আপনার কোডের প্রথম অংশটি ব্যবহার করে আমার আর কোডে জেলি পদ্ধতিটি পুনরায় তৈরি করেছি। এটি এর অনলাইনে চেষ্টা করুন! এবং এটি আপনার তুলনায় যথেষ্ট দীর্ঘ, এটি বৃহত্তর সংখ্যা পরিচালনা করে। নোট করুন এটি বর্তমানে 1 টি সারি সঠিকভাবে পরিচালনা করে না। আমি সন্দেহ করি এটি আরও সংক্ষিপ্ত হতে পারে তবে আমি জেলির কাছে নতুন।

— নিক কেনেডি

Answer 2

জাভাস্ক্রিপ্ট (ES6),  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

এটি অনলাইন চেষ্টা করুন!

মন্তব্য

$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)))

কোনও পুনরাবৃত্তি নোট করুন, এবং এম এবং এন এর মোটামুটি বড় মানগুলি পরিচালনা করে (যেমন 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

সম্ভাব্য দেয়ালগুলির তালিকা তৈরি করতে @ এরিকথিউটগলফারের উত্তর থেকে প্রথম বিটটি ব্যবহার করে এবং তারপরে আমার আর উত্তর থেকে ম্যাট্রিক্স ছেদ এবং ম্যাট্রিক্স এক্সপেনসিয়েশন পদ্ধতির ব্যবহার করুন। যেমনটি এটি বৃহত্তর এন এর সাথেও ভাল কাজ করে This আমি প্রথম বিভাগটিও আদর্শভাবে পরিবর্তন করতে চাই যাতে এম এবং মেমরির সাথে সময় এবং মেমরির প্রয়োজনীয়তাগুলি দ্রুত স্কেল না করে

Answer 5

05 এ বি 1 ই , 42 বাইট

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

আমি এটি পোস্ট করতে প্রায় লজ্জা পেয়েছি এবং এটি অবশ্যই একটি ভিন্ন পদ্ধতির সাথে খুব বেশি কিছু দ্বারা গল্ফ হতে পারে তবে এটি সম্পূর্ণ হতে কিছুক্ষণ সময় নিয়েছে আমি যেভাবেই পোস্ট করার সিদ্ধান্ত নিয়েছি এবং এখান থেকে এটি গল্ফ করে। চ্যালেঞ্জটি ইমোয়ের চেয়ে সহজ দেখায় তবে আমি অবশ্যই এখানে একটি ভুল পন্থা ব্যবহার করছি এবং আমার মনে হয় যে 05 এবি 1 ই প্রায় 25 বাইট করতে পারে ..

এটি অনলাইনে চেষ্টা করুন। দ্রষ্টব্য: এটি কেবল দীর্ঘ নয়, এটি অদক্ষও, যেহেতু 9x4টেস্ট কেসটি টিআইওতে প্রায় 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 বাইট

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। টিআইও-তে প্রায় 12 অবধি আকারের আয়তক্ষেত্রের জন্য কাজ করে তবে তালিকার ছেদটি পরিবর্তে বিট টুইডলিং ব্যবহার করে 2 বাইটের ব্যয়ে প্রায় তিনগুণ দ্রুত তৈরি করা যেতে পারে। ব্যাখ্যা:

Ｎθ

প্রস্থ ইনপুট।

⊞υ⟦⟧

কোনও ইট ছাড়াই একটি সারি দিয়ে শুরু করুন।

≔⟦⟧η

কোন সম্পূর্ণ সারি দিয়ে শুরু করুন।

Ｆυ

সারিগুলির উপর লুপ করুন।

Ｆ⟦²¦³⟧«

ইট উপর লুপ।

≧⁺∧Ｌι§ι⁰κ

বর্তমান সারির প্রস্থে ইটের প্রস্থ যুক্ত করুন।

¿⁼κθ⊞ηι

যদি ইনপুট প্রস্থের ফলাফল হয় তবে এই সারিটি সম্পূর্ণ হওয়া সারিগুলির তালিকায় যুক্ত করুন।

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

অন্যথায় যদি এটি এখনও ইনপুট প্রস্থের চেয়ে কম হয় তবে সারিগুলির তালিকায় নতুন সারি যুক্ত করুন, সুতরাং এটি পরবর্তী পুনরাবৃত্তির দ্বারা বাছাইয়ের কারণ হবে।

≔Ｅη⟦ι⟧ζ

এক সারির দেয়ালের একটি তালিকা তৈরি করুন।

Ｆ⊖Ｎ«

উচ্চতার চেয়ে একেরও কম লুপ।

≔ζι

দেয়ালের তালিকা সংরক্ষণ করুন।

≔⟦⟧ζ

দেয়ালের তালিকা সাফ করুন।

Ｆι

দেয়ালের সংরক্ষিত তালিকার উপরে লুপ করুন।

Ｆη

সমাপ্ত সারিতে লুপ করুন।

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

সারিটি যদি এই দেয়ালে যুক্ত করা যায় তবে এটিকে দেয়ালের তালিকায় যুক্ত করুন।

ＩＬζ

দেয়ালের চূড়ান্ত তালিকার দৈর্ঘ্য আউটপুট করুন।