एक हेक्सागोनल ग्रिड पर गति

Question

हेक्सागोनल ग्रिड पर आंदोलनों का प्रतिनिधित्व करने वाले पात्रों की एक श्रृंखला के इनपुट को देखते हुए, "सूचक" के अंतिम निर्देशांक का उत्पादन करता है।

हमारे हेक्सागोन्स को ऐसे ही गिना जाएगा (प्रत्येक विषम-संख्या वाले स्तंभ के साथ एक आयताकार ग्रिड को थोड़ा नीचे स्थानांतरित करने की कल्पना करें):

  _____         _____         _____         _____
 /     \       /     \       /     \       /     \
/ -3,-2 \_____/ -1,-2 \_____/  1,-2 \_____/  3,-2 \
\       /     \       /     \       /     \       /
 \_____/ -2,-1 \_____/  0,-1 \_____/  2,-1 \_____/
 /     \       /     \       /     \       /     \
/ -3,-1 \_____/ -1,-1 \_____/  1,-1 \_____/  3,-1 \
\       /     \       /     \       /     \       /
 \_____/ -2,0  \_____/  0,0  \_____/  2,0  \_____/
 /     \       /     \       /     \       /     \
/ -3,0  \_____/ -1,0  \_____/  1,0  \_____/  3,0  \
\       /     \       /     \       /     \       /
 \_____/ -2,1  \_____/  0,1  \_____/  2,1  \_____/
 /     \       /     \       /     \       /     \
/ -3,1  \_____/ -1,1  \_____/  1,1  \_____/  3,1  \
\       /     \       /     \       /     \       /
 \_____/       \_____/       \_____/       \_____/

सूचक (0, 0) से शुरू होता है।

आपके द्वारा समर्थित निर्देश निम्नानुसार हैं:

• q: ऊपर-बाएँ
• w: बढ़ाना
• e: ऊपर-नीचे करो
• a: नीचे-बाएँ
• s: नीचे की ओर
• d: नीचे की ओर बढ़ना
• r: ग्रिड क्लॉकवाइज घुमाएं
• R: ग्रिड वामावर्त घुमाएँ

एक ही निर्देशांक पर सूचक को रखते हुए रोटेशन कमांड पूरे ग्रिड को घुमाते हैं। (क्यों qweasd? वे QWERTY कीबोर्ड पर अच्छी तरह से दिशाओं से मेल खाते हैं।)

यह कल्पना करने में मदद करने के लिए, यहां आंदोलन के आदेश क्या करेंगे, सूचक को बीच में शुरू होता है:

         _____
        /     \
  _____/   w   \_____
 /     \       /     \
/   q   \_____/   e   \
\       /     \       /
 \_____/       \_____/
 /     \       /     \
/   a   \_____/   d   \
\       /     \       /
 \_____/   s   \_____/
       \       /
        \_____/

एक दक्षिणावर्त रोटेशन ( r) के बाद, कमांड्स को रीमेक किया जाता है (इसे पूरे हेक्स ग्रिड को घुमाने के रूप में कल्पना करें लेकिन फिर भी "डब्ल्यू" को ऊपर रखते हुए, आदि, जो निम्नलिखित के बराबर है):

         _____
        /     \
  _____/   e   \_____
 /     \       /     \
/   w   \_____/   d   \
\       /     \       /
 \_____/       \_____/
 /     \       /     \
/   q   \_____/   s   \
\       /     \       /
 \_____/   a   \_____/
       \       /
        \_____/

इसी तरह, काउंटरकॉलवाइज ( R) को घुमाने के बाद ग्रिड को सामान्य में लौटाया जाएगा, और काउंटरक्लॉकवाइज को फिर से घुमाकर "रीमैप" qwedsaकिया जाएगा aqweds।

इनपुट को एक स्ट्रिंग के रूप में दिया जाना चाहिए, और आउटपुट या तो किसी भी गैर-संख्यात्मक वर्ण (पूर्व। 1 2या 3,4) या पूर्णांकों की एक सरणी से जुड़ने वाला एकल स्ट्रिंग हो सकता है ।

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीत जाएगा।

परीक्षण के मामलों:

In                         Out
---------------------------------
edeqaaaswwdqqs             -2, 0
dddddddddd                 10, 5
wswseaeadqdq               0, 0
<empty string>             0, 0
esaaqrweesrqrq             -1, 0
wrwrwrwrw                  -1, 0
RRssrrrs                   -1, -1
aRRRRwddrqrrqqq            -1, -4
rrrrrrrrrrrrRRRRRRrrrrrrq  -1, -1
rrRrRrrRrrrrRRrRrRR        0, 0

Answer 1

पायथ, 81 बाइट्स

J_K1=Y"qwedsa"A,ZZFNz=kxYN ?<kZ=Y?<x\rNZ.>Y1.<Y1A,+G@[JZ1KZJ)k+H@[J_2JK2K)k;,G/H2

आउटपुट निर्देशांक का प्रतिनिधित्व करने वाले पूर्णांकों की एक सूची है।

मेरा समाधान वास्तव में उबाऊ है; यह केवल एक सरणी ( qwedsa) में इनपुट किए गए वर्ण को देखता है , और फिर दो सरणियों तक पहुंचता है जो निर्देशांक में संबंधित परिवर्तनों का प्रतिनिधित्व करते हैं। उदाहरण के लिए, यदि इनपुट है w, तो हमें 1 मिलता है (क्योंकि यह सरणी में दूसरा वर्ण है)। तब हम जोड़ने A[1]के लिए x(जहां Aमें परिवर्तन के लिए सरणी है xऔर विभिन्न आदानों के संबंध में) B[1]करने के लिए y(जहां Bके लिए परिवर्तन है y)। rऔर Rकेवल qwedsaसरणी को घुमाकर हासिल किया जाता है ।

मुझे यकीन है कि कोई भी पाइथ का उपयोग करके बेहतर कर सकता है। मैं हालांकि मेरे जवाब गोल्फ की कोशिश जारी रखेंगे!

आप इसे यहाँ आज़मा सकते हैं ।

Answer 2

रेटिना , 353 339 178 175 150 130 129 117 बाइट्स

R
5$*r
T`aq\we\ds`so`r.+
)`r(.*)
$1
^
:
a
sq
e
wd
+`(.+)q
w$1
+`(.+)d
s$1
+`sw

(.*)(\1w?):
$0$2
+`sw|ws

w+
-$0
\w
1

आउटपुट एकात्मक में है, एक बृहदान्त्र द्वारा अलग किया गया है। इसका मतलब है कि आप वास्तव में आउटपुट में शून्य नहीं देखेंगे (हालांकि एक बृहदान्त्र की उपस्थिति आपको बताएगी कि दोनों में से कौन सा निर्देशांक शून्य है, अगर केवल एक है)।

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

यह वास्तव में मजेदार था और आश्चर्यजनक रूप से कम हो गया। :)

व्याख्या

पहले कुछ पृष्ठभूमि। हेक्सागोनल ग्रिड का वर्णन करने के लिए कई समन्वय प्रणाली हैं। एक ऑफसेट निर्देशांक का उपयोग करने के लिए कहा। यह अनिवार्य रूप से आयताकार ग्रिड के निर्देशांक की तरह है, सिवाय इसके कि एक अक्ष "वॉबल्स" को थोड़ा सा। विशेष रूप से, प्रश्न "विषम-क्यू" लेआउट के लिए लिंक किए गए पृष्ठ पर दिखाया गया है। यह समन्वय प्रणाली के साथ काम करने के लिए थोड़ा कष्टप्रद है, क्योंकि एक चाल के दौरान निर्देशांक कैसे बदलते हैं यह न केवल कदम की दिशा पर निर्भर करता है, बल्कि वर्तमान स्थिति पर भी निर्भर करता है।

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

तो यहां हम क्या करेंगे: हम अक्षीय निर्देशांक में आंदोलन की गणना करते हैं (रोटेशन का ख्याल रखना, जैसा कि चुनौती में सुझाव दिया गया है, आज्ञाओं के अर्थ को हटाकर), और जब हमने किया है तो हम अक्षीय को विषम-क्यू ऑफसेट में बदल देते हैं निर्देशांक।

अक्षीय निर्देशांक (xz) में निम्नलिखित डेल्टा वैक्टर के लिए छह चालों का नक्शा:

q => (-1,  0)
w => ( 0, -1)
e => ( 1, -1)
d => ( 1,  0)
s => ( 0,  1)
a => (-1,  1)

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

:इनपुट के सामने अक्षीय एक्स और जेड घटकों को बाईं और दाईं ओर (एक विभाजक के रूप में) बनाने की योजना है । wऔर sदाईं ओर जोड़ देगा। qऔर dबाएं ओर करने के लिए जोड़ देगा, और eऔर aदोनों पक्षों के लिए जोड़ देगा। चूंकि wऔर sपहले से ही :(जो सामने जाएगा) के दाईं ओर है , हम क्रमशः उन -1और +1अंकों के रूप में उपयोग करेंगे ।

कोड के माध्यम से चलते हैं।

R
5$*r

हम प्रत्येक Rको पाँच rएस में बदलकर शुरू करते हैं । बेशक, एक लेफ्ट टर्न एक हेक्स ग्रिड पर पांच राइट टर्न के समान है, और ऐसा करके हम रीमैपिंग स्टेप पर बहुत अधिक दोहराव कर सकते हैं।

T`aq\we\ds`so`r.+

यह एक लिप्यंतरण चरण है जो छह कमांडों को घुमाता है, यदि वे पहले के बाद पाए जाते हैं r(इस प्रकार पहले प्रसंस्करण करते हैं r)। wऔर dउन्हें चरित्र वर्गों में विस्तार से रोकने के लिए भागने की जरूरत है। oलक्ष्य सेट जो इन कार्यों के लिए रोटेशन बाइट्स के एक झुंड की बचत होती है में स्रोत सेट सम्मिलित करता है। चरित्र मानचित्रण इसलिए है:

aqweds
saqweds

जहाँ sदूसरी पंक्ति में अंतिम को अनदेखा किया जा सकता है।

)`r(.*)
$1

यह rस्ट्रिंग से पहले को हटा देता है , क्योंकि यह संसाधित किया गया है (काश मैं पहले से ही प्रतिस्थापन सीमाएं लागू कर चुका होता ...)। )रेटिना को यह भी बताता है कि जब तक स्ट्रिंग बदलना बंद न हो जाए, तब तक यह सभी चरणों को एक लूप में चलाता है। बाद के पुनरावृत्तियों पर, पहला चरण एक ऑप-ऑप है क्योंकि कोई भी अधिक Rएस नहीं हैं और दूसरा चरण तब तक एक और रोटेशन लागू करेगा जब तक rकि स्ट्रिंग में शेष नहीं हो जाते ।

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

^
:

सामने पर समन्वित सीमांकक डालें।

अब हम वास्तव में कार्रवाई करने के लिए की जरूरत नहीं है sऔर w। वे हमारे +1और -1अंक हैं और वे पहले से ही सही हैं, :इसलिए वे अंत में आवश्यक रूप से छोड़ देंगे। हम एक और सरलीकरण कर सकते हैं: aबस है s + qऔर eहै w + d। चलो करते हैं:

a
sq
e
wd

फिर से, उन sऔर wबाहर छोड़ देंगे। हमें बस की जरूरत है उन लोगों के लिए कदम है qऔर dसामने से रों और उन्हें में बदल जाते हैं wऔर sखुद को है। हम दो अलग छोरों के साथ करते हैं:

+`(.+)q
w$1
+`(.+)d
s$1

तो हो गया। निर्देशांक से ऑफसेट करने के लिए अक्षीय से रूपांतरण के लिए समय। उसके लिए हमें अंकों को समाप्‍त करना होगा। हालाँकि, अब हम केवल बाएं हाथ की ओर ध्यान रखते हैं। जिस तरह से हमने qएस और dएस को संसाधित किया है , हम जानते हैं कि sबाएं हाथ में सभी एस किसी भी wएस के सामने दिखाई देंगे , इसलिए हमें केवल उन्हें गिराने के लिए एक जोड़ी की जांच करने की आवश्यकता है:

+`sw

अब वास्तविक रूपांतरण। यहाँ pseudocode, ऊपर दिए गए लिंक से लिया गया है:

# convert cube to odd-q offset
col = x
row = z + (x - (x&1)) / 2

दाएं, इसलिए बाएं हाथ की तरफ पहले से ही सही है। दाएं हाथ की ओर (x - (x&1)) / 2हालांकि सुधार अवधि की आवश्यकता है । लेना &1मोड्यूलो 2 के समान है। यह मूल रूप x/2से पूर्णांक विभाजन, माइनस इनफिनिटी की ओर गोल होता है। तो सकारात्मक के लिए x, हम अंकों की आधी संख्या (नीचे की ओर) जोड़ते हैं, और नकारात्मक के लिए x, हम अंकों की आधी संख्या (पूर्णांक) को घटाते हैं। यह regex में आश्चर्यजनक रूप से स्पष्ट रूप से व्यक्त किया जा सकता है:

(.*)(\1w?):
$0$2

लालच के कारण, यहां तक ​​कि x, समूह 1 बिल्कुल आधे अंकों से मेल खाएगा, \1अन्य आधा और हम इसे अनदेखा कर सकते हैं w?। हम उस के बाद आधा डालें :(जो है x/2)। यदि समान xहै, तो हमें सकारात्मक और नकारात्मक में अंतर करने की आवश्यकता है। यदि xसकारात्मक है, तो w?कभी मेल नहीं खाएगा, इसलिए दोनों समूहों को अभी भी समान अंकों का मिलान करना होगा। यह कोई समस्या नहीं है अगर पहली sबस छोड़ दी जाती है, तो हम गोल हो जाते हैं। यदि xनकारात्मक और विषम है, तो संभव मैच \1( xगोल नीचे का आधा ) और उस वैकल्पिक के साथ है w। चूंकि वे दोनों समूह में जाते हैं 2, हम x/2परिमाण के साथ लिखेंगे (आवश्यकतानुसार)।

+`sw|ws

अब हम दायीं ओर के अंकों को समाप्‍त करते हैं। इस बार, हमें आदेश का पता नहीं है sऔर wइसलिए हमें दोनों जोड़ियों का हिसाब देना होगा।

w+
-$0

दोनों भागों को अब एक ही दोहराया अंक (या कुछ नहीं) के लिए कम कर दिया जाता है। यदि वह अंक है w, तो हम सामने एक ऋण चिह्न डालते हैं।

\w
1

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

Comments

(क्या मैं एकमात्र ऐसा व्यक्ति हूं जिसने इस उत्तर को मुख्य साइट पृष्ठ पर देखा और प्रिय को उम्मीद थी कि यह हेक्सागोनी में लिखा गया था?)

— एडिसन क्रंप

@FlagAsSpam इस समुदाय की मांग गंभीरता से बढ़ रही है जब 8 लोगों (और गिनती) को निराश करना संभव है, एक हस्ताक्षरित पूर्णांकों और हेक्सागोनल ग्रिड से जुड़ी एक चुनौती को हल करने के लिए एक भाषा के साथ जो केवल इनपुट के माध्यम से अपने इनपुट को संसाधित कर सकती है। ;)

— मार्टिन एंडर

Answer 3

पायथन (3.5) 193 185 182 बाइट्स

मैं अक्षीय निर्देशांक में भी गणना करता हूं और अंत में परिवर्तित करता हूं ।

मैं @Martin Büttner समाधान के अनुसार कुछ अनुकूलन जोड़ता हूं: मैं R को r * 5 से प्रतिस्थापित करता हूं, यह बाइट्स की संख्या को नहीं बदलता है। लेकिन इस बदलाव के साथ हम दूसरे टेस्ट की जगह ले सकता elif j=='r'है बस द्वाराelse

समाधान यह मानता है कि इनपुट में हमारे पास अमान्य वर्ण नहीं हो सकते।

def f(i):
 x=y=0;u=-1,0,-1,1,0,1,1,0,1,-1,0,-1;v='dewqas'
 for j in i.replace('R','r'*5):
  w=v.find(j)*2
  if-1<w:x+=u[w];y+=u[w+1]
  else:u=u[2:]+u[:2]
 print(-x,-x-y+(x-(x%2))/2)

Ungolfed

def f(i):
  x=y=0
  u=-1,0,-1,1,0,1,1,0,1,-1,0,-1    # operations list xd,yd,xe,ye...
  v='dewqas'                       # letters list in clockwise order 
  i.replace('R','r'*5)             # replace 'R' by 5*'r'
  for j in i:
    w=v.find(j)*2                  # extract letter index
    if-1<w:
      x+=u[w]                      # apply operations
      y+=u[w+1]
    else:
      u=u[2:]+u[:2]                # rotate clockwise the operation string
  print(-x,-x-y+(x-(x%2))/2)       # convert coordinates axial to "odd-q"

प्रयोग

>>> f('wrwrwrwrw')
-1 0.0
>>> f('dddddddddd')
10 5.0
>>> f('edeqaaaswwdqqs')
-2 0.0

Answer 4

बैच, 708 636 586 569 बाइट्स

मैंने दोगुना y-निर्देशांक का उपयोग किया क्योंकि यह गणित को सरल बनाता था। मुझे यकीन नहीं है कि मैंने रोटेशन को सबसे आदर्श तरीके से ध्यान में रखा, लेकिन यह rएस की संख्या की गणना करता है ।

संपादित करें: Rs की हैंडलिंग पर सुधार करके 72 बाइट्स सहेजे गए । मेरे set/aबयानों को अनुकूलित करके 60 बाइट्स बचाए । कुछ मामूली आशाओं के साथ 17 बाइट्स बचाए।

@echo off
set m=%1
set/ay=x=0
set r=r
set g=goto l
:l
set/a"z=y>>1
if "%m%"=="" echo %x% %z%&exit/b
set c=%m:~0,1%
set m=%m:~1%
goto %r:rrrrrr=%%c%
:a
:rq
:rrw
:rrre
:rrrrd
:rrrrrs
set/ax-=2
:w
:re
:rrd
:rrrs
:rrrra
:rrrrrq
set/ax+=1,y-=1
%g%
:q
:rw
:rre
:rrrd
:rrrrs
:rrrrra
set/ay-=2
%g%
:s
:ra
:rrq
:rrrw
:rrrre
:rrrrrd
set/ax-=2
:e
:rd
:rrs
:rrra
:rrrrq
:rrrrrw
set/ax+=+1,y+=1
%g%
:d
:rs
:rra
:rrrq
:rrrrw
:rrrrre
set/ay+=2
%g%
:r
:rr
:rrr
:rrrr
:rrrrr
:rrrrrr
if %c%==R set c=rrrrr
set r=%c%%r%
%g%

Answer 5

05AB1E , 60 बाइट्स

.•F?äM•U2Å0IvXy'rQiÀUëy'RQiÁUëykÐ5α‚ßsD3%_s3›·+‚<+]Ć`DÉ-2÷+‚

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

सामान्य स्पष्टीकरण:

हम एक स्ट्रिंग "qwedsa"और एक समन्वय के साथ शुरू करते हैं [0,0], और इनपुट के पात्रों पर लूप करते हैं।
यदि यह एक "आर" या "आर" है, तो हम इस स्ट्रिंग को क्रमशः बाईं या दाईं ओर घुमाते हैं।
यदि नहीं, तो हमें इस स्ट्रिंग में 0-आधारित इंडेक्स मिलता है, और इसे निम्नानुसार मैप करें:

q → 0 → [-1,  0]
w → 1 → [ 0, -1]
e → 2 → [ 1, -1]
d → 3 → [ 1,  0]
s → 4 → [ 0,  1]
a → 5 → [-1,  1]

हमें सूचकांक-अंकों को निम्नलिखित में बदलना होगा $x$ तथा $y$ निर्देशांक:

 x   indices     y   indices
-1 ← 0;5        -1 ← 1;2
 0 ← 1;4         0 ← 0;3
 1 ← 2;3         1 ← 4;5

हम सूचकांक को परिवर्तित करके ऐसा करते हैं $k$ निम्नलिखित नुसार:

$x = min(k, abs(k-5))-1$
$y = (0\equiv k\pmod3) + 2(k\gt3) - 1$

और पूरे लूप के बाद, हमें ऑफ-सेट को ठीक करना होगा $y$के आधार पर-समन्वित $x$-कॉर्डिनेट, जो हम इस तरह करते हैं ($x$ एक ही रहता है):

$y=y+\lfloor\frac{x-x\pmod2}{2}\rfloor$

कोड स्पष्टीकरण:

.•F?äM•         # Push compressed string "qwedsa"
       U        # Pop and store it in variable `X`
2Å0             # Push list [0,0]
                # (many 3-byte alternatives for this: `00S`; `т¦S`; `0D‚`; `1¾‰`; etc.)
   Iv           # Loop over each character `y` of the input:
     X          #  Push string `X`
      y'rQi    '#  If `y` equals "r":
           À    #   Rotate string `X` once towards the left
            U   #   And pop and store it as new value for `X`
      ëy'RQi   '#  Else-if `y` equals "R":
            ÁU  #   Do the same, but rotate right instead
      ë         #  Else:
       yk       #   Get the 0-based index of `y` in the string `X`
         Ð      #   Triplicate this index
          5α    #   Take the absolute difference with 5
            ‚ß  #   Pair it with the original index, and pop and push the minimum
                #   (maps 0→[0,5]→0; 1→[1,4]→1; 2→[2,3]→2;
                #         3→[3,2]→2; 4→[4,1]→1; 5→[5,0]→0)
         sD     #   Swap to get the original index again, and duplicate it
           3%   #   Take modulo 3
             _  #   And check if it's equals to 0 (1 if truthy; 0 if falsey)
          s3›   #   Swap to take the index again, and check if it's larger than 
                #   (again, 1 if truthy; 0 if falsey)
             ·  #   Double this
          +     #   And add both checks together
                #   (maps 0→1+0→1; 1→0+0→0; 2→0+0→0;
                #         3→1+0→1; 4→0+2→2; 5→0+2→2)
         ‚      #   Pair both mapped values together
          <     #   Decrease both by 1, so it becomes: 0→-1; 1→0; 2→1
           +    #   And add it to the current coordinates
    ]           # After the loop with inner if-else statements:
     Ć          # Enclose the coordinate, appending its own head: [x,y] becomes [x,y,x]
      `         # Push all three values separated to the stack
       D        # Duplicate this x
        É       # Check if its odd (1 if truthy; 0 if falsey)
         -      # Subtract it from the duplicated x
          2÷    # Integer-divide it by 2
            +   # Add it to y
             ‚  # And pair it with the original x again
                # (after which the result is output implicitly)

मेरा यह 05AB1E टिप देखें (अनुभाग संपीड़ित तार शब्दकोश का हिस्सा नहीं कैसे? ) को समझने के लिए क्यों .•F?äM•है "qwedsa"।

Answer 6

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

def G(s):
 q='qwedsa'
 d=[-1,0,1,1,0,-1,-1,-2,-1,1,2,1]
 X=Y=0
 for c in s:
  if c in q:
   n = q.find(c)
   X += d[n]
   Y += d[n+6]
  if c == 'r':
   q = q[1:]+q[0]
  if c == 'R':
   q = q[5]+q[0:5]
 print(X, int((Y-X%2)/2))

Comments

मैं Python 3.5.0b3MacOS पर उपयोग कर रहा हूं , और जब मुझे 5 और 6 में त्रुटि मिली, तो राउंडिंग के कारण, बाकी सही थे। (चूंकि संपादन के माध्यम से तय)। आप पायथन के किस संस्करण का उपयोग कर रहे हैं?

— ऑस्टिन हेस्टिंग्स

@AustinHastings मैं डेबियन अस्थिर पर पायथन 3 पर हूं।

— दरवाज़े