रोटेशन क्रम की मैनहट्टन दूरी

Question

हालाँकि, यह एक अच्छी चुनौती होगी: http://adventofcode.com/2016/day/1

कार्य विवरण

पैटर्न (L। R) [1-9] [0-9] * के बाद घुमाव और दूरी के अनुक्रम को देखते हुए, मैनहट्टन को शुरुआत और अंत बिंदुओं के बीच की दूरी दें, जो कि ऊर्ध्वाधर और क्षैतिज चालों की न्यूनतम संख्या है ग्रिड।

उदाहरण

उदाहरण के लिए, अगर हम मान लें कि आपने उत्तर का सामना करना शुरू कर दिया है:

R2 के बाद, L3 आपको 2 ब्लॉक पूर्व और 3 ब्लॉक उत्तर या 5 ब्लॉक दूर छोड़ देता है। आर 2, आर 2, आर 2 आपको 2 ब्लॉक छोड़ देता है जो आपके शुरुआती स्थान के दक्षिण में है, जो 2 ब्लॉक दूर है। R5, L5, R5, R3 आपको 12 ब्लॉक दूर छोड़ते हैं।

तकनीकी जानकारी

आप चाल के बीच विभाजक चुन सकते हैं (जैसे: "\ n", ",", या ",")। आपको आधार 10 में पूर्णांक के रूप में उत्तर देना होगा।

डुप्लिकेट नहीं!

यह कई कारणों से डुप्लिकेट नहीं है:

• चालें समान नहीं हैं। यहां वे रोटेशन हैं , दिशा नहीं।
• मुझे मैनहट्टन दूरी चाहिए, यूक्लिडियन नहीं।

Comments

आपको अपने प्रश्न में मैनहट्टन की दूरी क्या है, इसका विवरण शामिल करना चाहिए। बस एक लिंक पोस्ट करना एक तरह से समझौता है।

— गैब्रियल बेनामी

यह बहुत अलग है ! हमारे पास केवल रोटेशन है!

— लैबो

@ लाबो मैं सहमत हूँ। यह इस तथ्य के बारे में नहीं है कि यहां उत्तर मैनहट्टन दूरी में है, जबकि दूसरा यूक्लिडियन दूरी में है। इसमें कछुआ शैली की गति है, जबकि दूसरा कम्पास दिशाओं को निर्दिष्ट करता है NSEW (तथ्य यह है कि यह उन्हें यूडीएलआर कहता है अप्रासंगिक है।)

— लेवल रिवर सेंट

मुख्य साइट पर पोस्ट करने से पहले अपनी चुनौतियों पर प्रतिक्रिया प्राप्त करने के लिए कृपया भविष्य में सैंडबॉक्स का उपयोग करें ।

— Mego

@ लाबो ठीक है, हम नए उपयोगकर्ताओं से इस साइट के सभी ins और बहिष्कार को तुरंत जानने की उम्मीद नहीं करते हैं। यह अगली बार के लिए सिर्फ एक सौम्य सुझाव है। :)

— Mego

Answer 1

पायथन 3, 109 99 104 101 बाइट्स

यह एक सरल उत्तर है जो जटिल संख्याओं का उपयोग करता है, एक अंतरिक्ष-पृथक स्ट्रिंग या एक नई-लाइन-अलग स्ट्रिंग के रूप में इनपुट के साथ। गोल्फ सुझाव आपका स्वागत है!

संपादित करें: -13 बाइट्स लाबो के लिए धन्यवाद। एक इंट में परिवर्तित करने के लिए +5 बाइट्स।

d=p=0
for r in input().split():d+=1-2*(r<'R');p+=1j**d*int(r[1:])
print(int(abs(p.real)+abs(p.imag)))

Ungolfing

def manhattan_rotation(seq, nsew=0, pos = 0):
    for rot in seq.split():
        # change direction
        if rot[0] == "L":
            nsew += -1 
        else:
            nsew += 1
        # move in that direction rot[1:] times
        pos += 1j ** nsew * int(rot[1:])
    return int(abs(pos.real)+abs(pos.imag))

Comments

1-2 * (r [0] <'R') आपको 2 बाइट्स बचाएगी :)

— Labo

एक फ़ंक्शन न करें, इनपुट से पढ़ने से आप अधिक वर्ण बचा सकते हैं!

— लाबो

2 बाइट्स बचाने के लिए एक ही पंक्ति में 2 चर असाइन करें: d = p = 0

— Labo

मैंने आपका जवाब फिर से दिया और यह 99 वर्ण बनाता है! pastie.org/private/hm7lejqosdqnkgo000u7q

— Labo

@ लाबो मुझे यकीन नहीं है कि आप विनिर्देश को इस तरह से संपादित कर सकते हैं जो मौजूदा उत्तरों को अमान्य कर देगा, लेकिन मुझे कुछ मॉड्स पूछने दें।

— शर्लक

Answer 2

PHP, 93 बाइट्स

while($m=$argv[++$i])${chr(80|3&$d+=(P<$m)-(M>$m))}+=substr($m,1);echo abs($P-$R)+abs($Q-$S);

टूट - फूट

while($m=$argv[++$i])       // loop through arguments:
    ${                      // 5. use as variable name
        chr(                // 4. cast to character (P,Q,R,S) 
        80|                 // 3. add 80
        3&                  // 2. modulo 4
        $d+=(P<$m)-(M>$m)   // 1. change direction depending on letter
    )}+=substr($m,1);       // 6. add number to variable
echo abs($P-$R)+abs($Q-$S); // calculate distance, print

Answer 3

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

x=y=0
for d in input().split():c=cmp(d,'M');x,y=int(d[1:])-y*c,x*c
print abs(x)+abs(y)

वर्तमान को ट्रैक करता है xऔर yनिर्देशांक करता है। जब मोड़, दिशा को अद्यतन करने के बजाय, वर्तमान मूल्य को घुमाता है ताकि गति हमेशा एक्स-पॉजिटिव दिशा में हो। निर्देशांक निकालने के लिए जटिल संख्या बहुत महंगी थी।

Answer 4

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

l=c=0
for i in input().split():c+=cmp(i[0],'N');l+=1j**c*int(i[1:])
print int(abs(l.imag)+abs(l.real))

repl.it

इनपुट अंतरिक्ष सीमांकित दिशाओं की एक स्ट्रिंग है, जैसे "R5 L5 R5 R3"।
शुरुआती स्थान और गंतव्य के बीच मैनहट्टन की दूरी प्रिंट करता है।

कैसे?

जटिल विमान के मूल में शुरू होता है l=0;

एक संचयी क्वार्टर-राइट टर्न काउंटर के साथ c=0;

प्रत्येक निर्देश के लिए, iरोटेशन को पार्स किया जाता है, चरित्र के लिए दिशा के पहले चरित्र की तुलना करके 'N', और cतदनुसार समायोजित किया जाता है।

यात्रा करने के लिए दूरी के साथ पार्स किया जाता है int(i[1:])और निर्देश दिया जाता है कि cवें शक्ति के 0+1jसाथ ले कर दिए गए दिशा में कई ब्लॉक आकार के कदम उठाते हैं 1j**c।

अंतिम मैनहट्टन की दूरी दो दिशाओं में मूल से पूर्ण दूरी का योग है - काल्पनिक और वास्तविक; के साथ हासिल कियाabs(l.imag)+abs(l.real)

Comments

@ शर्लक 9 - ओह, उम उत्तर अभिसरण। पायथन 2 पर स्विच करके 2 बाइट्स सहेजें और cmpमेरे उत्तर की तरह उपयोग करें , मुझे बताएं और मैं हटा दूंगा।

— जोनाथन एलन

Answer 5

जावास्क्रिप्ट (ES2016), 98 100

2 बाइट्स ने @ xeil को बचाया

d=>d.replace(/.(\d+)/g,(d,l)=>(o+=d>'M'||3,l*=~-(o&2),o&1?x-=l:y+=l),x=y=o=0)&&(x*x)**.5+(y*y)**.5

ईएस 6 के लिए 100 बाइट्स

d=>d.replace(/.(\d+)/g,(d,l)=>(o+=d>'M'||3,l*=~-(o&2),o&1?x-=l:y+=l),x=y=o=0)&&(x>0?x:-x)+(y>0?y:-y)

कम गोल्फ वाला

d => d.replace(/.(\d+)/g,
  (d,l)=>( // L or R in d, distance in l
    o += d>'M' || 3, // orientation in o, used %4
    l *= ~-(o&2), // convert to number and change sign if needed
    o&1 ? x -= l : y += l // move based on orientation
  ), x = y = o = 0)
&& (x>0?x:-x) + (y>0?y:-y)

टेस्ट (ES6)

F=
d=>d.replace(/.(\d+)/g,(d,l)=>(o+=d>'M'||3,l*=~-(o&2),o&1?x-=l:y+=l),x=y=o=0)&&(x>0?x:-x)+(y>0?y:-y)

function update() {
  O.textContent=F(I.value)
}

update()

<input id=I value='R5, L5, R5, R3' oninput='update()'><pre id=O></pre>

Comments

मेरा ES6 जवाब मूल रूप से 106 बाइट्स था; अपने मध्यवर्ती चर की नकल करने से मुझे 3 बाइट्स की बचत हुई; मैच से अपने प्रतिस्थापन पर स्विच करने से मुझे 2 बाइट्स की बचत हुई, और उसी समय आपकी प्रोसेसिंग की दिशा और दूरी को कॉपी करते हुए मुझे एक अंतिम बाइट से बचाया, जिसके परिणामस्वरूप: s=>s.replace(/.(\d+)/g,(c,n)=>(d+=c<'R'||3,n*=~-(d&2),d&1?x+=n:y+=n),x=y=d=0)&&(x<0?-x:x)+(y<0?-y:y)अब आपके ES6 उत्तर की तुलना में दो बाइट्स कम हैं, c<'R'||3और n*=~-(d&2)ट्रिक्स के लिए धन्यवाद ।

— नील