কোথায় যাচ্ছে সেই সাপ?

35

একটি ফাংশন লিখুন (যতটা সম্ভব বাইট ব্যবহার করে) যে কোনও কলাম এবং সারিতে যে দ্বি-মাত্রিক অ্যারে নেয়:

  • 0 খালি ব্লক প্রতিনিধিত্ব করে,
  • 1 সাপ ব্লক প্রতিনিধিত্ব করে।

ফাংশনটি অবশ্যই সাপটি যে পথে যাত্রা করেছিল তার সংখ্যাটি ফিরিয়ে আনতে হবে।

উদাহরণ 1:

ইনপুট:

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

আউটপুট: 2

উপরের উদাহরণে, ফাংশনটি ফিরে আসবে 2কারণ উত্তরগুলির মধ্যে একটির একটি হ'ল:

এখানে চিত্র বর্ণনা লিখুন

উদাহরণ 2:

ইনপুট:

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

আউটপুট: 6

এই উদাহরণে ফাংশনটি ফিরে আসবে 6কারণ উত্তরগুলির মধ্যে একটি হল:

এখানে চিত্র বর্ণনা লিখুন

বিঃদ্রঃ:

ইনপুট মূল্যায়ন করার সময়, আপনি ধরে নিতে পারেন:

  • কলামগুলির প্রতিনিধিত্বকারী অ্যারেগুলির সর্বদা একই আকার থাকবে (যাতে অ্যারেগুলি আয়তক্ষেত্রাকার হয়);
  • কমপক্ষে 1 টি বৈধ পথ রয়েছে;
  • সাপটি প্রান্ত দিয়ে চলতে পারে না (যেমন সাপের কয়েকটি সংস্করণে ঘটতে পারে);
  • সাপের সর্বদা কমপক্ষে 2 টি ব্লক থাকবে;
  • সাপটি তির্যকভাবে চলতে পারে না;
  • পথ নির্দেশিত হয়। (সুতরাং, দুটি অবস্থান পৃথক অবস্থানে শেষ হয় তবে অন্যথায় ঠিক একইরকম দেখতে একই পন্থা নয়, এটি মোটে যোগ করবে)
code-golf  grid  binary-matrix 
— Adelin
সূত্র
13
পিপিসিজিতে আপনাকে স্বাগতম! ভাল প্রথম চ্যালেঞ্জ।
— লাইকনি
5
গৌণ দ্রষ্টব্য: "সর্বদা সর্বদা কমপক্ষে একটি সারি থাকবে এবং একটি কলাম থাকবে" অপ্রয়োজনীয়, প্রদত্ত সাপটির সর্বদা কমপক্ষে 2 টি ব্লক থাকবে।
— স্টিভি গ্রিফিন
2
প্রস্তাবিত পরীক্ষার কেস: @ স্টিভিগ্রিফিন এবং একটি দিয়েছিল [[0,0,1,1],[0,0,1,1],[0,0,1,1]]। বেশিরভাগ উত্তর 16 দেয়, তবে একটি 15 দেয়
— কেভিন ক্রুইজসেন
2
এ পর্যন্ত এটি সবাই মত মনে হয় (আমি সহ) ধৃষ্টতা যে 2 পাথ বিভিন্ন অবস্থানের এ বিভক্তি কিন্তু অন্যথায় ঠিক একই খুঁজছেন হয় করেছে না একই পথ। আমি মনে করি এটি স্পষ্টভাবে নির্দিষ্ট করা প্রয়োজন।
— আর্নৌলদ
2
@ আরনাউল্ড - ঠিক আছে। দুটি অবস্থান বিভিন্ন অবস্থানে শেষ হয় তবে অন্যভাবে দেখতে একইরকম পথ একই নয় , এটি মোট যোগ করে দেবে to আপনার উদাহরণে মোট 16 হওয়া উচিত যদি আমার ভুল না হয় - আমি এখনই নির্ভুলভাবে গণনা করতে পারি না তবে আপনি
— বিষয়টিটি

উত্তর:

11

ওল্ফ্রাম ভাষা (গণিত) , 16 + 83 = 99 বাইট

গ্রন্থাগার আমদানি বিবৃতি (16 বাইট):

<<Combinatorica`

আসল ফাংশন বডি (83 বাইট):

Length@HamiltonianCycle[MakeGraph[#~Position~1~Join~{1>0},##||Norm[#-#2]==1&],All]&

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

নোট করুন যে প্রশ্নটি কেবল গ্রাফের হ্যামিল্টনীয় পথের সংখ্যা জিজ্ঞাসা করে।

যাইহোক, (কোনও কারণে) HamiltonianPathফাংশনটি নির্দেশিত গ্রাফ ( উদাহরণ ) সহ সত্যই কাজ করে না । সুতরাং, আমি এই ম্যাথমেটিকা.এসই প্রশ্নে বর্ণিত কাজটি ব্যবহার করেছি :

  • এমন একটি ভার্টেক্স যুক্ত করুন (যা বলা হয় True) যা অন্য সমস্ত শীর্ষে সংযুক্ত থাকে।
  • ফলাফল গ্রাফের হ্যামিল্টোনীয় চক্রের সংখ্যা গণনা করুন।

MakeGraphবুলিয়ান ফাংশনটি ব্যবহার করে (বিরক্তিকরভাবে কোনও সরাসরি সমতুল্য অন্তর্নির্মিত নেই) ব্যবহার করে গ্রাফটি তৈরি করা হয়েছে ##||Norm[#-#2]==1&, যা Trueযদি আর্গুমেন্টগুলির মধ্যে একটি হয় Trueবা দুটি শীর্ষে অবস্থিত দূরত্ব হয় তবেই তা ফিরে আসে 1।

Tr[1^x]পরিবর্তে ব্যবহার করা যাবে না Length@xএবং পরিবর্তে ব্যবহার করা <2যাবে না ==1।

HamiltonianPathগ্রাফটি যদি পুনঃনির্দেশিত হয় তবে ফাংশন বডিটি 84 বাইট নেয় (বর্তমান জমা দেওয়ার চেয়ে ঠিক 1 বাইট বেশি) ব্যবহার করতে পারে:

Length@HamiltonianPath[MakeGraph[#~Position~1,Norm[#-#2]==1&,Type->Undirected],All]&

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

— user202729
সূত্র
10

জাভাস্ক্রিপ্ট (ES6), 154 134 বাইট

m=>m.map((r,Y)=>r.map(g=(_,x,y,r=m[y=1/y?y:Y])=>r&&r[x]&&[-1,0,1,2].map(d=>r[r[x]=0,/1/.test(m)?g(_,x+d%2,y+~-d%2):++n,x]=1)),n=0)|n/4

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

কিভাবে?

পদ্ধতি

প্রতিটি সম্ভাব্য কক্ষ থেকে শুরু করে, আমরা ম্যাট্রিক্সকে বন্যায় পূর্ণ করি, আমাদের পথে সমস্ত কক্ষ সাফ করি। যখনই ম্যাট্রিক্সে আরও 1 টি থাকে না , আমরা সম্ভাব্য পাথের সংখ্যা n বৃদ্ধি করি ।

প্রতিটি বৈধ পাথ 4 বার গণনা করা হয় কারণ শেষ কক্ষে যে দিকটি বেছে নেওয়া হয়েছে, তাতে আসলে কিছু আসে যায় না। অতএব, চূড়ান্ত ফলাফল এন / 4 ।

পুনরাবৃত্তি ফাংশন

দ্বিতীয় মানচিত্রের কলব্যাক () এর থেকে পুনরাবৃত্ত ফাংশন জি () কল করার পরিবর্তে এইভাবে ...

m=>m.map((r,y)=>r.map((_,x)=>(g=(x,y,r=m[y])=>...g(x+dx,y+dy)...)(x,y)))

... আমরা recursive ফাংশন নির্ধারণ ) জি ( সরাসরি কলব্যাক যেমন এর মানচিত্র () :

m=>m.map((r,Y)=>r.map(g=(_,x,y,r=m[y=1/y?y:Y])=>...g(_,x+dx,y+dy)...))

Yy=1/y?y:Y এর প্রাথমিক মান নির্ধারণের জন্য প্রয়োজনীয় দীর্ঘ সূত্র সত্ত্বেও এটি সামগ্রিকভাবে 2 বাইট সংরক্ষণ করে।

মন্তব্য করা কোড

m =>                           // given the input matrix m[][]
  m.map((r, Y) =>              // for each row r[] at position Y in m[][]:
    r.map(g = (                //   for each entry in r[], use g() taking:
      _,                       //     - the value of the cell (ignored)
      x,                       //     - the x coord. of this cell
      y,                       //     - either the y coord. or an array (1st iteration),
                               //       in which case we'll set y to Y instead
      r = m[y = 1 / y ? y : Y] //     - r = the row we're currently located in
    ) =>                       //       (and update y if necessary)
      r && r[x] &&             //     do nothing if this cell doesn't exist or is 0
      [-1, 0, 1, 2].map(d =>   //     otherwise, for each direction d,
        r[                     //     with -1 = West, 0 = North, 1 = East, 2 = South:
          r[x] = 0,            //       clear the current cell
          /1/.test(m) ?        //       if the matrix still contains at least one '1':
            g(                 //         do a recursive call to g() with:
              _,               //           a dummy first parameter (ignored)
              x + d % 2,       //           the new value of x
              y + ~-d % 2      //           the new value of y
            )                  //         end of recursive call
          :                    //       else (we've found a valid path):
            ++n,               //         increment n
          x                    //       \_ either way,
        ] = 1                  //       /  do r[x] = 1 to restore the current cell to 1
      )                        //     end of map() over directions
    ),                         //   end of map() over the cells of the current row
    n = 0                      //   start with n = 0
  ) | n / 4                    // end of map() over the rows; return n / 4
— Arnauld
সূত্র
10

জেলি , 12 11 বাইট

ŒṪŒ!ạƝ€§ÐṂL

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

ব্যাখ্যা।

ŒṪ               Positions of snake blocks.
  Œ!             All permutations.
                 For each permutation:
    ạƝ€             Calculate the absolute difference for each neighbor pair
       §            Vectorized sum.
                 Now we have a list of Manhattan distance between snake
                    blocks. Each one is at least 1.
        ÐṂL      Count the number of minimum values.
                    Because it's guaranteed that there exists a valid snake,
                    the minimum value is [1,1,1,...,1].
— user202729
সূত্র
নতুন বৈশিষ্ট্যগুলি অত্যন্ত দরকারী বলে প্রমাণিত।
— ব্যবহারকারী 202729
বাইট সংরক্ষণ করার §ỊMLপরিবর্তে কীভাবে §ỊP€S- আমি মনে করি এটি কাজ করা উচিত?
— জোনাথন অ্যালান
... বা §ÐṂLযা কিছুটা দ্রুত।
— জোনাথন অ্যালান 21
@ জোনাথান অ্যালান কেবল তখনই কাজ করে যখন ফলাফলটি অজেজারো হয়।
— ব্যবহারকারী 202729
@ জোনাথান অ্যালান তাই এটি শেষ হয়ে যায় আসলে কাজ করে।
— ব্যবহারকারী 202729
8

পাইথন 2 , 257 246 241 234 233 227 214 210 বাইট

lambda b:sum(g(b,i,j)for j,l in e(b)for i,_ in e(l))
e=enumerate
def g(b,x,y):d=len(b[0])>x>-1<y<len(b);c=eval(`b`);c[d*y][d*x]=0;return d and b[y][x]and('1'not in`c`or sum(g(c,x+a,y)+g(c,x,y+a)for a in(1,-1)))

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

সংরক্ষিত

  • -8 বাইট, কেভিন ক্রুইজসেনকে ধন্যবাদ
  • -14 বাইট, ব্যবহারকারীর জন্য ধন্যবাদ 202729
— TFeld
সূত্র
1
— কেভিন ক্রুইজসেন
1
কাজের জন্য সঠিক ভাষা?
— নিল
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.