11

अरे नहीं! निमो, हमारी छोटी मसखरी मछली इस ASCII महासागर में खो गई है और उसके पिता मार्लिन उसे खोजने की कोशिश कर रहे हैं।

आपका काम मार्लिन को निमो तक सुरक्षित पहुंचाना है। लेकिन सावधान रहना, हम ढीले पर एक खिला उन्माद ब्रूस है, इसलिए बेहतर है कि हर कीमत पर उससे बचें!

विवरण

आपको एक आयताकार ASCII महासागर ग्रिड दिया गया है जिसमें केवल लोअरकेस अल्फाबेट्स हैं a-z। यह महासागर होगा nemo, marlinऔर इसके bruceअंदर एक निरंतर पॉलीओमीनो के रूप में होगा, जो हमेशा पॉलीस्टिनो के पहले कॉलम में सबसे ऊपरी सेल से शुरू होता है। इसलिए, उदाहरण के लिए, सभी संभावित टेट्रॉमिनो में से, वैध को नीचे दिए गए स्निपेट में सूचीबद्ध किया गया है

कोड स्निपेट दिखाएं

nemo

n
e
m
o

no
em

ne
om

nem
  o

  o
nem

n
e
mo

 o
 m
ne

ne
 m
 o

n
emo

ne
 mo

n
em
 o

 mo
ne

Expand snippet

लेकिन इस तरह के रूप अमान्य हैं और इनपुट में मौजूद नहीं होंगे:

omen

ne
mo

nem
o

o
m
en

nem
 o

n
eo
m

अंत में, आपका कार्य marlinपॉलीओमीनो टाइल से पॉलीमिनो टाइल तक एक रास्ता खोजना है, nemoजिससे यह सुनिश्चित हो सके कि आपके रास्ते में कोई भी सेल bruceपॉलीमिनो टाइल से सटे नहीं है । आपके आउटपुट को उन सभी अल्फाबेट्स को बदलना चाहिए जो marlinटाइल, nemoटाइल का हिस्सा नहीं हैं और उन दोनों को प्रिंट करने योग्य ASCII रेंज (स्पेस सहित) के एक चरित्र के साथ निचले पथ के अलावा दोनों को जोड़ने वाले मार्ग हैं a-z।

उदाहरण

यदि इनपुट महासागर निम्नानुसार है:

oxknvvolacycxg
xmliuzsxpdzkpw
warukpyhcldlgu
tucpzymenmoyhk
qnvtbsalyfrlyn
cicjrucejhiaeb
bzqfnfwqtrzqbp
ywvjanjdtzcoyh
xsjeyemojwtyhi
mcefvugvqabqtt
oihfadeihvzakk
pjuicqduvnwscv

(3 पॉलीमिनोस होने के साथ:

...n..........
.mli..........
.ar...........
..............
....b.........
....ruce......
..............
.....n........
.....emo......
..............
..............
..............

)

तब एक वैध समाधान जैसा दिख सकता है:

...n..........
.mli..........
.ar...........
.u............
.n............
.i............
.z............
.wvjan........
.....emo......
..............
..............
..............

नीचे स्निपेट में कुछ और उदाहरण हैं:

कोड स्निपेट दिखाएं

oxknvvolacycxg
xmliuzsxpdzkpw
warukpyhcldlgu
tucpzymenmoyhk
qnvthsalyfrlyn
cibrucejhiaebu
bzqfnfwqtrzqbp
ywvjanjdtzcoyh
xsjeyemojwtyhi
mcefvugvqabqtt
oihfadeihvzakk
pjuicqduvnwscv

...n..........
.mli..........
.ar...........
.u............
qn............
c.............
b.............
ywvjan........
.....emo......
..............
..............
..............

----------------------------------------------

nemokjahskj
sdjsklakdjs
uqiceasdjnn
sbruakmarli

nemokjahskj
..........s
..........n
......marli

----------------------------------------------

Expand snippet

टिप्पणियाँ

ग्रिड हमेशा एक सही आयत होगी और इसमें केवल एक पॉलीमिनो टाइल होगी nemo, marlinऔर bruce।
आपका रास्ता टाइल bruceमें किसी भी सेल के 4 आसन्न (ऊपर, नीचे, बाएँ और दाएँ) से होकर नहीं गुजरना चाहिए bruce।
यह हमेशा गारंटी है कि वहाँ से कम से कम एक वैध रास्ता marlinहोगा nemo।
यहाँ एक सबसे छोटे मार्ग की आवश्यकता नहीं है, इसलिए पागल हो जाओ!
भले ही आपको सबसे छोटा रास्ता खोजने की ज़रूरत नहीं है, लेकिन पथ में कोई भी सेल (मार्ग जिसमें मार्लिन या नेमो शामिल नहीं है) पथ में दो से अधिक अन्य कोशिकाओं से सटे नहीं हो सकता है।
रास्ता marlinया nemoटाइलों के माध्यम से नहीं जाना चाहिए , क्योंकि यह एक दिशा चुनने में छोटी मछलियों को भ्रमित करेगा।
हमेशा की तरह, आप STDIN (या निकटतम समकक्ष), कमांड-लाइन तर्क या फ़ंक्शन पैरामीटर, और STDOUT (या निकटतम समकक्ष), रिटर्न वैल्यू या फ़ंक्शन (आउट) पैरामीटर के माध्यम से आउटपुट का उत्पादन करके एक प्रोग्राम या फ़ंक्शन लिख सकते हैं।
यदि मल्टी-लाइन इनपुट संभव नहीं है, तो आप मान सकते हैं कि ग्रिड |चरित्र के बजाय शामिल हो गया है \n। आप ग्रिड पंक्तियों की एक सरणी के रूप में इनपुट भी ले सकते हैं।

यह कोड गोल्फ है इसलिए बाइट्स जीत में सबसे छोटी प्रविष्टि है।

code-golf grid path-finding

— अनुकूलक
स्रोत

क्या मार्ग मार्लिन (या नीमो) से होकर जा सकता है? यदि मार्लिन में kऊपर lदिखाई देता था तो क्या उपरोक्त समाधान अभी भी मान्य होगा ? (मार्लिन में n से nemo तक का रास्ता बनाते हुए)

— केसाब

@स्कैब मैं नहीं कहूंगा कि यह तब मार्लिन को भ्रमित कर देगा :)

— ऑप्टिमाइज़र

4

मतलाब 560

सभी अनावश्यक स्थानों, सभी अर्धविरामों और सभी टिप्पणियों को हटाते समय 560 बाइट्स। बहुत अधिक गोल्फ हो सकता है, लेकिन मैं अभी (शायद कल ...) हर किसी को शुभ रात्रि थक गया हूँ।

पुनश्च: मैंने माना कि पथ में 4 पड़ोस ('+') की कनेक्टिविटी होनी चाहिए।

function c(A)
Z = [0,1,0;1,1,1;0,1,0];
Br = q('bruce');
Bn = conv2(Br,ones(3),'s')>0;
Ne = q('nemo');
Ma = q('marlin');
%construct path marlin to nemo
U=Ma>0;M=A*Inf;
M(U)=0;
for k=1:2*sum(size(A))%upper bound for path length
    %expand
    V=imdilate(U,Z);
    V(Bn)=0;
    M(V-U==1)=k;
    U=V;
    %disp(M)
end
%go back from nemo to marlin
Pr=reshape(1:numel(A),size(A));
[i,j]=find(Ne);
m=M(i(1),j(1));%value
P=A*0;%path image
P(i(1),j(1))=1;
for k=m:-1:1
    %find neighbour of (i(1),j(1)) with value m-1
    U=imdilate(P,Z);
    F = M==k;
    G = F&U;
    mask = Pr == min(Pr(F & U));
    P(mask)=1; 
end
A(~P & ~Ma & ~Ne)='.';
disp(A)



    function M = q(s)%find string in matrix, A ascii, M mask
        M = A*0;
        m=numel(s);
        N = M+1;%all neighbours
        for k=1:m;
            M(A==s(k) & N)=k;%only set the ones that were in the neighbourhood of last
            L=M==k;
            N=imdilate(L,Z);
        end
        for k=m:-1:2
            %set all that are not neighbour to next higher highest to zero
            L=M==k;
            N=imdilate(L,Z);
            M(M==k-1 & ~N)=0;
        end
    end


end

कॉलिंग फ़ंक्शन: (जरूरी नहीं कि नए अंक)

c(['oxknvvolacycxg',
'xmliuzsxpdzkpw',
'warukpyhcldlgu',
'tucpzymenmoyhk',
'qnvtbsalyfrlyn',
'cicjrucejhiaeb',
'bzqfnfwqtrzqbp',
'ywvjanjdtzcoyh',
'xsjeyemojwtyhi',
'mcefvugvqabqtt',
'oihfadeihvzakk',
'pjuicqduvnwscv']);

आउटपुट:

...n..........
.mli..........
.ar...........
..c...........
..v...........
..c...........
..q...........
..vjan........
.....emo......
..............
..............
..............

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

नाम निकालना

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

रास्ता खोज रहे हैं

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

 2 1 1  0  1  2  3  4  5  6  7  8  9 10
 1 0 0  0  1  2  3  4  5  6  7  8  9 10
 1 0 0  1  2  3  4  5  6  7  8  9 10 11
 2 1 1  _  _  _  5  6  7  8  9 10 11 12
 3 2 2  _  _  _  _  _  _  9 10 11 12 13
 4 3 3  _  _  _  _  _  _ 10 11 12 13 14
 5 4 4  _  _  _  _  _  _ 11 12 13 14 15
 6 5 5  6  7  8  9 10 11 12 13 14 15 16
 7 6 6  7  8  9 10 11 12 13 14 15 16 17
 8 7 7  8  9 10 11 12 13 14 15 16 17 18
 9 8 8  9 10 11 12 13 14 15 16 17 18 19
10 9 9 10 11 12 13 14 15 16 17 18 19 20

अब nemoपिक्सल्स पर शुरू करें और प्रत्येक चरण में दूरी काउंटर को कम करें और अपने पथ पर अगली निचली दूरी (उस दूरी के नक्शे के अनुसार जिसे हमने पहले गणना की थी) के साथ जोड़ें।

— flawr
स्रोत

3

अजगर 2 - 658

समय और स्मृति दोनों में बहुत अक्षम। पैटर्न की पहचान करने का कार्य पुनरावर्ती फ़ंक्शन S है, और पथों को खोजने के लिए फ़ंक्शन C है, जो मूल रूप से एक अकुशल ए * कार्यान्वयन है।

G=input().split('\n')
R=range
S=lambda g,x,y,s,B:[[(x,y)]+r for a,b in[(-1,0),(0,-1),(0,1),(1,0)]for r in S(g,x+a,y+b,s[1:],B)if B(x,y)and s[0]==g[y][x]]if s else[[]]
C=lambda l,N,B:[i for i in l if i[-1]in N]or C([i+[(i[-1][0]+c,i[-1][1]+d)]for i in l for c,d in [(-1,0),(0,-1),(0,1),(1,0)]if all(1<abs(i[-1][0]+c-a)or 1<abs(i[-1][1]+d-b)for a,b in B)],N,B)
X,Y=len(G[0]),len(G)
N,M,B=[filter(list,[S(G,s,t,e,lambda a,b:0<=a<X and 0<=b<Y and Y*(a-s)+b-t>=0)for s in R(X)for t in R(Y)])[0][0]for e in["nemo","marlin","bruce"]]
print'\n'.join(''.join(G[y][x]if(x,y)in N+M+min([C([[k]],N,B)[0]for k in M],key=lambda i:len(i))else'.'for x in R(X))for y in R(Y))

परीक्षण के लिए यह (बहुत थोड़ा) कम गोल्फ वाले का उपयोग करें (जो हर टाइल के लिए एक बार पथ की गणना करता है)

G=input().split('\n')
R=range
S=lambda g,x,y,s,B:[[(x,y)]+r for a,b in[(-1,0),(0,-1),(0,1),(1,0)]for r in S(g,x+a,y+b,s[1:],B)if B(x,y)and s[0]==g[y][x]]if s else[[]]
C=lambda l,N,B:[i for i in l if i[-1]in N]or C([i+[(i[-1][0]+c,i[-1][1]+d)]for i in l for c,d in [(-1,0),(0,-1),(0,1),(1,0)]if all(1<abs(i[-1][0]+c-a)or 1<abs(i[-1][1]+d-b)for a,b in B)],N,B)
X,Y=len(G[0]),len(G)
N,M,B=[filter(list,[S(G,s,t,e,lambda a,b:0<=a<X and 0<=b<Y and Y*(a-s)+b-t>=0)for s in R(X)for t in R(Y)])[0][0]for e in["nemo","marlin","bruce"]]
s=N+M+min([C([[k]],N,B)[0]for k in M],key=lambda i:len(i))
print'\n'.join(''.join(G[y][x]if(x,y)in s else'.'for x in R(X))for y in R(Y))

— KSab
स्रोत

पॉली निमो ढूँढना!

मतलाब 560

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

नाम निकालना

रास्ता खोज रहे हैं

अजगर 2 - 658