Je pensais que ce serait un bon défi: http://adventofcode.com/2016/day/1

Description de la tâche

Étant donné une séquence de rotations et de distances suivant le motif (L | R) [1-9] [0-9] *, donnez la distance manhattan entre le point de départ et le point d'arrivée, c'est-à-dire le nombre minimal de mouvements verticaux et horizontaux sur une grille.

Exemples

Par exemple, si nous supposons que vous avez commencé à faire face au Nord:

Après R2, L3 vous laisse 2 blocs à l'est et 3 blocs au nord, ou 5 blocs plus loin. R2, R2, R2 vous laisse 2 pâtés de maisons au sud de votre position de départ, qui est à 2 pâtés de maisons. R5, L5, R5, R3 vous laisse à 12 pâtés de maisons.

Détails techniques

Vous pouvez choisir le séparateur entre les mouvements (par exemple: "\ n", "," ou ","). Vous devez donner la réponse sous forme d'entier en base 10.

Pas un doublon!

Ce n'est pas un doublon pour plusieurs raisons:

• Les mouvements ne sont pas les mêmes. Ici, ce sont des rotations , pas des directions.
• Je veux la distance de Manhattan, pas l'euclidienne.

Python 3, 109 99 104 101 octets

Il s'agit d'une réponse simple qui utilise des nombres complexes, avec une entrée sous forme de chaîne séparée par des espaces ou une chaîne séparée par des sauts de ligne. Suggestions de golf bienvenues!

Edit: -13 octets grâce à Labo. +5 octets pour la conversion en 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))

PHP, 93 octets

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

panne

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

Python 2, 86 octets

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)

Suit le courant xet les ycoordonnées. Lorsque vous tournez, au lieu de mettre à jour la direction, tourne la valeur actuelle afin que le mouvement soit toujours dans la direction x-positive. Les nombres complexes étaient trop coûteux pour en extraire les coordonnées.

Python 2, 103 102 octets

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

L'entrée est une chaîne de directions séparées par des espaces, par exemple "R5 L5 R5 R3".
Imprime la distance de Manhattan entre l'emplacement de départ et la destination.

Comment?

Commence à l'origine du plan complexe, l=0;

Avec un compteur de virage quart de droite cumulé c=0;

Pour chaque instruction, ila rotation est analysée en comparant le premier caractère de la direction au caractère 'N'et cest ajustée en conséquence.

La distance à parcourir est analysée int(i[1:])et l'instruction est exécutée en prenant autant de pas de la taille d'un bloc dans la direction donnée en prenant la cpuissance e0+1j avec 1j**c.

La distance finale de Manhattan est la somme des distances absolues de l'origine dans les deux directions - imaginaire et réelle; réalisé avecabs(l.imag)+abs(l.real)

JavaScript (ES2016), 98 100

2 octets enregistrés 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 octets pour 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)

Moins golfé

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>