अग्नि से उसे मार डालो

Question

डिस्क्लेमर: इस सवाल के भीतर बताई गई कहानी पूरी तरह से काल्पनिक है, और इंट्रो प्रदान करने के उद्देश्य से पूरी तरह से आविष्कार की गई है।

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

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखें जो एक फ़ील्ड के रूप में लेता है, और जब तक पूरा फ़ील्ड राख नहीं हो जाता तब तक इसे जलने के चरणों को लौटाता है। जिस क्षेत्र में आग लगी है उसका एक विशिष्ट खंड एक पूर्णांक द्वारा लौ की तीव्रता का प्रतिनिधित्व करता है। एक आग "1" से शुरू होती है और "2" और फिर "3" और इसी तरह आगे बढ़ती है। एक बार "4" पर पहुंचने के बाद, यह किसी भी सीधे (तिरछे नहीं) आसन्न क्षेत्रों को पकड़ता है जो आग पर ज्वलनशील होते हैं। एक बार जब यह "8" तक पहुंच जाता है, तो यह अगले पुनरावृत्ति पर जलता है, और राख में बदल जाता है, जिसे "ए" द्वारा दर्शाया जाता है। जब किसी क्षेत्र को अभी तक आग से नहीं छुआ गया है, तो इसे "0" द्वारा दर्शाया गया है। उदाहरण के लिए, यदि फ़ील्ड इस तरह दिखता है:

100
000

आपके कार्यक्रम को इसका उत्पादन करना चाहिए:

100
000

200
000

300
000

410
100

520
200

630
300

741
410

852
520

A63
630

A74
741

A85
852

AA6
A63

AA7
A74

AA8
A85

AAA
AA6

AAA
AA7

AAA
AA8

AAA
AAA

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

इनपुट:

फ़ील्ड की प्रारंभिक स्थिति, किसी भी मानक रूप में, जैसे कि ऊपर की ओर एक नया-सीमांकित स्ट्रिंग।

आउटपुट:

प्रत्येक पुनरावृत्ति में क्षेत्र, जैसे कि यह जलता है, या तो एक सरणी के रूप में, या कुछ वर्ण द्वारा सीमांकित स्ट्रिंग के रूप में।

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

0301
000A
555
 |
 v
0301
000A
555

1412
010A
666

2523
020A
777

3634
030A
888

4745
141A
AAA

5856
252A
AAA

6A67
363A
AAA

7A78
474A
AAA

8A8A
585A
AAA

AAAA
6A6A
AAA

AAAA
7A7A
AAA

AAAA
8A8A
AAA

AAAA
AAAA
AAA

स्कोरिंग:

यह कोड-गोल्फ है , बाइट्स जीत में सबसे कम स्कोर!

Comments

आकृति कितनी भिन्न हो सकती है? क्या गैर-आयताकार भागों में हमेशा दाहिने किनारे पर "छेद" होते हैं, या क्षेत्र में रिक्त स्थान हो सकते हैं?

— पुरकाकूदरी

इतना कुछ जो 4 हिट करता है, आसन्न वर्गों में आग शुरू करता है, लेकिन कुछ जो 4 या उच्चतर पर शुरू होता है? यह बहुत यथार्थवादी नहीं है।

— लास्ज़्लोक

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

— J_F_B_M

क्या प्रारंभिक राख के लिए खेत को दो में अलग करना संभव है, ताकि इसका हिस्सा कभी न जले?

— aschepler

यदि आग 4 से ऊपर नहीं फैल रही है, तो यह बहुत परेशान करने वाली है, कल्पना कीजिए कि 1-4 आग लगने की तीव्रता है और 5-A इसे बाहर जलाने का प्रतिनिधित्व करती है।

— जेरेमी वीरिच

Answer 1

APL (Dyalog) , 52 बाइट्स *

मान लिया गया ⎕IO←0है जो कई सिस्टम पर डिफ़ॉल्ट है। खाली स्लॉट्स के लिए 0, नॉन-बर्निंग फील्ड के लिए 1, नई आग के लिए 2, आग फैलने के लिए 5 और राख के लिए 10 का उपयोग करता है। इनपुट कम से कम 3 × 3 होना चाहिए, जो अतिरिक्त पंक्तियों के रूप में एक समस्या नहीं है और कॉलम शून्य (ओपी के प्रारूप में रिक्त स्थान) के साथ गद्देदार हो सकते हैं।

{}{1=c←4⊃r←,⍵:1+4∊r/⍨9⍴⍳2⋄10⌊c+×c}⌺3 3⍣{⍺≡⎕←⍵}

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

मेरा प्रारूप शुद्धता के लिए जांचना कठिन बनाता है, इसलिए यहां एक संस्करण है, जिसमें पूर्व से और बाद के प्रसंस्करण से और ओपी के प्रारूप में अनुवाद करना है।

⍣{… } तक दोहराएं:

 ⍺ अगली पीढ़ी

 ≡ के समान है

 ⎕←⍵ वर्तमान पीढ़ी, आउटपुट

{... }⌺3 3 इस कार्य के परिणाम के साथ प्रत्येक सेल को उसके मूर पड़ोस पर लागू किया जाता है:

 ,⍵ तर्क (चपटा) तर्क; नौ-तत्व सूची देता है

 r←r  को असाइन करें

 4⊃ चौथा तत्व उठाओ; केंद्र, यानी मूल सेल वैल्यू

 c←c  को असाइन करें

 1= उस के बराबर है?

 : यदि ऐसा है, तो:

  ⍳2 पहले से to ntegers; 0 1

  9⍴ R की लंबाई नौ तक बढ़ जाती है; 0 1 0 1 0 0 1 0 0 0

  r/⍨r का  उपयोग करने के लिए इसका उपयोग करें (यह सिर्फ रूढ़िवादी पड़ोसियों को मिलता है)

  4∊ चार उस का एक सदस्य है? (यानी अगली पीढ़ी में एक पाँच होगा?)

  1+ एक जोड़ें; 1 अगर आग नहीं पकड़ी गई या 2 अगर आग पकड़ी गई

 ⋄ और (अर्थात वर्तमान मान 0 या ie 2 है)

  ×cसी  के हस्ताक्षर

  c+ c प्लस जो (यदि आग लगने पर एक से बढ़ कर)

  10⌊ कम से कम दस और वह (जैसा कि राख जलती नहीं है)

---

* Dyalog Classic में, के ⎕U233A बजाय का उपयोग कर ⌺।

Comments

छोटा है, लेकिन बोर्ड में परिवर्तन के साथ सौदा नहीं करता है। एक 3x3 पर अटक गया।

— सुमेरे

@Suamere क्या? बोर्ड आकार नहीं बदलता है, है ना?

— 13

क्षमा करें, मैं स्पष्ट नहीं था। आपका उत्तर भयानक है, लेकिन मैं समझ रहा हूं कि समाधान को एक चर आकार के बोर्ड के लिए अनुमति देना चाहिए जो "दाईं ओर" अंतराल हो सकता है या नहीं हो सकता है। बीच में अंतराल को संभालने की आवश्यकता नहीं है। "दाईं ओर" का मतलब है कि आकार -15 बोर्ड 4x4 के रूप में बनाया जाएगा, सिवाय इसके कि सबसे निचला तल गायब है। और एक आकार -8 बोर्ड एक 3x3 के रूप में बनाया जाएगा, सिवाय इसके कि सबसे नीचे का टुकड़ा गायब है, आदि यह है कि मैंने चुनौती की आवश्यकताओं को कैसे पढ़ा। वर्तमान में आपका उत्तर सबसे छोटा है, लेकिन केवल 3x3 के साथ काम करता है।

— सुमेरे

@Samamere OP स्पष्ट रूप से बताता है कि इनपुट 2D है। मैं एक संख्यात्मक मैट्रिक्स के रूप में इनपुट लेता हूं और शून्य के रूप में कहीं भी "खाली" स्लॉट की अनुमति देता हूं। जबकि मुझे न्यूनतम 3 × 3 इनपुट की आवश्यकता है ( ओपी ने इसकी अनुमति दी है ) मैं किसी भी बड़े आकार के इनपुट को स्वीकार करता हूं। वास्तव में, यदि आप यहां लिंक पर क्लिक करते हैं , तो आप देखेंगे कि मेरा दूसरा उदाहरण मामला नीचे के दाईं ओर के सेल के साथ 2 × 3 है।

— 14

पकड़ लिया। निश्चित रूप से क्यों नहीं, लेकिन यह यहाँ कोशिश करें लिंक में समस्याएँ हैं (संभवतः मेरी गलती है), हालाँकि आपका नया स्वरूपित लिंक अच्छी तरह से काम करता है। EG: fire '0A000\n0A0A0\n0A0A0\n000A1'स्वरूपित एक पर सही काम करता है, लेकिन मैं पहली कड़ी के साथ काम करने के लिए एक बराबर नहीं मिल सकता। मैं शायद कुछ गलत कर रहा हूं। यह मेरे लिए काम नहीं करता है:f ↑(0 0 0)(0 1 0)(0 0 0)

— Suamere

Answer 2

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

def f(j):
 k=[[int(min(9,j[x][y]+(j[x][y]>0)or 3in(lambda k,x,y:[k[i][j]for i,j in[[x-1,y],[x+1,y],[x,y-1],[x,y+1]]if(-1<i<len(k))and(-1<j<len(k[i]))])(j,x,y)))for y in range(len(j[x]))]for x in range(len(j))]
 if k!=j:print(k);f(k)

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

-3 बाइट्स को अन्य लैम्ब्डा में विलय करने के लिए आधिकारिकता के लिए धन्यवाद f(गन्दा लग रहा है लेकिन बाइट्स बचाता है और यही सब हम ध्यान रखते हैं)
-8 श्री Xoder करने के लिए धन्यवाद बाइट्स
-26 OVS करने के लिए धन्यवाद बाइट्स
-6 ppperry करने के लिए धन्यवाद बाइट्स

Comments

मैं रिक्त स्थान कैसे जोड़ूं, उदाहरण में ऐसा कैसे हो सकता है?

— 15:56 बजे tuskiomi

Answer 3

जावास्क्रिप्ट (ईएस 6), 217 210 207 204 193 192 190 बाइट्स

के 9रूप में उपयोग करने के @ झबरा के सुझाव के लिए धन्यवाद 2 बाइट्स बचा लिया A।

f=F=>[F,...(t=[],y=0,g=x=>(r=F[y])?(x||(t[y]=[]),r[x]+1)?(t[y][x]=r[x]<8?r[x]+(r[x]>0|[r[x-1],r[x+1],F[y-1]&&F[y-1][x],F[y+1]&&F[y+1][x]].includes(3)):9,g(x+1)):g(0,y++):t)(0)+""!=F?f(t):[]]

// test code
test=s=>{
  var test = document.querySelector("#in").value.split`\n`.map(e => Array.from(e).map(e => parseInt(e)));
  var out = f(test);
  document.querySelector("#out").innerHTML = out.map(e => e.map(e => e.join``).join`\n`).join`\n\n`;
};window.addEventListener("load",test);

<textarea id="in" oninput="test()">0301&#10;0009&#10;555</textarea><pre id="out"></pre>

के 9बजाय का उपयोग करता है A। पूर्णांक के 2 डी सरणी के रूप में इनपुट। ऐसे सरणियों की एक सरणी के रूप में आउटपुट।

Comments

के 9बजाय का उपयोग करके आप कुछ भी बचा सकता है A?

— झबरा

Answer 4

दुनिया का अनुकरण (इमोजी में) , 1407 बाइट्स?

क्या आप प्रोग्रामिंग भाषा के रूप में एक एक्सप्लोसिव स्पष्टीकरण का उपयोग करना पसंद नहीं करते हैं? इसका नकारात्मक पक्ष यह है कि आमतौर पर एक बहुत अच्छी तरह से परिभाषित कार्यक्रम नहीं है, इसलिए इस मामले में, मैं JSON का उपयोग कर इसे निर्यात कर रहा हूं। (यदि आपके पास कोई बेहतर विचार है, तो मुझे बताएं)

{"meta":{"description":"","draw":1,"fps":1,"play":true},"states":[{"id":0,"icon":"0","name":"","actions":[{"sign":">=","num":1,"stateID":"4","actions":[{"stateID":"1","type":"go_to_state"}],"type":"if_neighbor"}],"description":""},{"id":1,"icon":"1","name":"","description":"","actions":[{"stateID":"2","type":"go_to_state"}]},{"id":2,"icon":"2","name":"","description":"","actions":[{"stateID":"3","type":"go_to_state"}]},{"id":3,"icon":"3","name":"","description":"","actions":[{"stateID":"4","type":"go_to_state"}]},{"id":4,"icon":"4","name":"","description":"","actions":[{"stateID":"5","type":"go_to_state"}]},{"id":5,"icon":"5","name":"","description":"","actions":[{"stateID":"6","type":"go_to_state"}]},{"id":6,"icon":"6","name":"","description":"","actions":[{"stateID":"7","type":"go_to_state"}]},{"id":7,"icon":"7","name":"","description":"","actions":[{"stateID":"8","type":"go_to_state"}]},{"id":8,"icon":"8","name":"","description":"","actions":[{"stateID":"9","type":"go_to_state"}]},{"id":9,"icon":"A","name":"","description":"","actions":[]}],"world":{"update":"simultaneous","neighborhood":"neumann","proportions":[{"stateID":0,"parts":100},{"stateID":1,"parts":0},{"stateID":2,"parts":0},{"stateID":3,"parts":0},{"stateID":4,"parts":0},{"stateID":5,"parts":0},{"stateID":6,"parts":0},{"stateID":7,"parts":0},{"stateID":8,"parts":0},{"stateID":9,"parts":0}],"size":{"width":9,"height":9}}}

इसे यहाँ या यहाँ आज़माएँ :

<iframe width="100%" height="450" src="http://ncase.me/simulating/model/?remote=-Kr2X939XcFwKAunEaMK" frameborder="0"></iframe>

Answer 5

रेटिना , 103 96 88 बाइट्स

^
¶
;{:`

T`0d`d
(?<=¶(.)*)0(?=4|.*¶(?<-1>.)*(?(1)_)4|(?<=40|¶(?(1)_)(?<-1>.)*4.*¶.*))
1

इसे ऑनलाइन आज़माएं! 9राख के लिए उपयोग ; इसका उपयोग करके 4 बाइट्स की लागत पर बदला जा सकता है T`1-8`2-8A। संपादित करें: @MartinEnder के लिए 6 बाइट्स सहेजे गए। स्पष्टीकरण:

^
¶

एक विभाजक जोड़ें ताकि आउटपुट एक दूसरे में न चलें। (नीचे मिलान करते समय भी मदद करता है।)

;{:`

अंतिम स्थिति को प्रिंट न करें (जो पिछले राज्य के समान है जो पहले ही प्रिंट हो चुका है)। जब तक पास राज्य को बदल नहीं देता तब तक दोहराएं। प्रत्येक पास से पहले वर्तमान स्थिति को प्रिंट करें।

T`0d`d

सभी आग की तीव्रता को आगे बढ़ाएं।

(?<=¶(.)*)0(?=4|.*¶(?<-1>.)*(?(1)_)4|(?<=40|¶(?(1)_)(?<-1>.)*4.*¶.*))
1

प्रकाश उपयुक्त के रूप में क्षेत्रों को उजागर। उप-स्पष्टीकरण:

(?<=¶(.)*)

इस अयोग्य फ़ील्ड के कॉलम नंबर को मापें।

0

अनलिट फ़ील्ड से मिलान करें।

(?=4

दाईं ओर एक उपयुक्त फ़ील्ड देखें।

  |.*¶(?<-1>.)*(?(1)_)4

नीचे पंक्ति में एक ही कॉलम (एक संतुलन समूह का उपयोग करके) के लिए एक उपयुक्त फ़ील्ड देखें। ध्यान दें कि यदि इनपुट आयताकार की गारंटी दे सकता है तो |.*¶(?>(?<-1>.)*)43 बाइट की बचत के लिए इसे सरल बनाया जा सकता है ।

  |(?<=40

बाईं ओर एक उपयुक्त फ़ील्ड देखें। (चूंकि हम फ़ील्ड के दाईं ओर से देख रहे हैं, हम अनलिमिटेड फ़ील्ड को भी देखते हैं।)

      |¶(?(1)_)(?<-1>.)*4.*¶.*))

ऊपर की पंक्ति में एक ही कॉलम में उपयुक्त फ़ील्ड देखें। चूंकि यह एक देखने वाला है और इसलिए दाएं-से-बाएं मैच है, इसलिए संतुलन समूह की स्थिति को संतुलन समूह द्वारा मिलान किए गए स्तंभों के सामने प्रकट होना है।

Answer 6

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

@a=map{[/./g]}<>;do{say@$_ for@a;say;my@n=();for$r(0..$#a){$l=$#{$a[$r]};for(0..$l){$t=$a[$r][$_];$n[$r][$_]=($q=$n[$r][$_])>$t?$q:$t==9?9:$t?++$t:0;if($t==4){$n[$r-1][$_]||=1if$r&&$_<$#{$a[$r-1]};$n[$r+1][$_]||=1if$r<$#a&&$_<$#{$a[$r+1]};$n[$r][$_-1]||=1if$_;$n[$r][$_+1]||=1if$_<$l}}}$d=0;for$r(0..$#a){$d||=$a[$r][$_]!=$n[$r++][$_]for 0..$#{$a[$r]}}@a=@n}while$d

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

एक जले हुए स्थान को इंगित करने के लिए 'ए' के ​​बजाय '9' का उपयोग करता है।

व्याख्या की

@a=map{[/./g]}<>;   # split input into a 2-D array

do{
say@$_ for@a;say;   # output the current state
my@n=();            # holds the next iteration as it's created
for$r(0..$#a){      # loop through rows
  $l=$#{$a[$r]};    # holder for the length of this row
  for(0..$l){
    $t=$a[$r][$_];  # temporary holder for current value
    $n[$r][$_]=($q=$n[$r][$_])>$t?$q:$t==9?9:$t?++$t:0; #update next iteration
    if($t==4){      # ignite the surrounding area if appropriate
      $n[$r-1][$_]||=1if$r&&$_<$#{$a[$r-1]};
      $n[$r+1][$_]||=1if$r<$#a&&$_<$#{$a[$r+1]};
      $n[$r][$_-1]||=1if$_;
      $n[$r][$_+1]||=1if$_<$l
    }
  }
}
$d=0;              # determine if this generation is different than the previous
for$r(0..$#a){$d||=$a[$r][$_]!=$n[$r++][$_]for 0..$#{$a[$r]}}
@a=@n              # replace master with new generation
}while$d

Answer 7

हास्केल , 162 बाइट्स

import Data.List
i x|x<'9'=succ x|1<2=x
f('3':'@':r)="30"++f r
f(x:r)=x:f r
f e=e
a%b=a.b.a.b
g=map(i<$>).(transpose%map(reverse%f))
h x|y<-g x,y/=x=x:h y|1<3=[x]

इसे ऑनलाइन आज़माएं! उपयोग: hफ़ील्ड को रेखाओं की सूची के रूप में लेता है और फ़ील्ड की सूची लौटाता है। एक असंतुलित क्षेत्र द्वारा @और राख द्वारा इंगित किया जाता है 9, अलग-अलग आग के लिए अंक 1हैं 8।

• fउन सभी असंतुलित @खेतों को बदलकर, जो एक जलते हुए 3खेत के लिए सही हैं, के स्थान पर बाईं से दाईं ओर आग फैलने का प्रबंधन करता है 0।
• iप्रत्येक अंक में वृद्धि तब तक होती है जब तक वह इससे कम हो 9।
• gfप्रत्येक लाइन पर लागू होता है, फिर लाइन को उलट देता है, fफिर से लागू होता है और वापस पलटता है। फिर लाइनों की सूची को ट्रांसपोज़ किया जाता है और फिर से प्रत्येक लाइन पर और इसके रिवर्स fको लागू किया जाता है।
• hgइनपुट पर लागू होता है जब तक कि यह परिवर्तन नहीं करता है और परिणाम एकत्र करता है।

Comments

इनपुट पर "" @ 3 @ 1 \ n @@@@ 9 \ n555 @@@@@@@@@@@@@@@@@@@@@@, @s स्विच की लंबी लाइन के कारण पहली पुनरावृत्ति के बाद शीर्ष पंक्ति। फिक्सिंग जो महान होगी, धन्यवाद!

— Gryphon -

@Gryphon विस्थापन वर्ण मैट्रिक्स को स्थानांतरित करने के कारण होता है। यह काम करता है अगर अन्य लाइनों को कुछ चरित्र के साथ समान लंबाई में लाया जाता है जो न तो क्षेत्र, आग या राख का प्रतिनिधित्व करता है, जैसे _। यदि यह स्वीकार्य नहीं है, तो मुझे डर है कि मुझे उत्तर को नष्ट करना होगा, क्योंकि यह इसके उपयोग के आसपास केंद्रित है transposeऔर मुझे टन के बाइट्स को पेश किए बिना इसे आसानी से ठीक करने का कोई तरीका नहीं दिखता है।

— लाकोनी

Answer 8

C (gcc) , 308 305 299 297 295 291 बाइट्स

#define F B[i][v]
m(A,B,k,y,m,U,i,v)char**B;{do{for(i=k=y=0;i<A;puts(""),++i)for(v=0;v<(m=strlen(B[i]));F=(U=F)>48&&F<56?F+1:F>55?65:(i+1<A&&B[i+1][v]==51||v+1<m&&B[i][v+1]==51||v-1>-1&&B[i][v-1]==52||i-1>-1&&B[i-1][v]==52)&&U<49?49:F,putchar(U),k+=U<49||U>64,++y,++v);puts("");}while(k-y);}

इस कार्यक्रम के एक समारोह के रूप में जो द्वारा अनुमति दी है, इसकी लंबाई से पहले तार की एक सरणी के लिए दो आदानों, एक सूचक लेता है परिभाषित करता है यह I / O डिफ़ॉल्ट । अनुगामी नईलाइन के साथ STDOUT में आउटपुट।

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

Comments

इनपुट पर हमेशा के लिए चलता है 80।

— aschepler

@aschepler क्षमा करें! मैंने यह मान लिया कि सभी पात्रों को बदल जाना चाहिए A, लेकिन जाहिर है मैंने गलत माना। वैसे भी, जानकारी के लिए धन्यवाद। यह अब तय हो गया है।

— आर। कप

-6 बाइट्स! टियो लिंक

— जियाको गारबेलो

@GiacomoGarabello मैं विश्वास नहीं कर सकता कि मैं उस रणनीति के बारे में भूल गया था। मुझे याद दिलाने के लिये धन्यवाद! :)

— आर। काप

Answer 9

ऑक्टेव, 72 69 बाइट्स

a=input(''),do++a(a&a<9);a+=imdilate(a==4,~(z=-1:1)|~z')&~a,until a>8

इनपुट को संख्या के 2 डी सरणी के रूप में लिया जाता है, और रिक्त स्थानों को चिह्नित किया जाता है Inf। 'A'के साथ बदल दिया गया है9 । इंटरमीडिएट के परिणाम (संख्या की सरणी के रूप में) स्पष्ट रूप से मुद्रित।

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

स्पष्टीकरण:

एक लूप में imdilateछवि पैकेज से फ़ंक्शन (रूपात्मक छवि फैलाव) का उपयोग आग के प्रसार को अनुकरण करने के लिए किया जाता है।

Comments

यह सभी आकारों के बोर्डों के साथ काम करता है, और यहां तक ​​कि छेदों के एक गुच्छा के साथ भी। ईजी: [0 Inf 0 0 0;0 Inf 0 Inf 0;0 Inf 0 Inf 0;0 0 0 Inf 1]- वेरी नाइस

— Suamere

Answer 10

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

def f(x):
 while{i for m in x for i in m}>{9,''}:
    yield x;i=0
    for l in x:
     j=0
     for c in l:
        if 0<c<9:x[i][j]+=1
        j+=1
     i+=1
    i=0
    for l in x:
     j=0
     for c in l:
        if c==0 and{1}&{x[k[1]][k[2]]==4for k in[y for y in[[i,i-1,j],[i<len(x)-1,i+1,j],[j,i,j-1],[j<len(l)-1,i,j+1]]if y[0]]}:x[i][j]+=1
        j+=1
     i+=1
 yield x

fइनपुट को पूर्णांक के 2 डी सरणी के रूप में लेता है, और रिक्त स्थानों को चिह्नित करता है ''। 'A'के साथ बदल दिया गया है 9। फ़ंक्शन एक ही प्रारूप में समय के साथ सभी क्षेत्रों के जनरेटर का उत्पादन करता है।

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

Answer 11

ऑक्टेव , 212 बाइट्स

function r(f)b=48;f-=b;c=-16;l=f~=-c;d=17;p=@(x)disp(char(x+b));g=@()disp(' ');p(f);g();while~all(any(f(:)==[0 d c],2))m=f>0&l;f(m)+=1;k=conv2(f==4,[0 1 0;1 0 1;0 1 0],'same')&~m&l;f(k)+=1;f(f>8&l)=d;p(f);g();end

चलाने के लिए, वर्ण सरणी निर्दिष्ट करें:

f = ['0301','000A','555 '];

... फिर करो:

r(f)

पालन ​​करने के लिए कोड की व्याख्या ...

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

^{नोट: मैंने इस कोड को tio.run के साथ चलाने की कोशिश की , लेकिन मुझे कोई आउटपुट नहीं मिल रहा था। मुझे दूसरी सेवा का उपयोग करना पड़ा।}

Comments

वास्तव में इस समय मैं आपके सामने उत्तर देने के लिए एक ऑक्टेव उत्तर पोस्ट करना चाहता हूं ..

— मिचथन

Answer 12

PHP, 226 212 210 209 185 177 बाइट्स

for($f=file(m);$f!=$g;print"
")for($g=$f,$y=0;$r=$f[$y++];)for($x=-1;~$c=$r[++$x];$f[$y-1][$x]=$c=="0"?strstr($g[$y-2][$x].$r[$x-1].$f[$y][$x].$r[$x+1],51)/3:min(++$c,9))echo$c;

एक फ़ाइल नाम की अनुगामी न्यूलाइन के साथ इनपुट लेता है m; 9राख के लिए।

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

---

पहला दृष्टिकोण: PHP 7.0, 209 बाइट्स

for($f=$g=file(m);trim(join($f),"A
");print"
".join($f=$g))for($y=-1;(a&$c=$r[++$x])||$r=$f[$y-=$x=-1];)for(+$c&&$g[$y][$x]=++$c<9?$c:A,$a=4;$a--;$q=$p)$c-4|($w=&$g[$y+$p=[1,0,-1][$a]])[$q+=$x]!="0"||$w[$q]=1;

नाम की फ़ाइल से अनुगामी न्यूलाइन के साथ इनपुट लेता है m।

इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

PHP संस्करण नोट (पुराने दृष्टिकोण के लिए)

• पीएचपी से 7.0 वृद्ध लोगों के लिए, सब कुछ को बदलने के बाद $c-4|से$g[$y+$p=[1,0,-1][$a]][$q+=$x]!="0"||$g[$y+$p][$q]=1;
• 5.5 से अधिक पुराने PHP के लिए, के [1,0,-1][$a]साथ बदलें$a%2*~-($a&2)
• पीएचपी से 7.0 नए के लिए, की जगह a&$cके साथ ""<$c, +$cके साथ 0<$cऔर $c-4साथ$c!=4

Comments

अन्य परीक्षण मामलों के लिए नहीं करता है 'काम ... sandbox.onlinephpfunctions.com/code/...

— g19fanatic

@ g19fanatic फिक्स्ड और गोल्फ। ध्यान देने के लिए धन्यवाद।

— टाइटस

Answer 13

ऑक्टेव, 419 312 बाइट्स

M=input('') %take a matrix M as input
[a, b]=size(M); %size M for later
while mean(mean(M))!=9 %while the whole matrix M isn't ashes
M=M+round(M.^0.001); %if there is a nonzero int add 1 to it
for i=1:a %loop over all values of M
for j=1:b
if(M(i,j)==4) %if a value of 4 is found, ignite the zeros around it
if(M(max(i-1,1),j)==0) M(i-1,j)++;end
if(M(min(i+1,a),j)==0) M(i+1,j)++;end
if(M(i,max(j-1,1))==0) M(i,j-1)++;end      
if(M(i,min(j+1,b))==0) M(i,j+1)++;end
elseif(M(i,j)==10) M(i,j)--;
end
end
end
M %display the matrix
end

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

यह मेरा संस्करण है यह काम करता है, इसलिए अब मुझे अभी भी इसे गोल्फ करने की आवश्यकता है। मुझे लगता है कि यह बहुत छोटा हो सकता है अगर मुझे मैट्रिक्स में 4 के सूचकांकों को खोजने का तरीका मिल जाए, लेकिन मुझे नहीं पता कि कैसे।
PS: A मेरे कोड में एक 9 है।

Comments

के बजाय endif endforऔर endwhileआप लिख सकते हैंend

— rahnema1

Answer 14

स्टैंसिल ( ∊-मोड) , 22 बाइट्स

S≡8:'A'⋄0::S⋄(3∊N)⌈S+s

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

टेस्ट इनपुट की तरह, रिक्त स्थान के लिए 0- 8, ' 'रिक्त और के 'A'लिए अलग-अलग पूर्णांक का उपयोग करें A। अनुगामी रिक्त स्थान भी जोड़ना याद रखें।