सेल फोन चार्ज

Question

^{मेरे विश्वविद्यालय कोड चैलेंज प्रतियोगिता से अनुमति के साथ चुनौती ली गई}

---

हमारे पास मोबाइल फोन पर निर्भरता हर रात बैटरी के अधिकतम स्तर तक हमें चार्ज करती है, इसलिए हम अगले दिन के मध्य तक बिजली से चलने का जोखिम नहीं उठाते हैं। यहां तक ​​कि ऐसे लोग भी हैं, जब वे दिन के दौरान एक मुफ्त आउटलेट देखते हैं, जो कुछ भी हो सकता है, उसे चार्ज करने के लिए रख दें।

मैं उनमें से एक हूं।

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

जो मैंने अभी तक मास्टर करने में कामयाब नहीं किया है, वही गणना जब मैं स्थापित दिनचर्या को छोड़ता हूं और चीजों को करने के लिए मेरे पास कई विकल्प हैं। यह, उदाहरण के लिए, उन दिनों पर होता है जब मैं दूसरे शहर के लिए मार्ग पर होता हूं, जहां मैं विभिन्न तरीकों से पहुंच सकता हूं।

समस्या के लिए मेरे पहले दृष्टिकोण में, मैं मान रहा हूं कि मैं एक "शतरंज की बिसात" के चारों ओर बढ़ना चाहता हूं, ऊपरी-बाएं कोने से निचले-दाएं कोने तक। प्रत्येक "सेल" में मैं या तो मोबाइल को एक विशिष्ट राशि चार्ज कर सकता हूं, या मैं नहीं कर सकता और इसका लोड स्तर नीचे चला जाता है।

चुनौती

पूर्णांक के एक एफएक्ससी मैट्रिक्स को देखते हुए, न्यूनतम बैटरी स्तर की मात्रा का उत्पादन जो मुझे 2-इकाइयों से नीचे गिरने वाले लोड स्तर के बिना ऊपरी-बाएं कोने से नीचे-दाएं तक जाने की आवश्यकता होती है।

मैट्रिक्स में, एक सकारात्मक संख्या इंगित करती है कि मैं अपने पथ का अनुसरण करने से पहले अपने मोबाइल फोन को कितना चार्ज कर सकता हूं, जबकि एक नकारात्मक संख्या इंगित करती है कि कोई आउटलेट नहीं हैं और मोबाइल की बैटरी उस राशि द्वारा अपना चार्ज स्तर गिरा देती है। यह गारंटी दी जाती है कि स्रोत और गंतव्य कोशिकाओं (ऊपर-बाएं और नीचे-दाएं कोने) में मात्रा हमेशा 0 होती है और शेष मान (पूर्ण मान) 100 से अधिक नहीं होते हैं।

उदाहरण
दिया गया:

$$\begin{bmatrix} 📱&-1&1&-1 \\ -1&-1&-1&-1 \\ -1&1&-1&-1 \\ 1&1&-1&0 \end{bmatrix}$$

जिस पथ पर मुझे कम बैटरी चाहिए वह है:

$$\begin{bmatrix} 📱&-1&1&-1 \\ \color{blue}{-1}&-1&-1&-1 \\ \color{blue}{-1}&1&-1&-1 \\ \color{blue}{1}&\color{blue}{1}&\color{blue}{-1}&0 \end{bmatrix}$$

और न्यूनतम बैटरी स्तर की राशि जिसकी मुझे आवश्यकता है 4 है

टिप्पणियाँ

• स्टार्ट हमेशा शीर्ष-बाएं कोने में होने वाला है
• द एंड हमेशा बॉटम-राइट कॉर्नर होने वाला है
• आप उस सेल पर नहीं जा सकते हैं जिसे आप पहले ही पास कर चुके हैं। उदाहरण: एक बार स्थिति (0,1) में, आप प्रारंभिक बिंदु (0,0) पर नहीं जा सकते
• आपकी बैटरी का स्तर (किसी भी कारण से) 2 से कम नहीं हो सकता
• आप मान सकते हैं कि हमेशा एक शुरुआत और एक अंत होगा
• यदि आपको आवश्यकता हो तो आप 1-आयामी सरणियों को बहुआयामी के रूप में ले सकते हैं [1,2,3] == [[1,2,3]]
• कई सही (न्यूनतम आवश्यक शुल्क) पथ हो सकते हैं
• आपका लक्ष्य केवल न्यूनतम प्रारंभिक बैटरी स्तर की आवश्यकता है, न कि मार्ग का उत्पादन करना
• आप केवल लंबवत और क्षैतिज रूप से जा सकते हैं (तिरछे नहीं)

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

[0, 0] => 2
[0, 1, 0] => 2
[0, -1, 0] => 3
[0, 15, -20, 5, 0] => 7
[[0, -3],[-5, 0]] => 5
[[0, -5, -9, 5], [-3, 5, 2, -2], [2, -4, -4, 0]] => 5
[[0, -1, 1, -1], [-1, -1, -1, -1], [-1, 1, -1, -1], [1, 1, -1, 0]] => 4

Comments

मैं चुनौती का दिन भूल गया। सैंडबॉक्स पोस्ट

— लुइस फेलिप डी जीसस मुनोज

किसी को याद करने के लिए: चुनौती "द हंग्री मूस" ने इसे सैंडबॉक्स से बाहर कभी नहीं बनाया, इसलिए यह कोई धोखा नहीं है।

— काले उल्लू काई

@ ब्लेकऑवलाइकई मुझे लगता है कि दोनों चुनौतियां अलग

— लुइस फेलिप डी

क्या इष्टतम पथ को कभी बाएं या ऊपर जाने की आवश्यकता होगी? उदाहरण के लिए[[0,1,-1],[-9,-9,1],[-9,1,-1],[-9,-1,-9],[-9,1,0]]

— कामिल दकरी

@ डाना नहीं, 0sऊपर-बाएँ कोने पर केवल 2 ही रखे गए हैं और दूसरे नीचे-दाईं ओर

— लुइस फेलिप डी जीसस मुनोज़

Answer 1

जावास्क्रिप्ट (ईएस 7),  162 156  154 बाइट्स

m=>(M=g=(x,y,n,k)=>m.map((r,Y)=>[r[x+1]]+[m[y+1]]?r.map((v,X)=>r[1/v&&(x-X)**2+(y-Y)**2==1&&g(X,Y,u=v+n,k<u?k:u,r[X]=g),X]=v):M=M>k?M:k))(0,0,0)|M<0?2-M:2

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

टिप्पणी की गई

m => (                          // m[] = input matrix
  M =                           // initialize M to a non-numeric value
  g = (x, y, n, k) =>           // g = recursive depth-first search function
    m.map((r, Y) =>             // for each row r[] at position Y in m[]:
      [r[x + 1]] +              //   if either r[x + 1]
      [m[y + 1]] ?              //   or m[y + 1] is defined:
        r.map((v, X) =>         //     for each value v at position X in r[]:
          r[                    //
            1 / v &&            //       if v is numeric
            (x - X) ** 2 +      //       and the squared Euclidean distance
            (y - Y) ** 2 == 1   //       between (x, y) and (X, Y) is 1:
            &&                  //
              g(                //         do a recursive call:
                X, Y,           //           with (X, Y)
                u = v + n,      //           with n = n + v
                k < u ? k : u,  //           with k = min(k, n + v)
                r[X] = g        //           set r[X] to a non-numeric value
              ),                //         end of recursive call
            X                   //       then restore r[X]
          ] = v                 //       to its initial value
        )                       //     end of inner map()
      :                         //   else (we've reached the bottom right corner):
        M = M > k ? M : k       //     update M to max(M, k)
    )                           // end of outer map()
)(0, 0, 0) |                    // initial call to g with x = y = n = 0 and k undefined
M < 0 ? 2 - M : 2               // return 2 - M if M is negative, or 2 otherwise

Answer 2

पायथन 2 , 208 202 बाइट्स

lambda s:2-f(s)
def f(s,x=0,y=0):
 if x>-1<y<s[y:]>[]<s[y][x:]!="">s[y][x]:k=s[y][x];s[y][x]="";return k+min(0,max([len(s[y+1:]+s[y][x+1:])and f(eval(`s`),x+a/3-1,y+a%3-1)for a in 7,1,5,3]))
 return-9e9

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

---

पायथन 2 , 217 211 बाइट्स

i=input()
X,Y=len(i[0]),len(i)
s=[[0]*4+[i]];r=[]
for m,l,x,y,g in s:
 if X>x>-1<y<Y<"">g[y][x]:r+=[m]*(Y-y<2>X-x);l+=g[y][x];g[y][x]="";s+=[[min(m,l),l,x+a/3-1,y+a%3-1,eval(`g`)]for a in 7,1,5,3]
print 2-max(r)

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

Answer 3

आर , 224 220 217 213 210 बाइट्स

f=function(x,m=rbind(0,cbind(0,x,0),0),i=2,j=2,p=F,k=c(1:-1,0,0,-1:1),b=Inf,`^`=min){m[i,j]=0
for(h in 1:4)b=b^'if'(all(c(R<-i+k[h],C<-j+k[h+4])>dim(x)),max(2,2-cumsum(p)^0),if(v<-m[R,C])b^f(x,m,R,C,c(p,v)))
b}

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

Answer 4

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 242 बाइट्स

a=>{int m=1<<31,n=~m;void g(int w,int x,int y,int z){for(int i=4,t,c,d,e;i-->0;)try{t=a[c=i<1?w-1:i<2?w+1:w,d=i>2?x-1:i>1?x+1:x];n=t==0&z<n?z:n;a[c,d]=m;e=y+t<2?2-y-t:0;if(t!=m)g(c,d,y+t+e,z+e);a[c,d]=t;}catch{}}a[0,0]=m;g(0,0,2,2);return n;}

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

//a: input matrix
a=>{
  // m: marker for used cells
  // n: result, initialized to a huge value
  int m=1<<31,n=~m;
  // recursive function
  // w: 1st dim coordinate
  // x: 2nd dim coordinate
  // y: current charge level
  // z: initial charge for current path
  void g(int w,int x,int y,int z){
    // i: loop variable
    // t: temp holds overwritten value
    // c: adjacent 1st dim coordinate
    // d: adjacent 2nd dim coordinate
    // e: delta charge needed
    for(int i=4,t,c,d,e;i-->0;)
      // avoid index out of range errors
      // by using try/catch
      try{
        // determine neighbor
        // coordinates and save value
        t=a[c=i<1?w-1:i<2?w+1:w,
            d=i>2?x-1:i>1?x+1:x];
        // if we have found a 0, check if
        // initial charge is lower than the
        // lowest so far. save it if it is.
        n=t==0&z<n?z:n;
        // mark current cell used
        a[c,d]=m;
        // determine if we need to
        // increase the initial charge
        e=y+t<2?2-y-t:0;
        // make recursive call if current
        // cell was not previously in use
        if(t!=m)g(c,d,y+t+e,z+e);
        // restore current cell value
        a[c,d]=t;
      }catch{}
  }
  // mark starting cell used
  a[0,0]=m;
  // start the recursive function
  g(0,0,2,2);
  // return the result to the caller
  return n;
}