Manhattan distance of rotation sequence

Question

I though this would be a good challenge : http://adventofcode.com/2016/day/1

Task description

Given a sequence of rotations and distances following the pattern (L|R)[1-9][0-9]*, give the manhattan distance between the start and the ending points, that is the minimal number of vertical and horizontal moves on a grid.

Examples

For example, if we assume you started facing North:

Following R2, L3 leaves you 2 blocks East and 3 blocks North, or 5 blocks away. R2, R2, R2 leaves you 2 blocks due South of your starting position, which is 2 blocks away. R5, L5, R5, R3 leaves you 12 blocks away.

Technical details

You can choose the separator between the moves (e.g. : "\n", ", ", or ","). You must give the answer as an integer in base 10.

Not a duplicate!

It is not a duplicate for multiple reasons :

• The moves are not the same. Here they are rotations, not directions.
• I want the Manhattan distance, not the euclidian.

Answer 1

Python 3, 109 99 104 101 bytes

This is a simple answer that uses complex numbers, with input as a space-separated string or a newline-separated string. Golfing suggestions welcome!

Edit: -13 bytes thanks to Labo. +5 bytes for converting to an int.

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

Answer 2

PHP, 93 bytes

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

breakdown

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

Python 2, 86 bytes

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)

Tracks the current x and y coordinates. When turning, instead of updating the direction, rotates the current value so that the motion is always in the x-positive direction. Complex numbers were too costly to extract the coordinates from.

Answer 4

Python 2, 103 102 bytes

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

Input is a string of space delimited directions, e.g. "R5 L5 R5 R3".
Prints out the Manhattan distance between the starting location and the destination.

How?

Starts at the origin of the complex plane, l=0;

With a cumulative quarter-right turn counter, c=0;

For each instruction, i, the rotation is parsed is by comparing the first character of the direction to the character 'N', and c is adjusted accordingly.

The distance to travel is parsed with int(i[1:]) and the instruction is enacted by taking that many block sized steps in the direction given by taking the cth power of 0+1j with 1j**c.

The final Manhattan distance is the sum of the absolute distances from the origin in the two directions - imaginary and real; achieved with abs(l.imag)+abs(l.real)

Answer 5

JavaScript (ES2016), 98 100

2 bytes saved thx @Neil

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

100 bytes for ES6

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)

Less golfed

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)

Test (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>