वैज्ञानिक सील एक हिमखंड पर फंसे

17

परिचय

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

इनपुट विवरण

सील के कार्यक्रम STDIN, कमांड लाइन तर्क, या उपयोगकर्ता इनपुट फ़ंक्शन (जैसे raw_input()) से इनपुट लेंगे । इसे एक चर में प्रचलित नहीं किया जा सकता है (जैसे "यह प्रोग्राम एक चर में इनपुट की उम्मीद करता है x")।

इनपुट की पहली पंक्ति में दो अल्पविराम से अलग पूर्णांक होते हैं 

A,B

इसके बाद Bलाइनों में Aप्रत्येक वर्ण शामिल होता है। प्रत्येक पंक्ति में केवल निम्न में से वर्ण हो सकते हैं:

  • .: ठंडा, ठंडा, सागर। नक्शे में हमेशा यह एक सीमा के रूप में होगा।
  • #: हिमखंड का एक हिस्सा।
  • a... z: एक सील जो आइसबर्ग पर डैडी सील नहीं है।
  • D: आइसबर्ग पर डैडी सील।
  • *: रेडियो ट्रांसमीटर।

(ध्यान दें कि डैडी सील हमेशा अपरकेस के साथ नोट की जाती है D। लोअरकेस dबस एक नियमित सील है।)

आउटपुट विवरण

जवानों को कैसे स्थानांतरित किया जा सकता है, इसके बारे में निम्नलिखित नियमों के अनुसार, रेडियो ट्रांसमीटर के लिए डैडी सील प्राप्त करने के लिए उन्हें कैसे स्थानांतरित करना चाहिए, इस पर जवानों के निर्देशों की एक सूची तैयार करें।

  1. नियम: सभी मुहरें ऊपर ( U), नीचे ( D), बाएं ( L), और दाएं ( R) चल सकती हैं। वे तिरछे स्लाइड नहीं कर सकते।
  2. नियम: हिलने पर, एक सील उसी दिशा में चलती रहेगी जब तक कि वह दूसरी सील से टकराकर या समुद्र में गिर न जाए।
    1. यदि एक सील दूसरे सील से टकराती है, तो वह हिलना बंद कर देगी। इससे जो सील टकराई, वह नहीं हिलेगी।
    2. यदि कोई सील समुद्र में गिरती है, तो वह डूब जाएगी और नक्शे से गायब हो जाएगी। यही है, यह अन्य मुहरों के लिए एक कोलाइडर के रूप में कार्य नहीं करता है और इसे फिर से स्थानांतरित नहीं किया जा सकता है।
  3. नियम: दो मुहरें एक ही समय में नहीं चल सकती हैं, न ही एक सील को स्थानांतरित किया जा सकता है जबकि एक अन्य अभी भी चल रहा है। अगली सील को केवल तभी स्थानांतरित किया जा सकता है जब पिछली सील ने चलना बंद कर दिया हो।
  4. नियम: एक मुहर को कई बार स्थानांतरित करने, या डूबने वाले जवानों की संख्या के बारे में कोई प्रतिबंध नहीं है।
  5. नियम: एक सही समाधान में रेडियो ट्रांसमीटर पर डैडी सील अंत होगा । स्लाइड करते समय डैडी सील केवल ट्रांसमीटर को पास नहीं कर सकता है ।

आउटपुट में कई लाइनें होंगी, जो प्रत्येक फॉर्म में होंगी

A,B

कहाँ Aमुहर (स्थानांतरित करने के लिए है Dपिताजी मुहर के लिए, a... zदूसरों के लिए), और Bदिशा मुहर स्थानांतरित करने के लिए (या तो है U, D, L, या R)। ध्यान दें कि आपको सबसे छोटा मार्ग खोजने की आवश्यकता नहीं है। लक्ष्य के लिए डैडी सील प्राप्त करने वाला कोई भी मार्ग स्वीकार्य आउटपुट है।

उदाहरण इनपुट और आउटपुट

इनपुट:

25,5
.........................
.#######################.
.####D#############*k###.
.#######################.
.........................

आउटपुट:

D,R

इनपुट:

9,7
.........
.a#####b.
.#####d#.
.##l*###.
.###m#p#.
.#D#.#c#.
.........

आउटपुट (कई में से एक संभावित आउटपुट):

m,R
b,L
D,U
D,R
D,D
D,L

इनपुट:

26,5
..........................
.###..................###.
.l*##########v#########D#.
.###..................###.
..........................

आउटपुट (कई में से एक संभावित आउटपुट):

v,D
D,L

यदि आपके कोई अन्य प्रश्न हैं, तो कृपया टिप्पणियों में पूछें।

code-golf 
— चिरायता
स्रोत
क्या सभी इनपुट का एक वैध समाधान होगा? यदि नहीं, तो अपेक्षित आउटपुट / व्यवहार क्या है?
— जियोबिट्स
@Geobits सभी इनपुट के पास एक वैध समाधान होगा। बिना समाधान के इनपुट को अमान्य माना जाता है और आपका प्रोग्राम उनके साथ जो कुछ भी कर सकता है।
— अनुपस्थित
क्या अपवाद को फेंककर कार्यक्रम को समाप्त करना अनुमत है?
— DLosc
2
यदि एक गैर-डैडी सील रेडियो ट्रांसमीटर को हिट करती है तो क्या होगा? क्या यह रुक जाएगा, या इसके माध्यम से आगे बढ़ेगा?
— रेटो कोराडी
1
यह मेरे समाधान को अमान्य करता है। :(
— DLosc

जवाबों:

6

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

R=range
g=[list(input())for i in R(int(input().split(',')[1]))]
f=set(sum(g,[]))-set(".#*")
L=8
def P(p,g):
 if len(p)>L:return
 for s in f:
  c=sum(y.index(s)for y in g if s in y)
  if c<1:continue
  r,=[n for n in R(len(g))if s in g[n]]
  for d in R(4):
   m=p+s+",%s\n"%"LURD"[d];G=[y[:]for y in g];o="#";i,j=I,J=r,c
   while"#"==o:G[i][j]="#";G[I][J]=s;i,j=I,J;I,J=i+d%2*(d-2),j+(~d%-2&d-1);o=G[I][J]
   if"."==o:G[i][j]="#"
   if"D"==s:
    if"."==o:continue
    if"*"==o:print(m);1/0
   P(m,G)
while 1:P("",g);L+=4

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

मैं if G!=g:8-अतिरिक्त बाइट्स के लिए दूसरी-अंतिम पंक्ति की शुरुआत में जोड़कर कोड को बहुत तेजी से चला सकता हूं - यह अस्वीकार करता है कि कुछ भी नहीं बदलता है, जैसे k,Lकि पहले परीक्षण मामले में।

रनटाइम एक इनपुट से दूसरे में भी अलग-अलग होता है, यहां तक ​​कि एक ही इनपुट के साथ - जाहिर तौर पर इस तथ्य का एक परिणाम है कि मैं अगली सील को एक से अधिक पुनरावृत्ति करके स्थानांतरित करने के लिए चुनता हूं set, जो एक अनियंत्रित प्रकार है। मैंने 5 मिनट 30 सेकंड पर दूसरा टेस्ट केस टाइम किया, हालांकि ऐसा नहीं लगा कि पहली बार मैंने इसे चलाया था। ऊपर उल्लिखित अनुकूलन के साथ, यह 40 सेकंड की तरह अधिक है।

— DLosc
स्रोत
1
दिलचस्प रूप से पायथन 2 में इसे हर बार एक ही क्रम देना चाहिए। मुझे लगता है कि उन्होंने कुछ कारनामों से बचने के लिए प्रत्येक रन के लिए प्रत्येक रन पर रैंडमाइज्ड हैश देने के लिए पायथन 3 को बदल दिया : "हैश रैंडमाइजेशन को डिफ़ॉल्ट रूप से सक्षम किया गया है। हैश रेंडमाइजेशन को अक्षम करने के लिए PYTHONHASHSEED पर्यावरण चर को सेट करें। ऑब्जेक्ट भी देखें ।__ हैश __ () तरीका।"
— क्लाउडिया
4

जावास्क्रिप्ट (ईएस 6) 322 334 323

Edit2 स्निपेट में एनीमेशन जोड़ा गया

बग फिक्स को संपादित करें , '*' के शुरुआती पॉज़िटॉन को याद रखें, इसलिए मैं इसे तब भी ढूंढता हूं जब उस पर एक सील स्लाइड होती है और इसे मिटा देती है।

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

एल्गोरिथ्म के लिए: एक बीएफएस, एक इष्टतम समाधान खोजना चाहिए। मैं चर में खेल की स्थिति की एक पंक्ति रखता हूं l, चरित्र ग्रिड की स्थिति gऔर अब तक की चाल का क्रम s। इसके अलावा, चर में अब तक प्राप्त ग्रिड का एक सेट है k, बार-बार एक ही ग्रिड की खोज से बचने के लिए।

मुख्य लूप है

  • एक खेल की स्थिति को समाप्त करें
  • सभी वैध चालों की कोशिश करें, प्रत्येक वैध चाल के बाद स्थिति को समझें (परिणामस्वरूप ग्रिड पहले से मौजूद नहीं है)
  • यदि समाधान मिला तो लूप से बाहर निकलें
F=s=>{
  o=~s.match(/\d+/),g=[...z=s.replace(/.*/,'')];
  for(l=[[g,'']],k=[];[g,s]=l.shift(),!g.some((c,p)=>
      c>'A'&&[-1,1,o,-o].some((d,j)=>{
        t=s+' '+[c,'LRUD'[j]];
        for(q=p;(u=g[q+d])<'.';)q+=d;
        return(c<'a'&z[q]=='*')||
        c>'D'|u>'.'&&!(
          f=[...g],u=='.'?0:f[q]=c,f[p]='#',
          k[h=f.map(v=>v>'D'?0:v)]||(k[h]=l.push([f,t]))
        )
      })
    ););
  alert(t)
}

फ़ायरफ़ॉक्स में परीक्षण करने के लिए स्निपेट चलाएं

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

— edc65
स्रोत
1

सी ++, 628 बाइट्स

खैर, यह बहुत कम नहीं निकला:

#include <set>
#include <iostream>
using namespace std;struct R{string b,m;bool operator<(R r)const{return b<r.b;}};int w,h,t,j,k,z=1;char c,f;set<R> p,q;int m(R r,int x,int d,char a){for(j=x,c=r.b[x];(f=r.b[j+=d])==35;);if(c-68||f-46){r.b[x]=35;if(f-46)r.b[j-d]=c;r.m+=c;r.m+=44;r.m+=a;r.m+=10;if(c==68&j-d==t){cout<<r.m;z=0;}if(p.count(r)+q.count(r)==0){q.insert(r);}}}int main(){cin>>w>>c>>h>>c;R r;string l;for(;k++<h;){getline(cin,l);r.b+=l;}t=r.b.find(42);r.b[t]=35;q.insert(r);for(;z;){r=*q.begin();q.erase(q.begin());p.insert(r);for(k=0;z&&k<w*h;++k){if(r.b[k]>64){m(r,k,-1,76);m(r,k,1,82);m(r,k,-w,85);m(r,k,w,68);}}}}

मैंने C ++ को चुना क्योंकि मैं डेटा संरचनाओं ( set, string) का उपयोग करना चाहता था , लेकिन यह स्वाभाविक रूप से काफी क्रिया है। समाधान प्रदर्शन पर यथोचित रूप से अच्छी तरह से करता है, एक मैकबुक प्रो पर परीक्षण 2 से थोड़ा अधिक 2 सेकंड में हल करता है, भले ही यह रनटाइम के लिए अनुकूलित न हो।

व्हॉट्सएप और कुछ अन्य लंबाई घटाने को शुरू करने से पहले कोड:

#include <set>
#include <iostream>

using namespace std;

struct R {
    string b, m;
    bool operator<(R r) const {return b < r.b; }
};

int w, h, t;
set<R> p, q;
bool z = true;

void m(R r, int k, int d, char a) {
    int j = k;
    char s = r.b[k], f;
    for (; (f = r.b[j += d]) == 35;);
    if (s - 68 || f - 46) {
        r.b[k] = 35;
        if (f - 46) {
            r.b[j - d] = s;
        }
        r.m += s;
        r.m += 44;
        r.m += a;
        r.m += 10;
        if (s == 68 && j - d == t) {
            cout << r.m;
            z = false;
        }
        if (p.count(r) + q.count(r) == 0) {
            q.insert(r);
        }
    }
}

int main() {
    char c;
    cin >> w >> c >> h >> c;
    string b, l;
    int k;
    for (k = 0; k < h; ++k) {
        getline(cin, l);
        b += l;
    }

    t = b.find(42);
    b[t] = 35;

    R r;
    r.b = b;
    q.insert(r);

    for ( ; z; ) {
        r = *q.begin();
        q.erase(q.begin());
        p.insert(r);

        for (k = 0; z && k < w * h; ++k) {
            c = r.b[k];
            if (c > 64) {
                m(r, k, -1, 76);
                m(r, k, 1, 82);
                m(r, k, -w, 85);
                m(r, k, w, 68);
            }
        }
    }

    return 0;
}

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

  • q कॉन्फ़िगरेशन का एक सेट है जो लंबित प्रसंस्करण है।
  • p संसाधित किए गए कॉन्फ़िगरेशन का सेट है।

एल्गोरिथ्म प्रारंभिक कॉन्फ़िगरेशन के साथ शुरू होता है q। हर चरण में, एक कॉन्फ़िगरेशन से पॉपअप किया जाता है q, जोड़ा जाता है p, सभी संभव सील आंदोलनों को उत्पन्न किया जाता है, और परिणामस्वरूप नए कॉन्फ़िगरेशन में डाला जाता है q।

परीक्षण चालन:

bash-3.2$ ./a.out <test1
D,R
bash-3.2$ time ./a.out <test2
p,U
c,U
p,R
c,L
m,L
b,L
a,L
D,U
b,L
D,R
D,D
D,L

real    0m2.267s
user    0m2.262s
sys 0m0.003s
bash-3.2$ ./a.out <test3
v,U
D,L
bash-3.2$
— रेटो कोराडी
स्रोत
'Q' के लिए सेट के बजाय एक कतार का उपयोग करके, आप कम समय में कम समाधान पा सकते हैं (परीक्षण 2 के लिए मेरा समाधान 6 चरण है)।
— edc65
@ edc65 हां, मुझे शुरू में वहां कदमों की संख्या पर आश्चर्य हुआ था। मैंने इसकी पुष्टि करने के लिए यह किया कि यह एक वैध समाधान है। के लिए एक फीफो का उपयोग qनिश्चित रूप से उस अर्थ में बेहतर होगा। मेरे द्वारा सेट का उपयोग करने का कारण यह था कि मैं एक ही प्रविष्टि को कई बार दर्ज करने से बचना चाहता था। लेकिन परिणाम देखने के बाद मैंने दूसरा विचार रखना शुरू कर दिया।
— रेटो कोराडी
प्रदर्शन के अनुसार, आपको पुनरावृत्ति से बचने के लिए एक कतार और एक सेट का उपयोग करना चाहिए। लेकिन सेट में ग्रिड के एक संशोधित संस्करण में डाल दिया, क्योंकि प्रत्येक बच्चे की सील विनिमेय है।
— edc65
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.