वह सांप कहां जा रहा है?

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
PPCG में आपका स्वागत है! अच्छी पहली चुनौती।
— लैकोनी
5
माइनर नोट: "हमेशा कम से कम एक पंक्ति और एक कॉलम होगा" बेमानी है, यह देखते हुए कि साँप में हमेशा कम से कम 2 ब्लॉक होंगे।
— स्टीवी ग्रिफिन
2
सुझाए गए परीक्षण मामले: @StewieGriffin द्वारा दिया गया और [[0,0,1,1],[0,0,1,1],[0,0,1,1]]। अधिकांश उत्तर 16 देते हैं, लेकिन एक 15.
— केविन क्रूज़सेन
2
ऐसा लगता है कि अब तक हर कोई (मेरे सहित) ने यह धारणा बना ली है कि 2 रास्ते अलग-अलग स्थिति में समाप्त होते हैं, लेकिन ठीक उसी तरह दिखने वाले समान मार्ग नहीं हैं । मुझे लगता है कि इसे स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता है।
— अरनौलद
2
@ अरनल्ड - यह सही है। अलग-अलग पदों पर समाप्त होने वाले दो रास्ते हैं, लेकिन ठीक उसी तरह दिखने वाले एक ही रास्ते नहीं हैं , यह कुल को जोड़ देगा। आपके उदाहरण में कुल 16 होना चाहिए अगर मुझसे गलती नहीं हुई है - मैं अब सटीक गणना नहीं कर सकता, लेकिन आप इस बिंदु को प्राप्त करते हैं
— Adelin

जवाबों:

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

जावास्क्रिप्ट (ईएस 6), 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 बार गिना जाता है, जो वास्तव में मायने नहीं रखता है। इसलिए, अंतिम परिणाम n / 4 है ।

पुनरावर्ती कार्य

दूसरे मानचित्र () के कॉलबैक से पुनरावर्ती फ़ंक्शन जी () को कॉल करने के बजाय इस तरह ...

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

... हम पुनरावर्ती फ़ंक्शन g () को सीधे मानचित्र के कॉलबैक के रूप में परिभाषित करते हैं () :

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

बल्कि लंबे फार्मूले के बावजूद y=1/y?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
स्रोत
नई सुविधाएँ बेहद उपयोगी साबित होती हैं।
— user202729
कैसे के §ỊMLबजाय §ỊP€Sएक बाइट को बचाने के लिए - मुझे लगता है कि यह काम करना चाहिए?
— जोनाथन एलन
... या §ÐṂLजो थोड़ा तेज है।
— जोनाथन एलन
@JonathanAllan केवल तभी काम करता है जब परिणाम नॉनजरो हो।
— user202729
@JonathanAllan तो यह वास्तव में काम करता है।
— user202729
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 बाइट्स, उपयोगकर्ता 202029 के लिए धन्यवाद
— TFeld
स्रोत
1
— केविन Cruijssen
1
नौकरी के लिए सही भाषा?
— नील
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.