आगजनी करने वाले की लोरी पाएं

26

शहर के चारों ओर घूमने वाले और एक बहुत ही विशिष्ट पैटर्न के अनुसार अपने शिकार चुनने की कल्पना करें (या, वैकल्पिक रूप से, बगीचे के चारों ओर एक मधुमक्खी की कल्पना करें और बहुत विशिष्ट पैटर्न के अनुसार परागण करने के लिए उसके फूलों को उठाएं )। मान लीजिए कि शहर एक एन × एन मैट्रिक्स है, जहां एन एक पूर्णांक 2 या उससे अधिक है । आगजनी ऊपरी बाएं कोने से शुरू होती है और क्रमिक रूप से घर एम स्पॉट को उनके सामने सेट करती है (जहां एम वर्तमान में वे घर की संख्या है), प्रत्येक आग के बाद दिशा बदल रही है, क्रम में पूर्व ⟶ दक्षिण ⟶ पश्चिम ⟶ उत्तर ⟶ पूर्व and दक्षिण ... और इसी तरह। लोरीआगजनी करने वाले का मान M होता है जो उन्हें शहर से बाहर कर देता है (यानी अंतिम घर जो वे घृणा को रोकने से पहले जाते हैं)। यह एक उदाहरण के साथ समझने में आसान है। उदाहरण के लिए निम्नलिखित मैट्रिक्स लें:

3 2 3 2 7
3 1 4 1 6
२ ५ ३ १ १
4 4 3 2 4
१ १ १ १ १ १
  • हम ऊपरी-बाएँ कोने में शुरू करते हैं, इसलिए M = 3 ( Xआगजनी के वर्तमान और पिछले पदों को चिह्नित करता है): 
    एक्स 2 3 2 7
3 1 4 1 6
२ ५ ३ १ १
4 4 3 2 4
१ १ १ १ १ १
  • ज्ञात आदेश के अनुसार, यह पहली बार पूर्व एम (3) स्थानों और 2 पर भूमि जाता है इसलिए एम तदनुसार बदलता है: 
    एक्स 2 3 एक्स 7
3 1 4 1 6
२ ५ ३ १ १
4 4 3 2 4
१ १ १ १ १ १
  • फिर यह दक्षिण 2 स्थानों पर जाता है और एम अब 1 : 
    एक्स 2 3 एक्स 7
3 1 4 1 6
२ ५ ३ १ १
4 4 3 2 4
१ १ १ १ १ १
  • अब यह पश्चिम में 1 स्थान पर पहुँच गया और M 3 हो गया : 
    एक्स 2 3 एक्स 7
3 1 4 1 6
२ ५ XX १
4 4 3 2 4
१ १ १ १ १ १
  • उत्तर में 3 स्थानों की ओर बढ़ने के बाद , यह शहर से बाहर निकलता है! इसलिए, 3 इस आगजनी की लोरी है: 
        एक्स
एक्स 2 3 एक्स 7
3 1 4 1 6
२ ५ XX १
4 4 3 2 4
१ १ १ १ १ १

N × N मैट्रिक्स को देखते हुए (आप वैकल्पिक रूप से N को इनपुट के रूप में भी ले सकते हैं), आगजनी करने वाले की लोरी का पता लगाएं। मैंने एक कार्यक्रम लिखा है जिसके साथ आप अधिक परीक्षण मामलों को उत्पन्न कर सकते हैं और आगजनी के मार्ग की कल्पना कर सकते हैं: इसे ऑनलाइन आज़माएं!

  • आप मान सकते हैं कि arsonist करता लोरी है (यह है कि, यह वास्तव में मैट्रिक्स से बाहर निकल सकते)।
  • मैट्रिक्स में केवल सादगी के लिए 9 (अंक) से कम या बराबर सकारात्मक पूर्णांक होंगे । किसी भी सकारात्मक पूर्णांक को संभालने वाले समाधान पूरी तरह से स्वागत योग्य हैं।
  • ध्यान दें कि arsonist कर सकते हैं समझ में वे में आगे बढ़ रहे मामले में एक जगह वे पहले से ही जला दिया है पर लैंड, पहली बार से अलग है। ऐसे परिदृश्य में, बस उस तत्व का मान लें और हमेशा की तरह फिर से आगे बढ़ें।
  • आप किसी भी प्रोग्रामिंग भाषा में प्रतिस्पर्धा कर सकते हैं और इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। यह कोड-गोल्फ है , इसलिए हर भाषा के लिए सबसे कम सबमिशन (बाइट्स में) जीतता है।

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

-------------
९ २ ३
१ 1 २
8 ६

लोरी: ९
-------------
२ १ २ १ १
3 1 1 2
१ २ २ १
1 1 1 3

लोरी: २
-------------
3 2 3 2 7
3 1 4 1 6
२ ५ ३ १ १
4 4 3 2 4
१ १ १ १ १ १

लोरी: ३
-------------
१ २ १ २ २ १ २
१ २ १ २ २ १ २
१ २ १ २ २ १ २
१ २ १ २ २ १ २
१ २ १ २ २ १ २
१ २ १ २ २ १ २

लोरी: २
-------------
३ २ १ २ २ १ १ १
२ ३ २ ३ २ २ १ १
2 1 1 1 3 1 2
३ १ १ १ १ १ १ १ १
4 5 2 3 1 1 1
1 2 1 2 1 2 2
1 2 2 3 2 1 2

लोरी: ३
-------------

एक अलग प्रारूप में मेट्रिसेस:

[[९, २, ३], [१,,, २], [,,,, ६]]
[[२, १, २, १], [३, १, १, २], [१, २, २, १], [१, १, १, ३]]
[[3, 2, 3, 2, 7], [3, 1, 4, 1, 6], [2, 5, 3, 1, 1], [4, 4, 3, 2, 4], [ 1, 1, 1, 1, 1]]
[[१, २, १, २, १, २], [१, २, १, २, १, २], [१, २, १, २, १, २], [१, २, १, १] 2, 1, 2], [1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2]]
[[3, 2, 1, 2, 1, 1, 1], [2, 3, 2, 3, 2, 1, 1], [2, 1, 1, 1, 3, 1, 2], [ 3, 1, 1, 1, 1, 1, 1], [4, 5, 2, 3, 1, 1, 1], [1, 2, 1, 2, 1, 2, 2], [1, 2, 2, 3, 2, 1, 2]]

पांचवें परीक्षण के मामले में कल्पना करना बहुत दिलचस्प है ।

code-golf  array-manipulation  matrix 
— श्री एक्सकोडर
स्रोत
1
यह दो आयामों में एक खरगोश की तरह स्किप के सामान्यीकरण की तरह है , थोड़ा अलग लक्ष्य के साथ। इस चुनौती के विषयगत और इसके शीर्षक को
— होज़ियर के
क्या होता है जब आगजनी एक वर्ग पर पहले से ही जलाया जाता है?
— लेवल रिवर सेंट
2
क्या हम यह मान सकते हैं कि आगजनी वास्तव में आगजनी नहीं है और इसके बजाय इसे जलाने के बजाय प्रत्येक स्थान पर कुछ अच्छा कर रहा है? +1 एक बहुत अच्छे विचार के लिए :)
— ElPedro
2
@ElPedro ज़रूर, आपके लिए एक वैकल्पिक संस्करण: एक मधुमक्खी को बगीचे के चारों ओर उड़ने और बहुत विशिष्ट पैटर्न के अनुसार परागण करने के लिए उसके फूलों को चुनने की कल्पना करें। : डी हैप्पी फ्रेंडली गोल्फिंग!
— श्री Xcoder
1
यह एक बहुत अच्छा विचार है। अगर मैं फिर से आगे बढ़ सका तो मैं इसके लिए तैयार रहूंगा।
— एलपेड्रो

जवाबों:

11

MATL , 32 बाइट्स

JQ6*`G5thYay&Zj3$)wyJ2@-^*+8M]b&

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

इनपुट मैट्रिक्स को पांच शून्य के एक फ्रेम के साथ गद्देदार किया जाता है, इसलिए उदाहरण के लिए

3 2 3 2 7
3 1 4 1 6
2 5 3 1 1
4 4 3 2 4
1 1 1 1 1

हो जाता है

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 3 2 3 2 7 0 0 0 0 0
0 0 0 0 0 3 1 4 1 6 0 0 0 0 0
0 0 0 0 0 2 5 3 1 1 0 0 0 0 0
0 0 0 0 0 4 4 3 2 4 0 0 0 0 0
0 0 0 0 0 1 1 1 1 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

शून्य के फ्रेम का उपयोग यह पता लगाने के लिए किया जाता है कि आगजनी मधुमक्खी ने मैट्रिक्स को बाहर निकाला है या नहीं। पांच शून्य के साथ विस्तार सुनिश्चित करता है कि किसी भी नॉनज़रो प्रविष्टियों में से किसी भी दिशा में लंबाई का एक मॉड्यूलर विस्थापन 9कुछ शून्य-शून्य प्रविष्टि के आसपास लपेटे बिना शून्य में सही ढंग से उतरेगा।

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

निर्देशांक वास्तव में एक जटिल संख्या के रूप में संग्रहीत होते हैं, इसलिए उदाहरण के लिए (6,6)बन जाता है 6+6j। इस तरह चार चक्रीय दिशाओं को काल्पनिक इकाई की शक्तियों के रूप में महसूस किया जा सकता है। निर्देशांक को अद्यतन करने के लिए उपयोग किए जाने वाले जटिल विस्थापन को प्राप्त करने के लिए रीड एंट्री द्वारा संबंधित पावर ( j, या 1, ) को गुणा किया जाता है।-j-1

क्रमिक रूप से पढ़ा गया मान स्टैक पर रखा जाता है। जब लूप बाहर निकलता है, तो स्टैक में सभी गैर-शून्य रीड वैल्यू होते हैं, फिर अंतिम रीड वैल्यू, जो 0कि लेटेस्ट कॉर्डिनेट करता है। तो तीसरा-शीर्ष तत्व आवश्यक आउटपुट है।

— लुइस मेंडो
स्रोत
1
एक बहुत ही नवीन दृष्टिकोण के लिए +1।
— लास्टस्टार Last
7

जावास्क्रिप्ट (ईएस 6), 70 68 बाइट्स

m=>(g=d=>(n=(m[y]||0)[x])?g(--d&3,x-=d%2*(y+=--d%2*n,L=n)):L)(x=y=0)

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

टिप्पणी की गई

m => (                        // given m = input matrix
  g = d =>                    // g = recursive function taking the direction d
    (n = (m[y] || 0)[x]) ?    // let n be the content of the current cell; if it's defined:
      g(                      //   do a recursive call:
        --d & 3,              //     with the next direction (0 = E, 3 = S, 2 = W, 1 = N)
        x -=                  //     update x by subtracting ...
          d % 2 * (           //       ... ((d - 1) % 2) * n
            y += --d % 2 * n, //       and update y by adding ((d - 2) % 2) * n
            L = n             //       save n into L
          )                   //     end of x update
      )                       //   end of recursive call
    :                         // else:
      L                       //   stop recursion and return L
)(x = y = 0)                  // initial call to g() with x = y = d = 0

यह देखते हुए कि जेएस में modulo का संकेत लाभांश का है, दिशा इस तरह से अद्यतन की जाती है:

 d | d' = --d&3 | dx = -(d%2)  | dy = --d%2 | direction
---+------------+--------------+------------+------------------
 0 |     3      | -(-1%2) = +1 | -2%2 =  0  | (+1,  0) = East
 3 |     2      | -( 2%2) =  0 |  1%2 = +1  | ( 0, +1) = South
 2 |     1      | -( 1%2) = -1 |  0%2 =  0  | (-1,  0) = West
 1 |     0      | -( 0%2) =  0 | -1%2 = -1  | ( 0, -1) = North
— Arnauld
स्रोत
4

चारकोल , 25 18 बाइट्स

ＰＳ↶ＷＫＫ«≔ιθ×Ｉι¶↷»⎚θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＰＳ

इनपुट स्ट्रिंग प्रिंट करें, लेकिन प्रिंट स्थिति को स्थानांतरित न करें।

↶

बायीं धुरी को घुमाएं, ताकि प्रिंट दिशा अब ऊपर हो।

ＷＫＫ«

प्रिंट की स्थिति के तहत एक चरित्र होने पर दोहराएं।

≔ιθ

एक चर में चरित्र को बचाओ।

×Ｉι¶

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

↷»

धुरी को घुमाएं ताकि अगले न्यूलाइन्स लूप के अगले पास के लिए अगली दिशा में घड़ी की स्थिति में प्रिंट स्थिति को स्थानांतरित करें।

Ｆ⟦ωθ⟧¿ιι⎚

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

⎚θ

कैनवास को साफ़ करें और सहेजे गए चर को प्रिंट करें। (चारकोल को ठीक करने के लिए @ ASCII-only को धन्यवाद।)

— नील
स्रोत
2

चारकोल , 50 49 46 34 33 26 बाइट्स

ＮθＥθＳＭθ↑ＷＫＫ«ＭＩι✳⊗Ｌυ⊞υι»⎚⊟υ

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

लिंक कोड के वर्बोज़ संस्करण के लिए है

इनपुट को अपनी लाइन पर एन होना चाहिए , फिर उसके बाद अलग लाइनों पर सरणी की रेखाएं।

बाइट्स को नॉक करने के किसी भी तरीके का स्वागत और चाहत है, क्योंकि मैं चारकोल में अच्छा गोल्फर नहीं हूं!

-12 बाइट्स @ @ नील को धन्यवाद! -1 बाइट @ ASCII-only को धन्यवाद! -7 बाइट्स के लिए @ ASCII-only (एक बग जिसे Clearरीसेट वैरिएबल में बदला गया ) के लिए धन्यवाद

— जाकारी
स्रोत
1

लाल , 145 बाइट्स

func[b][h:[0 1 0 -1 0]x: y: 1 i: 0
until[y: h/(i: i % 4 + 1) *(t: b/(y)/(x)) + y x: h/(i + 1) * t + x none = b/(y) or(x < 1 or(x > length? b))]t]

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

अधिक पठनीय:

f: func[b][
    h: [0 1 0 -1 0]                                ; step lengths (combined for x and y) 
    x: y: 1                                        ; starting coords (1,1)
    i: 0                                           ; step counter 
    until[
        y: h/(i: i % 4 + 1) * (t: b/(y)/(x)) + y   ; next y; t stores the lullaby
        x: h/(i + 1) * t + x                       ; next x
        none = b/(y) or (x < 1 or (x > length? b)) ; until x or y are not valid indices
    ]
    t                                              ; return the lullaby
]
— गैलेन इवानोव
स्रोत
1

साफ , 141 बाइट्स

import StdEnv
d=[0,1,1,0,0,-1,-1,0:d]
$m[x,y]n[a,b:l]#r=size m
#u=x+a*n
#v=y+b*n
|0>u||0>v||u>=r||v>=r=n= $m[u,v]m.[u,v]l
?m= $m[0,0]m.[0,0]d

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

फ़ंक्शन को परिभाषित करता है ? :: {#{#Int}} -> Int, पूर्णांकों के अनबॉक्स किए गए सरणियों का एक अनबॉक्स ऐरे को लेते हुए और परिणाम को वापस करता है।

— Οurous
स्रोत
1

जावा 8, 121 बाइट्स

m->{int l=m.length,x=0,y=0,f=0,r=0;for(;x*y>=0&x<l&y<l;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];return r;}

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

एक ही 121 बाइट्स -बाइट के साथ वैकल्पिक :

m->{int l=m.length,x=0,y=0,f=0,r=0;try{for(;;x+=f<1?r:f==2?-r:0,y+=f==1?r:f>2?-r:0,f=++f%4)r=m[y][x];}finally{return r;}}

अगर x,y-कोर्डिनेट अभी भी सीमा के भीतर है , तो जाँच के बजाय कोशिश-अंत का उपयोग करता है ।

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

स्पष्टीकरण:

m->{                   // Method with integer-matrix parameter and integer return-type
  int l=m.length,      //  Dimensions of the matrix
      x=0,y=0,         //  x,y coordinate, starting at [0,0]
      f=0,             //  Direction-flag, starting at 0 (east)
      r=0;             //  Result-integer
  for(;x*y>=0&x<l&y<l  //  Loop as long as the x,y coordinates are still within bounds
      ;                //    After every iteration:
       x+=f<1?         //     If the direction is east:
           r           //      Increase the `x` coordinate by `r`
          :f==2?       //     Else-if the direction is west:
           -r          //      Decrease the `x` coordinate by `r`
          :            //     Else (it's north/south):
           0,          //      Leave the `x` coordinate the same
       y+=f==1?        //     If the direction is south:
           r           //      Increase the `y` coordinate by `r`
          :f>2?        //     Else-if the direction is north:
           -r          //      Decrease the `y` coordinate by `r`
          :            //     Else:
           0,          //      Leave the `y` coordinate the same
       f=++f%4)        //     Go to the next direction (0→1→2→3→0)
    r=m[y][x];         //   Set `r` to the value of the current cell
  return r;}           //  Return the last `r` before we went out of bounds
— केविन क्रूज़सेन
स्रोत
0

पर्ल 5 , 92 बाइट्स

sub b{1while eval join'&&',map{/./;map"(\$$_$&=".'$n=$_[$y][$x])'.$',x,'y'}'+<@_','->=0';$n}

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

कैसे?

नेस्टेड मैप्स और ज्वाइन का सेट इसका उत्पादन करता है:

($x+=$n=$_[$y][$x])<@_&&($y+=$n=$_[$y][$x])<@_&&($x-=$n=$_[$y][$x])>=0&&($y-=$n=$_[$y][$x])>=0

जिसके बाद यह निर्धारित करने के लिए मूल्यांकन किया जाता है कि क्या लूप समाप्त होता है। क्योंकि बूलियन का मूल्यांकन दाएं से बाएं किया जाता है, $nमूल्यांकन के दौरान वास्तव में चार बार (ऊपर) के मूल्य बदल जाते हैं। क्योंकि पर्ल में बूलियन लॉजिक शॉर्ट-सर्किट, $nलूप से बाहर निकलने पर लोरी की वैल्यू है।

— Xcali
स्रोत
0

पायथन 3 , 85 84 बाइट्स

xcoder: -1 (मुझे + ~ चाल कभी याद नहीं है)

def f(x):
 r=c=0
 while-1<r:d=x[r][c];r,c=len(x)-c+~d,r;x=[*zip(*x)][::-1]
 return d

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

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

— RootTwo
स्रोत
84 बाइट्स : -d-1=>+~d
— श्री एक्सकोडर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.