ऑटोपायलट मोड

Question

शीर्ष बाएं कोने से शुरू होने वाला एक हेलीकॉप्टर जमीन की ओर (इस सवाल के लिए) एक 2D स्पेस में उतर रहा है। इसमें एक ऑटोपायलट मोड और एक मैनुअल मोड है।

ऑटोपायलट मोड निम्नानुसार व्यवहार करता है:

• यदि नीचे का स्थान खाली है, तो इसके नीचे उतरें।
• अन्यथा एक कदम बाएं या दाएं, पूरी तरह से यादृच्छिक पर ले जाएं। (यह इस तरीके से कई कदम बढ़ा सकता है।)

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

आपका काम यह निर्धारित करना है कि क्या

1. ऑटोपायलट दिए गए परिदृश्य में पारित होगा,
2. ऑटोपायलट दिए गए परिदृश्य में विफल हो सकता है,
3. ऑटोपायलट विफल हो जाएगा, लेकिन मैनुअल मोड पास होगा, या
4. दोनों मोड विफल हो जाएंगे (जमीन के लिए कोई वैध रास्ता नहीं है)।

इनपुट

• मुक्त और अवरुद्ध स्थानों का प्रतिनिधित्व करने के लिए दो अलग-अलग पात्रों का उपयोग करते हुए, 1d या 2d गैर-खाली सरणी के रूप में परिदृश्य को देखते हुए। विराम चिह्न वैकल्पिक।
• वैकल्पिक: सरणी के आयाम

उत्पादन

चार पूर्वनिर्धारित पात्रों में से एक यह दर्शाता है कि कौन से मामले घटित हुए हैं।

नमूना डेटा

इनपुट में 0 (खाली) और 1 (अवरुद्ध) का उपयोग करना, आउटपुट में 1 2 3 4 (जैसा कि ऊपर गिना गया है)

0 0 0 0
0 1 0 0
0 0 0 1
1 1 0 0

आउटपुट: 1

0 0 1 0
1 0 0 1
0 0 0 0
0 1 1 0
0 0 0 1

आउटपुट: 2(हेलीकॉप्टर चौथी पंक्ति में 1 का सामना करेगा, और यह संभव है कि यह पंक्ति 5 के अंत में खुद फंस जाएगा, अगर ऑटोपायलट मोड पर)

0 0 0 1 0
0 1 1 0 0
0 1 0 0 0
0 0 0 1 0
1 1 1 1 0

आउटपुट: 3(इसके लिए ऊपर की ओर बढ़ना आवश्यक है, इसलिए ऑटोपायलट विफल हो जाता है)

1 0 0
0 0 0

आउटपुट: 4

0 0 0 0 1
1 1 1 0 0
1 0 0 1 0
0 1 0 0 0
0 0 1 1 1

आउटपुट: 4

Comments

@ मार्टिनबटनर ने किया। साइड-नोट के रूप में, क्या आप सैंडबॉक्स में, या सीधे पोस्ट करने के लिए लोगों को पसंद करते हैं और उनकी त्रुटियों को ठीक किया है? दूसरा विकल्प सरल है, इसलिए जब तक कुछ प्रोत्साहन नहीं होता है, मैं कल्पना नहीं कर सकता कि मैं विकल्प एक का पालन क्यों करूंगा।

— भूत_न_थे_कोड

मैं व्यक्तिगत रूप से सैंडबॉक्स को पसंद करता हूं, क्योंकि यह लोगों को संभावित त्रुटियों, खामियों या लापता परीक्षण मामलों के बारे में सोचने का अधिक समय देता है, इससे पहले कि लोग चुनौती पर काम करना शुरू कर दें। यदि कोई त्रुटिपूर्ण चुनौती का प्रारंभिक उत्तर देता है, तो आप मौजूदा उत्तरों को अमान्य किए बिना वास्तव में चुनौती को ठीक नहीं कर सकते।

— मार्टिन एंडर

इसके अलावा - इनपुट हमेशा वर्ण होते हैं, या वे बूलियन / पूर्णांक / आदि हो सकते हैं? और आउटपुट - क्या यह पूर्णांक हो सकता है, या क्या चरित्र होना आवश्यक है?

— चार्ल्स

Answer 1

रूबी, 259

मैंने इसके साथ बहुत मस्ती की। धन्यवाद! दिलचस्प चुनौतियों के साथ ग्रिड चुनौतियां उत्कृष्ट हैं। यह मानता है कि प्रश्न में "वर्ण" पूर्णांक हो सकते हैं।

मुझे लगता है कि यहां सुधार के प्रमुख बिंदु हैं:

1. का निर्माण r
2. तीसरी लाइन पर भयंकर रूप से दुर्व्यवहार की संभावना को और अधिक-भयावह रूप से बनाया जा सकता है, लेकिन किसी चीज को छेड़ना।

->a,h,w{f=->l,s=0,y=[0]{r=w-2<s%w ?w:1,1>s%w ?w:-1,w
v=(l ?r+[-w]:a[s+w]==0?[w]:r).map{|d|a[m=s+d]==0&&!y[m]?m:p}-q=[p]
a[s]>0?q:s/w>h-2?8:v[0]?v.map{|o|f[l,y[o]=o,y]}.flatten-q :r.any?{|i|a[s+i]<1}?p: !0}
g=f[p]
[8,g[0]&&g.all?,g.any?,f[8].any?,!p].index !p}

Ungolfed (थोड़ा पुराना है, लेकिन असली करीब है):

# a is a one-dimensional array of 0s and 1s, h is height, w is width
->a,h,w{
  # f recursively walks the array and returns true/false/nil for each path.
  #    True means we can reach ground.
  #    False means we are stuck in a local minimum and cannot escape
  #    Nil means we reached a local dead-end and need to backtrack.
  # l: {true=>"manual", false=>"autopilot"}
  # s: the position index
  # y: an array of booleans - true-ish means we've visited that square before
  #         (this is to prevent infinite loops, esp in manual mode)
  f=->l,s=0,y=[0]{
    # d: all the legal deltas from s (maximally, that's [1,-1,w,-w], aka [LRDU])
    # r: but the right and left get tricky on the edges, so let's pre-calculate those
    #    we'll default to "down" if "left" or "right" are illegal
    r=[w-2<s%w ?w:1,1>s%w ?w:-1]
    # if manual, [LRDU]; if auto, and you can go down, [D]. else, [LR] 
    d=l ?r+[w,-w]:a[s+w]==0?[w]:r
    # v: the legal deltas that you can go to from s (that is, unvisited and unblocked)
    v=d.map{|d|a[m=s+d]==0&&!y[m]?m:p}-[p]


    a[s]>0 ? [p]     # if we're currently blocked, return [nil] (this is only the case when a[0]==1)
      : s/w>h-2 ? !p # if we're at the bottom, return true
        : v[0] ?     # if we have a place to go....
        v.map{|o|f[l,y[o]=o,y]}.flatten-[p] # recurse with each step.
                                            # y[o]=o is a neat trick to make y[o] truthy and return o
          : r.any?{|i|a[s+i]==0} ? # otherwise, we have nowhere to go. If we could visit left/right, but have already been there
            p                      #    this is not a dead-end - return nil to remove this path
            : !!p                  # If we have a true dead-end (auto-mode with a local minimum), false
  }
  # g is the auto flight
  g=f[p]
  # finally, choose the first "true" out of:
  # 0: always 8.  Cuz why not 8?
  # 1: there is at least one auto path, and all are truthy
  # 2: any auto path is truthy
  # 3: any manual path is truthy
  # 4: true
  [8,g[0]&&g.all?,g.any?,f[!p].any?,!p].index !p
}