आप दुर्घटनाग्रस्त बिना लूप कर सकते हैं?

Question

हम में से बहुत से लोग ट्रॉन खेल से परिचित हैं। आप ग्रिड पर रखे "लाइटसाइकल" को नियंत्रित करते हैं। प्रकाश चक्र हमेशा आगे बढ़ता है (हालांकि आप दिशा को नियंत्रित करते हैं) और इसके पीछे एक स्थायी निशान छोड़ देता है। यदि आप एक निशान में भागते हैं, तो आप दुर्घटनाग्रस्त हो जाते हैं!

यहां लक्ष्य यह निर्धारित करना है कि क्या दिया गया मार्ग वैध लूप है, अर्थात यह "क्रैश" के बिना अपने शुरुआती बिंदु पर लौटता है। ऐसा करने के लिए, हम मानते हैं कि हम बिंदु पर शुरू करते हैं (0,0)। एक इनपुट रूप में दिया जाता N2E1S2W1प्रमुख दिशाओं (की एक श्रृंखला के साथ, Nहै north, Eहै east, और इतने पर), प्रत्येक यात्रा के लिए दूरी उस दिशा का स्थान है। इस उदाहरण में, आप यात्रा करेंगे

N2 : North 2 to (0,2)
E1 : East 1  to (1,2)
S2 : South 2 to (1,0)
W1 : West 1  to (0,0)

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

अन्य उदाहरण:

input        -> output
N1E1S1W1     -> true
N1E1N1E1S2W2 -> true
N1S1E1W1     -> false     // Visits (0,0) 3 times
N4E2S2W4S2E2 -> false     // Visits (0,2) twice
N3E2S3       -> false     // Does not return to (0,0)
N1S1         -> anything  //I don't care how you evaluate this case

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

इनपुट को स्ट्रिंग के रूप में या वर्णों की एक सूची के रूप में लिया जा सकता है, या तो फॉर्म में S1N2E3... या SNNEEE... ग्रिड आकार पर भी कोई कठिन सीमा नहीं है, लेकिन मान लें कि इनपुट कुछ भी ओवरफ्लो करने वाला नहीं है। जब तक कोड मूल रूप से ध्वनि है, तब तक मामलों को संभालना महत्वपूर्ण नहीं है N99999999999999।

ध्यान दें: आप मामलों का मूल्यांकन कर सकते हैं N1S1, E1W1, S1N1, और W1E1फिर भी आप चाहते हैं। वे तकनीकी रूप से मान्य पथ हैं, लेकिन वे चुनौती के "ट्रॉन" भावना के खिलाफ जाते हैं।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर जीतता है!

Comments

N1S1अपनी परिभाषाओं के अनुरूप होना सच होना चाहिए क्योंकि यह (0, 0)दो बार और (0, 1)एक बार पहुंचता है , जो आपकी परिभाषा के तहत वैध है।

— हाइपरनेत्रिनो

मैं ले जा सकते हैं Nके रूप में 1j, Eके रूप में 1, Sके रूप में -1j, और Wके रूप में -1?

— लीक नन

@LeakyNun मुझे लगता है कि मैं इसके साथ ठीक हूं, क्योंकि कमोबेश सभी को कम से कम इस तरह से कुछ भी करना चाहिए जैसे कि हुड। बस यह सुनिश्चित करें कि आप अपने उत्तर में निर्दिष्ट करें।

— लॉर्ड फरक्वाड

@ हैपरनेट्रिनो लेकिन ट्रॉन के दृष्टिकोण से, आपका लाइटसाइकल दो बार (0, 0.5) से गुजरता है, भले ही इनपुट आपको कभी भी ऐसे बिंदु पर न रखे। इसलिए मुझे लगता है कि किसी के पास लचीला आउटपुट है (भले ही अधिकांश भाषाओं के लिए इसे वापस करना आसान होगा)

— वैल्यू इंक

@steenbergh (0,0) कोने में नहीं है, इसलिए आप इसके नीचे या बाईं ओर जा सकते हैं; यहां तक ​​कि अगर तुम दोनों पागल महसूस कर रहे हैं! इसके अलावा, ग्रिड के आकार पर कोई कठिन सीमा नहीं है, लेकिन यह मान लें कि इनपुट कुछ भी ओवरफ्लो करने वाला नहीं है। जब तक कोड मौलिक रूप से ध्वनि है, तब तक मुझे परवाह नहीं है कि क्या यह इनपुट को संभाल नहीं सकता है जैसेN99999999999999

— लॉर्ड फरक्वाड

Answer 1

पायथ , 44 39 बाइट्स

&!eJsM._smm^.j)x"NESW"hdstd:z".\d+"1{IJ

टेस्ट सूट ।

Answer 2

जावास्क्रिप्ट, 247 200 बाइट्स

n=s=>{r=s.match(/\w\d+/g)
x=y=z=0
e=""
for(d of r){a=d[0]
b=d.slice(1)
while(b--){
y+=a=="N"
y-=a=="S"
x+=a=="E"
x-=a=="W"
p=[x,y]+";"
if(~e.indexOf(p))if(!x&!y)z++
else return 0
e+=p}}return!x&!y&!z}

nइनपुट स्ट्रिंग का एक फंक्शन है sजो 1सही और 0गलत के लिए रिटर्न करता है

यहाँ संदर्भ / स्पष्टीकरण के लिए एक ungolfed संस्करण है:

function n(s)
{
    var dir = s.match(/\w\d+/g);
    var x = y = z = 0;
    var been = "";
    for (d of dir)
    {
        var a = d[0];
        var b = 1*d.substring(1);
        while(b-- > 0)
        {
            if (a == "N") y++;
            if (a == "S") y--;
            if (a == "E") x++;
            if (a == "W") x--;
            var pt = [x,y] + ";";
            if (~been.indexOf(pt))
                if (x==0 && y==0)
                    z++;
                else
                    return false;
            been += pt;
        }
    }
    return (x == 0 && y==0 && z == 0);
}

n=s=>{r=s.match(/\w\d+/g)
x=y=z=0
e=""
for(d of r){a=d[0]
b=d.slice(1)
while(b--){
y+=a=="N"
y-=a=="S"
x+=a=="E"
x-=a=="W"
p=[x,y]+";"
if(~e.indexOf(p))if(!x&!y)z++
else return 0
e+=p}}return!x&!y&!z}

console.log(n("N1E1S1W1"))
console.log(n("N1E1N1E1S2W2"))
console.log(n("N1S1E1W1"))
console.log(n("N4E2S2W4S2E2"))
console.log(n("N3E2S3"))

Comments

कुछ

— व्हाट्सएप

ध्यान नहीं दिया, धन्यवाद

— WaffleCohn

ऐसा लगता है कि containsजावास्क्रिप्ट की किसी भी बोली में कोई फ़ंक्शन नहीं है। क्या आप बोली निर्दिष्ट कर सकते हैं?

— लीक नून

मैं अभी परीक्षण करने के लिए क्रोम कंसोल का उपयोग कर रहा था - यह पूरी तरह से वहां काम करता है

— वफ़लकोन

वास्तव में यह मेरे क्रोम कंसोल में भी काम करता है ... लेकिन शायद आप इसे अधिक सार्वभौमिक उत्तर में बदलने पर विचार करेंगे?

— लीक नून

Answer 3

पायथन 3 , 236 161 150 बाइट्स

import re
p=0
a=[]
for i in''.join(s[0]*int(s[1:])for s in re.findall(r".\d+",input())):p+=1j**"NESW".find(i);a+=[p]
print(len({*a})-len(a)==0==a[-1])

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

-75 बाइट्स लीकी नून
-11 बाइट्स की बदौलत लीकी नून की बदौलत या, अगर हमें इनपुट लेने की अनुमति है तो रन लेंथ डिकेड कॉम्प्लेक्स नंबरों की सूची के रूप में:

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

c=0;k=[]
for i in input():c+=i;k+=[c]
print(k[-1]==0==len(set(k))-len(k))

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

-12 बाइट्स मिस्टर एक्सकोडर / -9 बाइट्स की बदौलत लीक नून (एक एडिट में विलीन) के लिए धन्यवाद

यह मुझे बहुत लंबा लगता है

Comments

जब तक यह पाइथ समाधान से 10 गुना कम है, तब तक यह बहुत लंबा नहीं है।

— लीक नन

@ लिकेन नन लोल ओके: पी

— हाइपरएनुट्रीनो

161 बाइट्स

— लीकी नून

@LeakyNun ओह स्नैप अच्छा। बहुत लंबा देखें, जैसा कि मैंने कहा: पी

— हाइपरएनुट्रीनो

76 बाइट्स

— लीकी नून

Answer 4

जेली , 14 12 बाइट्स

Œṙ+\µQ⁼ȧṛ/¬$

यह मेरी पहली बार जेली में गोल्फ है। सुझावों का स्वागत है।

इनपुट [direction, distance]जोड़े की एक सरणी के रूप में है , जहां दिशा एक जटिल संख्या के रूप में दी गई है।

स्पष्टीकरण:

Œṙ+\µÇȧṛ/¬$   Main link. Argument: n     = [[i, 3], [1, 2], [-i, 3]]
Œṙ            Run-length decode          = [i, i, i, 1, 1, -i, -i, -i]
  +\          Cumulative sum             = [i, 2i, 3i, 3i+1, 3i+2, 2i+2, i+2, i]
    µ         Begin a new monadic chain
     Q        Remove duplicates          = [i, 2i, 3i, 3i+1, 3i+2, 2i+2, i+2]
      ⁼       Equal to original?         = 0
           $  Make a monadic link:
        ṛ/      Reduce by right argument   = i
                (Gets the last element)
          ¬     Logical NOT:               = 0
       ȧ      Logical AND the two values = 0

Comments

पिछले मामले को विफल करना चाहिए।

— लीक नून

Answer 5

रेटिना , 86 बाइट्स

\d+
$*
1(1*)
$1
+`(.)1
$1$1
.
 $`$&¶
%O`.
+`NS|E(.*)W
$1
M`\w$|(?m)(^.+$)(?s).+^\1$
^0

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

\d+
$*

संख्याओं को एकात्मक में बदलें।

1(1*)
$1
+`(.)1
$1$1

रन-लेंथ अक्षरों को डीकोड करते हैं। N111में बदलने की जरूरत है NNN, इसलिए प्रत्येक को प्रत्येक संख्या से घटाया जाता है और फिर प्रत्येक 1 पिछले अक्षर को दोहराता है।

.
 $`$&¶

अलग-अलग लाइनों के रूप में सभी उपसर्गों (पथ पर अंक) उत्पन्न करें। रिक्त स्थानों के साथ समस्याओं से बचने के लिए एक स्थान उपसर्ग है।

%O`.
+`NS|E(.*)W
$1

प्रत्येक पंक्ति के सभी अक्षरों को क्रम में क्रमबद्ध करें और फिर मिलान जोड़े को हटा दें। हम ग्रिड पर किसी भी बिंदु के लिए एक अद्वितीय कोड के साथ समाप्त होते हैं।

M`\w$|(?m)(^.+$)(?s).+^\1$

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

^0

परिणाम उलटा।

Answer 6

पर्ल, 140

स्ट्रिंग इनपुट के साथ काम करता है। शायद मैं सरणी के साथ छोटा कर सकता हूं, लेकिन मुझे संदेह है। किसी भी आगे गोल्फ मदद के लिए खुश :)

sub w{$i=$_[0];%d=(E,[0],S,[1,-1],W,[0,-1]);$i=~s/(.)(.)/($d,$o)=(@{$d{$1}},1,1);for(1..$2){$s[$d]+=$o;$r+=$d{"@s"}++}/eg;!($s[0]+$s[1]+$r)}