सैन फ्रांसिस्को में टेक्सीकैब

Question

आप सैन फ्रांसिस्को में एक टैक्सी ड्राइवर हैं। जैसा कि टेक्सीकैब ड्राइवरों की खासियत है, आप एक ग्रिड को नेविगेट कर रहे हैं, जहां एकमात्र वैध दिशाएं जो आप ले जा सकती हैं, वे बाएं, दाएं, ऊपर और नीचे हैं। हालांकि, सैन फ्रैंसिस्को बहुत पहाड़ी है, इसलिए दो आसन्न चौराहों के बीच की दूरी आवश्यक रूप से समान नहीं है। अधिक विशेष रूप से, ऊंचाई पर एक चौराहे और ऊंचाई पर aआसन्न चौराहे के बीच की दूरी bहोगी 1 + |a - b|। आपका लक्ष्य मानचित्र के शीर्ष बाईं ओर अपने मूल से सभी छोटे से छोटे रास्तों को नीचे दाईं ओर अपने गंतव्य तक खोजना है।

इनपुट

जो भी प्रारूप में पूर्णांक ऊंचाई का एक दो आयामी ग्रिड सबसे सुविधाजनक है (दो आयामी सरणी, चौड़ाई और / या ऊंचाई, आदि के साथ एक आयामी सरणी)।

उत्पादन

ऊंचाई के दो समीपस्थ चौराहों के बीच की दूरी को देखते हुए कम से कम दूरी में ऊपर से इनपुट के निचले दाएं कोने पर आने के लिए यात्रा करने का निर्देश का एक क्रम aऔर bसूत्र द्वारा दिया गया है 1 + |a - b|। यदि कई समाधान आउटपुट सभी समाधान हैं।

हालांकि मैं का उपयोग U, D, L, और Rऊपर के लिए, नीचे, सही अपने कार्यक्रम इतने लंबे समय में यह और सभी आदानों पर उनके साथ संगत है के रूप में दिशाओं का प्रतिनिधित्व करने के लिए किसी भी चार अलग तार का उपयोग कर सकते नीचे के उदाहरणों में छोड़ दिया, और।

उदाहरण

Input:
0 3 0 0 0
0 2 0 2 0
0 0 0 3 0
Output:
D D R R U U R R D D

Input:
3
Output:
<empty>

Input:
11 11 11
11 11 11
11 11 11
Output:
R R D D
R D R D
R D D R
D R R D
D R D R
D D R R

Input:
7 8 1 -1 0
4 4 6 -1 7
3 4 4  2 8
2 5 2 -1 2
Output:
D R D R R D R
D R D R D R R

यह कोड-गोल्फ है इसलिए सबसे छोटी बाइट काउंट जीत के साथ उत्तर।

Comments

क्या ऊंचाई हमेशा 10 से कम होती है? (वे उदाहरणों पर हैं, लेकिन क्या वे हमेशा रहेंगे?)

— दादा

@ दादा का दृष्टिकोण आवश्यक रूप से 10 से कम नहीं है (वे नकारात्मक भी हो सकते हैं), मैंने तदनुसार उदाहरणों को अपडेट किया है।

— ० '

जब मैंने देखा कि यह पोस्ट सक्रिय है तो मैं suuuuuuper उत्साहित था - मैंने सोचा कि किसी ने टैक्सी में जवाब दिया था! शायद एक दिन

— अंतरिक्ष जंक

Answer 1

जावास्क्रिप्ट (ईएस 6), 228 212 200 194 बाइट्स

a=>w=>(B=1/0,(F=(r,p,s,b=a[p])=>p-a.length+1?1/b&&([...a[p]='RDUL'].map((c,d)=>d|p%w<w-1&&d-3|p%w&&F(r+c,P=p+[1,w,-w,-1][d],s+1+Math.abs(b-a[P]))),a[p]=b):R=s>B?R:s<B?(B=s,r):R+' '+r)('',0,0),R)

इनपुट

एक आयामी सरणी aऔर wकरी सिंटैक्स में चौड़ाई(a)(w)

उत्पादन

समाधानों की एक अलग-अलग सूची "DRDRRDR DRDRDRR"

प्रारूपित और टिप्पणी की गई

a => w => (                            // given an array 'a' and a width 'w'
  B = 1 / 0,                           // B = best score so far, initialized as +Infinity
  (                                    //
    F = (                              // F = recursive function with:
      r,                               //   - r = current path (string)
      p,                               //   - p = current position in grid
      s,                               //   - s = current score
      b = a[p]                         //   - b = backup of current cell
    ) =>                               //
    p - a.length + 1 ?                 // if we haven't reached our destination:
      1 / b && (                       //   if the current cell is valid:
        [...a[p] = 'RDUL']             //     invalidate the current cell
        .map((c, d) =>                 //     for each possible direction:
          d | p % w < w - 1 &&         //       check right boundary
          d - 3 | p % w &&             //       check left boundary
          F(                           //       do a recursive call with:
            r + c,                     //         - new direction appended to the path
            P = p + [1, w, -w, -1][d], //         - updated position
            s + 1 + Math.abs(b - a[P]) //         - updated score
          )                            //
        ),                             //
        a[p] = b                       //     restore current cell value
      )                                //
    :                                  // else:
      R = s > B ?                      //   if the current score is worse than B:
        R                              //     keep the previous solution
      : s < B ?                        //   if the current score is better than B:
        (B = s, r)                     //     update best score / store path as new solution
      : R + ' ' + r                    //   if it's just as good: append path to solution
  )('', 0, 0),                         // initial call to F with r = '', p = 0, s = 0
  R                                    // return solution
)                                      //

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

let f =

a=>w=>(B=1/0,(F=(r,p,s,b=a[p])=>p-a.length+1?1/b&&([...a[p]='RDUL'].map((c,d)=>d|p%w<w-1&&d-3|p%w&&F(r+c,P=p+[1,w,-w,-1][d],s+1+Math.abs(b-a[P]))),a[p]=b):R=s>B?R:s<B?(B=s,r):R+' '+r)('',0,0),R)

console.log(f([
  0, 3, 0, 0, 0,
  0, 2, 0, 2, 0,
  0, 0, 0, 3, 0
])(5));

console.log(f([
  3
])(1));

console.log(f([
  11, 11, 11,
  11, 11, 11,
  11, 11, 11
])(3));

console.log(f([
  7, 8, 1, -1, 0,
  4, 4, 6, -1, 7,
  3, 4, 4,  2, 8,
  2, 5, 2, -1, 2
])(5));