ASCII- कला ज़ोंबी आक्रमण सिमुलेशन

Question

एक ज़ोंबी आक्रमण का अनुकरण करने के लिए, ग्रिड के साथ शुरू करें #और नक्शे का प्रतिनिधित्व करें:

##   ##
###   #
## ##  
  # ###
#  ####

• # भूमि का प्रतिनिधित्व करता है।
• पानी का प्रतिनिधित्व करता है।

लाश नक्शे पर एक बिंदु से शुरू होती है ...

##   ##
###   #
## %#  
  # ###
#  ####

... और फैल गया। %लाश को संक्रमित भूमि को दर्शाता है।

हालाँकि, लाश तैर नहीं सकती । वे उसी तरह भूमि पार कर सकते हैं जिस तरह से एक राजा शतरंज में चलता है - किसी भी विकर्ण या रूढ़िवादी दिशा में एक वर्ग:

!!!
!%!
!!!

सिमुलेशन के अंत में, कुछ भूमि लाश से संक्रमित होगी:

%%   ##
%%%   #
%% %%  
  % %%%
#  %%%%

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

विशेष विवरण

• आपका प्रोग्राम एक वैकल्पिक ट्रेलिंग न्यूलाइन प्रिंट कर सकता है।
• आप मान सकते हैं कि इनपुट सही प्रारूप (रिक्त स्थान के साथ गद्देदार) में होगा, एक वैकल्पिक अनुगामी न्यूलाइन के साथ।
• आप मान सकते हैं कि प्रारंभिक ज़ोंबी जमीन पर शुरू होगा और तुरंत नहीं मर जाएगा।
• यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।
• -100% बोनस यदि आपका कोड मनमानी ट्यूरिंग मशीनों के लिए हॉल्टिंग समस्या को भी हल कर सकता है ।
• आपके कार्यक्रम में अधिकतम 50 वर्णों की बोर्ड चौड़ाई होनी चाहिए।

Comments

क्या समस्या है ?

— मुकुल कुमार

@MukulKumar en.wikipedia.org/wiki/Halting_problem । यह एक मज़ाक है। हलिंग समस्या को हल करना असंभव है।

— Esolanging फल

आप कभी नहीं जानते: पी

— मुकुल कुमार

संबंधित: codegolf.stackexchange.com/questions/83808/flood-fill-a-2d-grid

— Angs

नहीं, गंभीरता से, मैं -200% करने के लिए समस्या निवारण समाधान के लिए बोनस उठाना चाहते हैं। इसका जवाब होगा। :)

— रुडोल्फजेलिन

Answer 1

एपीएल (डायलॉग) , 44 बाइट्स

{{c'%'[⌊⌿'%#'∊¨⍵(c←4⊃⍵)]}∘,⌺3 3⍣≡'%'@(⊂⍺)⊢⍵}

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

मान लेता है ⎕IO←0।

वाम तर्क: 0 r% की अनुक्रमित पंक्ति ,% का 0-अनुक्रमित स्तंभ c: r c
सही तर्क: चरित्र मैट्रिक्स

Answer 2

कोटलिन, 283 218 बाइट्स

Ambda (एक नेस्टेड फ़ंक्शन के साथ, हे)।

golfed

{i:String,x:Int,y:Int->val m=i.lines().map{it.toCharArray()};fun v(x:Int,y:Int){try{if(m[y][x]=='#'){m[y][x]='%';for(c in-1..1)for(d in-1..1)if(!(c==0&&d==0))v(x+c,y+d)}}catch(e:Exception){}};v(x, y);m.map(::println)}

Ungolfed

fun zombies(input: String, startX: Int, startY: Int) {
    val m = input.lines().map(String::toCharArray)      // build game map
    fun invade(x: Int, y: Int) {                        // nested functions, woo!
        try {
            if (m[y][x] == '#') {                       // if land
                m[y][x] = '%'                           // mark as invaded
                for (dx in -1..1) {                      // generate neighbour tiles
                    for (dy in -1..1) {
                        if (!(dx == 0 && dy == 0)) {
                            invade(x + dx, y + dy)        // attempt to invade neighbours
                        }
                    }
                }
            }
        } catch(e: Exception) {}                        // catches ArrayIndexOutOfBounds
    }

    invade(startX, startY)                              // start the invasion
    m.map(::println)                                    // print final state
}

एक पुनरावर्ती समाधान पर स्विच करके काफी कुछ बाइट्स को बचाया।

Comments

"फन लाश": पी

— फल का भक्षण

Answer 3

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

(s,x,y,l=s.search`\n`,g=s=>s==(s=s.replace(eval(`/(#|%)(.?[^]{${l-1}}.?)?(?!\\1)[#%]/`),`%$2%`))?s:g(s))=>g(s.slice(0,x+=y*l)+`%`+s.slice(x+1))

जहां \nशाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। 0-अनुक्रमित निर्देशांक लेता है।

Answer 4

Befunge, 324 323 बाइट्स

&00p&10p20p~$v<p02+g02*!g02:+1$$$$<
 #<%>\"P"/8+p>1+:::~:0`!#v_:85+`!#^_2%\2%3*1+*\2/:"P"%\"P"/8+g+\2/:"P"
:+**73"="+g00*g02g010$$$$<v
02:\-<v/"P"\%"P":/2::_|#:$<:+1+g02\+g02:\-1+g02:\+1:\-1:\+1-g
\:20g^>g:30p\2%3*1+/4%1->#^_::2%6*2+30g+\2/:"P"%\"P"/p:20g-1-
0<v2\g+8/"P"\%"P":/2::<\_@#`0:-g
2^>%3*1+/4%1g,1+:20g%#^_1+55+,\

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

व्याख्या

Befunge में इसे लागू करना थोड़ा जटिल था क्योंकि हम "मेमोरी" के 80x25 वर्णों तक सीमित हैं, जिसे स्वयं स्रोत कोड के साथ साझा किया जाना है। उस क्षेत्र में 50x50 मानचित्र को फिट करने की चाल 2 डी मानचित्र को बाइट में दो मानचित्र स्थानों के साथ 1 डी सरणी में समतल करने के लिए थी। इस 1 डी सरणी को फिर 2 डी सरणी में लपेट दिया जाता है ताकि यह बेफ्यूज प्लेफील्ड के 80 चरित्र चौड़ाई में फिट हो सके।

संक्रमण एल्गोरिथ्म 1 डी सरणी में प्रारंभिक निर्देशांक को एक ऑफसेट में परिवर्तित करके शुरू होता है जो इसे स्टैक पर धकेलता है। मुख्य लूप स्टैक से एक मूल्य लेता है और उस ऑफसेट के लिए मानचित्र स्थिति को देखता है। यदि यह असिंचित भूमि है, तो यह संक्रमित के रूप में चिह्नित हो जाता है, और आठ नए ऑफसेट स्टैक पर धकेल दिए जाते हैं (वर्तमान स्थिति के चारों ओर भूमि का प्रतिनिधित्व करते हैं)। स्टैक खाली होने तक यह प्रक्रिया जारी रहती है।

सीमा मूल्यों से बाहर की जाँच करने से बचने के लिए, मानचित्र को सभी किनारों के चारों ओर एक वर्ण जल सीमा के साथ संग्रहित किया जाता है।

Answer 5

पिप , 59 बाइट्स

{(ac+b+b*Ya@?n):'%L2*#aa:RVaR.`#(.?.?.{`.y-1.`})?%`'%.@>_a}

एक फ़ंक्शन जो एक बहुस्तरीय स्ट्रिंग लेता है, प्रारंभिक ज़ोंबी की पंक्ति (0-अनुक्रमित), और प्रारंभिक ज़ोंबी का स्तंभ (0-अनुक्रमित)। इसे ऑनलाइन आज़माएं!

कैसे?

क्योंकि पिप में चक्रीय अनुक्रमण है (आमतौर पर एक अच्छी बात है, लेकिन इस समस्या के लिए बुरा है क्योंकि हम मानचित्र किनारों को लपेटना नहीं चाहते हैं), मैं रेगेक्स-रिप्लेसमेंट समाधान के लिए गया था।

Ya@?nपहली नईलाइन (यानी ग्रिड की चौड़ाई) के सूचकांक को खोजता है और इसमें जमा करता है y।

(ac+b+b*Ya@?n):'%उपरोक्त करने के बाद, गणना करता है (width + 1) * row + col, अर्थात c+b+b*y, और उस सूचकांक पर वर्ण सेट करता है %।

L2*#aछोरों 2*len(a)बार है, जो हमें बाढ़ भरण पूरी तरह से लागू करने के लिए पर्याप्त पुनरावृत्तियों देता है और यह सुनिश्चित करता है पुनरावृत्ति संख्या भी है (महत्वपूर्ण है कि)।

.`#(.?.?.{`.y-1.`})?%`बीच में 0, चौड़ाई -1, चौड़ाई, या चौड़ाई + 1 वर्णों के साथ, #उसके बाद मेल खाता एक रेगेक्स बनाता है %। ( .शुरुआत .में रेगेक्स मैच की नई सुर्खियों में आता है।) यह रेगेक्स निम्नलिखित में से किसी भी विन्यास से मेल खाता है:

#  
 % 

 # 
 % 

  #
 % 

#% 

aR ... '%.@>_चरित्र के साथ इस regex के मैचों की जगह %के लिए prepended .पहले को छोड़कर सभी चरित्र @>मैच के _; संक्षेप में, के #साथ की जगह %।

a:RV ...इसे उलट देता है और इसे वापस सौंप देता है a। हम रिवर्स करते हैं क्योंकि रेग्ज केवल स्ट्रिंग में # पहले से मेल खाता है %, बाद में नहीं; लेकिन जब स्ट्रिंग उलट जाती है, तो पहले हो जाती है और हम इसे अगले पुनरावृत्ति पर मेल कर सकते हैं। यही कारण है कि पुनरावृत्तियों की संख्या भी है।

लूप पूरा होने के बाद, हम बस संशोधित मूल्य लौटाते हैं a।

Answer 6

TSQL, 267 बाइट्स

golfed:

USE master
DECLARE @ varchar(max)=
'##   ##
###   #
## %#  
  # ###
#  ####'

WHILE @@rowcount>0WITH C as(SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c
FROM spt_values CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
WHERE type='P'and x<len(@))SELECT @=stuff(@,d.i,1,'%')FROM C,C D
WHERE'#%'=d.v+c.v and abs(c.r-d.r)<2and abs(c.c-d.c)<2PRINT @

Ungolfed:

USE master-- the script needs to be executed on the default master database
DECLARE @ varchar(max)=
'##   ##
###   #
## %#  
  # ###
#  ####'

WHILE @@rowcount>0
WITH C as
(
  SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c
  FROM
    spt_values
  CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
  WHERE type='P'and x<len(@)
)
SELECT @=stuff(@,d.i,1,'%')FROM C,C D
WHERE'#%'=d.v+c.v and abs(c.r-d.r)<2and abs(c.c-d.c)<2

PRINT @

कोशिश करके देखो

Answer 7

PHP, 209 189 188 183 बाइट्स

गोल्फ हो सकता है

for($w=strpos($s=($a=$argv)[1],10),$s[$a[2]*++$w+$a[3]]="%";$t<$s;)for($t=$s,$i=0;""<$c=$s[$i++];)if($c>"$")for($y=-2;++$y<2;)for($x=3;$x--;)$s[$p=$i+$y*$w-$x]>"!"?$s[$p]="%":0;echo$s;

साथ दौड़ो php -r '<code>' '<grid>' <y> <x>

Answer 8

जे, 152 बाइट्स

बहुत अच्छी तरह से गोल्फ नहीं है, मुझे यकीन है कि उन अंतिम कुछ नियंत्रण संरचनाओं को हटाने का एक तरीका है।

f=:4 :0
c=.(' '"_)`({~&<y)@.((*./y<$x)*.*./y>:0 0)x if.c='#' do.x=.'%'(<y)}x[i=.0 while.i<9 do.i=.>:i[x=.x f y+i<:@(|~,<.@%)3 end.end.x
)
g=:>@cutLF@[f]

एक बाढ़ भराव एल्गोरिथ्म लागू करता है। F छ लागू करने से पहले फ़ंक्शन जी प्रारूप एक वर्ण सरणी में इनपुट करता है।

ध्यान दें कि निर्देशांक थोड़ा अजीब हैं:

0, 0

शीर्ष बाएं कोने है। पहला समन्वय बढ़ाना:

1, 0

Y दिशा में स्थिति को नीचे ले जाता है।

इसके अलावा निर्देशांक सामान्य हैं।

उदाहरण:

    land =: 0 : 0    NB. Define a multi-line string
##   ##
###   #
## ##  
  # ###
#  ####
)

    ] l =. >@cutLF land    NB. Cut 'land' on new lines, and form into an array. Assign to 'l'
##   ##
###   #
## ##  
  # ###
#  ####
    NB. Looks the same, but it isn't.

    '%' (<2 3)} l    NB. 'Infect' the land at 2, 3
##   ##
###   #
## %#  
  # ###
#  ####

    l f 2 3    NB. Flood fill on l (already formatted), starting at 2 3
%%   ##
%%%   #
%% %%  
  % %%%
#  %%%%

    land g 2 3    NB. Flood fill on land, formats for us.
%%   ##
%%%   #
%% %%  
  % %%%
#  %%%%