กำหนดอินพุตของชุดอักขระที่แสดงถึงการเคลื่อนไหวบนกริดหกเหลี่ยมเอาท์พุทพิกัดสุดท้ายของ "พอยน์เตอร์"

รูปหกเหลี่ยมของเราจะมีหมายเลขเป็นอย่างนั้น (ลองนึกภาพสี่เหลี่ยมกริดที่มีคอลัมน์เลขคี่ทุกคอลัมน์เลื่อนลงด้านล่างเล็กน้อย):

  _____         _____         _____         _____
 /     \       /     \       /     \       /     \
/ -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) คำสั่งจะถูกแมปอีกครั้ง (ลองจินตนาการว่ามันเป็นการหมุนทั้งกริดฐานสิบหก แต่ยังคงรักษา "w" ไว้เช่น ฯลฯ ซึ่งเทียบเท่ากับสิ่งต่อไปนี้):

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

ในทำนองเดียวกันการหมุนทวนเข็มนาฬิกา ( R) หลังจากนั้นจะกลับไปที่ตารางปกติและหมุนทวนเข็มนาฬิกาอีกครั้งจะ "remap" เพื่อqwedsaaqweds

ต้องป้อนข้อมูลเป็นสตริงเดียวและเอาต์พุตสามารถเป็นสตริงเดี่ยวที่เข้าร่วมโดยอักขระที่ไม่ใช่ตัวเลข (เช่น1 2หรือ3,4) หรืออาร์เรย์ของจำนวนเต็ม

เนื่องจากนี่คือcode-golfรหัสที่สั้นที่สุดเป็นไบต์จะเป็นผู้ชนะ

กรณีทดสอบ:

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

Pyth, 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อาร์เรย์

ฉันแน่ใจว่าบางคนสามารถทำได้ดีกว่าการใช้ Pyth ฉันจะพยายามต่อไปที่จะตอบคำถามของฉันกอล์ฟ!

คุณสามารถลองมันออกมาที่นี่

Retina , 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

เอาต์พุตไม่พร้อมกันโดยคั่นด้วยเครื่องหมายโคลอน นั่นหมายความว่าคุณจะไม่เห็นเลขศูนย์ในผลลัพธ์ (แม้ว่าการมีเครื่องหมายโคลอนจะบอกคุณว่าพิกัดสองค่าใดเป็นศูนย์ถ้ามีเพียงค่าเดียว)

ลองออนไลน์!

มันสนุกและจบลงด้วยความประหลาดใจ :)

คำอธิบาย

พื้นหลังบางอย่างก่อน มีระบบพิกัดหลายระบบเพื่ออธิบายกริดหกเหลี่ยม หนึ่งขอใช้พิกัดชดเชย นั่นเป็นหลักเหมือนกับพิกัดกริดสี่เหลี่ยมยกเว้นว่าแกนหนึ่ง "สั่นคลอน" เล็กน้อย โดยเฉพาะคำถามจะถามถึงรูปแบบ "คี่ -Q" ที่แสดงในหน้าเชื่อมโยง ระบบพิกัดนี้น่ารำคาญนิดหน่อยที่จะทำงานด้วยเพราะพิกัดที่เปลี่ยนไปในระหว่างการเคลื่อนย้ายนั้นไม่เพียง แต่ขึ้นอยู่กับทิศทางของการเคลื่อนที่เท่านั้น แต่ยังเกี่ยวกับตำแหน่งปัจจุบันด้วย

ระบบพิกัดอื่นใช้พิกัดแกน นั่นคือการจินตนาการถึง hexgrid เป็นชิ้นส่วนทแยงมุมผ่านปริมาตรของลูกบาศก์และใช้แกนสองแกน (เช่น x และ z) เพื่อหาตำแหน่งบนระนาบ 2 มิติ บนกริดฐานสิบหกนั่นหมายความว่าทั้งสองแกนจะทำมุมเป็น 60 (หรือ 120) องศา ระบบนี้ใช้งานง่ายกว่า แต่ใช้งานง่ายกว่าเนื่องจากทุกทิศทางสอดคล้องกับเวกเตอร์ "เดลต้า" ที่แน่นอน (สำหรับคำอธิบายที่ดีขึ้นเกี่ยวกับการมาถึงที่ระบบพิกัดนี้ให้ตรวจสอบลิงค์และไดอะแกรมและภาพเคลื่อนไหวที่น่ารักที่นั่น)

ดังนั้นนี่คือสิ่งที่เราจะทำ: เราคำนวณการเคลื่อนที่ในแนวแกน (ดูแลการหมุนตามที่แนะนำในการท้าทายโดยทำการแมปความหมายของคำสั่ง) และเมื่อเราเสร็จแล้ว พิกัด.

ทั้งหกย้ายแผนที่ไปยังเวกเตอร์ของเดลต้าต่อไปนี้ในพิกัดแกน (xz):

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

เดี๋ยวก่อนนี่คือเรติน่าเราจะต้องทำงานกับตัวเลขเอก เราจะทำงานร่วมกับหมายเลข unary เชิงลบได้อย่างไร ความคิดคือการใช้ตัวเลขสองหลักที่แตกต่างกัน แสดงให้เห็นถึงหนึ่ง+1และอื่น ๆ -1ที่แสดงให้เห็นถึง นั่นหมายความว่าไม่ว่าเราต้องการเพิ่มหรือลบออก1จากตำแหน่งปัจจุบันเราสามารถทำได้โดยเพิ่มตัวเลข เมื่อเราเสร็จแล้วเราจะยุบผลลัพธ์เป็นขนาด (ของหลักที่เกี่ยวข้อง) โดยการยกเลิกตัวเลขที่สมดุล 1จากนั้นเราก็คิดออกป้ายอยู่บนพื้นฐานของหลักที่เหลืออยู่และแทนที่ตัวเลขทั้งหมดที่มี

แผนคือการสร้างส่วนประกอบแกน x และ z ไปทางซ้ายและขวาของ a :(เป็นตัวคั่น) หน้าอินพุต 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สตริงแรกออกจากสตริงเนื่องจากได้รับการประมวลผลแล้ว (ฉันหวังว่าฉันจะใช้การ จำกัด การแทนที่ ... ) )ยังบอก Retina ที่จะทำงานทุกขั้นตอนถึงหนึ่งนี้ในวงสตริงจนกว่าจะหยุดการเปลี่ยนแปลง ในการวนซ้ำครั้งต่อไปสเตจแรกคือ no-op เนื่องจากไม่มีอีกRแล้วสเตจที่สองจะใช้การหมุนอีกครั้งตราบใดที่มีrs เหลืออยู่ในสตริง

เมื่อเราทำเสร็จแล้วเราได้แมปคำสั่งทั้งหมดกับทิศทางที่สอดคล้องกับบนตารางที่ไม่ได้หมุนและสามารถเริ่มประมวลผลคำสั่งเหล่านั้นได้ แน่นอนว่าการเคลื่อนไหวนี้เป็นเพียงผลรวมของเวกเตอร์เดลต้าเหล่านั้นและจำนวนเงินเป็นคอมมิวเตชันดังนั้นมันจึงไม่สำคัญว่าเราจะประมวลผลอย่างไรในตอนนี้เมื่อการหมุนถูกกำจัด

^
:

แทรกตัวคั่นพิกัดที่ด้านหน้า

ตอนนี้เราไม่ได้จริงๆต้องในการประมวลผลและs wพวกเขาเป็นตัวเลข+1และของเราและ-1พวกเขาอยู่ในด้านที่ถูกต้อง:แล้วพวกเขาก็จะเลื่อนออกตามที่ต้องการในตอนท้าย เราสามารถทำให้เข้าใจง่ายอื่น: aเป็นเพียงs + qและเป็นe w + dมาทำสิ่งนี้กัน:

a
sq
e
wd

อีกครั้งเหล่านั้นsและwเพิ่งจะเลื่อนออก ทั้งหมดที่เราต้องทำคือการย้ายผู้qและdเพื่อต้อนรับและเปิดให้เป็นwและss ตัวเอง เราทำเช่นนั้นด้วยสองลูปแยกกัน:

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

เสร็จแล้ว เวลาสำหรับการแปลงจากพิกัดแนวแกนเป็นออฟเซ็ต เพื่อที่เราจะต้องยุบตัวเลข อย่างไรก็ตามสำหรับตอนนี้เราสนใจเฉพาะด้านซ้ายเท่านั้น เนื่องจากวิธีที่เราดำเนินการกับqs dเรารู้ว่าss ทั้งหมดที่อยู่ด้านซ้ายมือจะปรากฏต่อหน้าws ดังนั้นเราต้องตรวจสอบเพียงคู่เดียวเพื่อยุบพวกมัน:

+`sw

ตอนนี้การแปลงจริง นี่คือรหัสเทียมนำมาจากลิงก์ด้านบน:

# 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เป็นเลขหลักเดียว แต่ดูเหมือนจะยืดออกนิดหน่อย)

Python (3.5) 193 185 182 ไบต์

ฉันยังคำนวณในแนวแกนและแปลงในตอนท้าย

ฉันเพิ่มการปรับให้เหมาะสมตาม @Martin Büttner solution: ฉันแทนที่ 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

รุ่นที่708 636 586 569 ไบต์

ฉันใช้พิกัด y สองเท่าเพราะทำให้คณิตศาสตร์ง่ายขึ้น ฉันไม่แน่ใจว่าฉันพิจารณาการหมุนด้วยวิธีที่เหมาะสมที่สุด แต่มันจะนับจำนวนrวินาที

แก้ไข: บันทึกแล้ว 72 ไบต์โดยปรับปรุงการจัดการRs บันทึก 60 ไบต์ด้วยการเพิ่มประสิทธิภาพset/aคำสั่งของฉัน บันทึก 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%

05AB1E , 60 ไบต์

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

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

คำอธิบายทั่วไป:

เราเริ่มต้นด้วยสตริง"qwedsa"และพิกัด[0,0]และวนรอบอักขระของอินพุต
หากเป็น "r" หรือ "R" เราจะหมุนสตริงนี้ไปทางซ้ายหรือขวาตามลำดับ
ถ้าไม่เราจะได้รับดัชนี 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"

Python 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))