Sequência da distância de rotação de Manhattan


9

Eu acho que esse seria um bom desafio: http://adventofcode.com/2016/day/1

Descrição da tarefa

Dada uma sequência de rotações e distâncias seguindo o padrão (L | R) [1-9] [0-9] *, forneça a distância de manhattan entre os pontos inicial e final, ou seja, o número mínimo de movimentos verticais e horizontais em uma grade.

Exemplos

Por exemplo, se assumirmos que você começou a enfrentar o norte:

Após R2, L3 deixa 2 quarteirões a leste e 3 a norte, ou a 5 quarteirões de distância. R2, R2, R2 deixa você a 2 quarteirões do sul da sua posição inicial, que fica a 2 quarteirões de distância. R5, L5, R5, R3 deixa você a 12 quarteirões de distância.

Detalhes técnicos

Você pode escolher o separador entre os movimentos (por exemplo: "\ n", "," ou ","). Você deve fornecer a resposta como um número inteiro na base 10.

Não é uma duplicata!

Não é uma duplicata por vários motivos:

  • Os movimentos não são os mesmos. Aqui estão as rotações , não as direções.
  • Quero a distância de Manhattan, não o euclidiano.

3
Você deve incluir uma descrição de qual é a distância de Manhattan na sua pergunta. Apenas postar um link é meio cafona.
Gabriel Benamy 02/12/19

2
É muito diferente ! Nós só temos rotações!
Labo

11
@Labo Concordo. Não se trata apenas do fato de que a resposta aqui está na distância de Manhattan, enquanto a outra está na distância euclidiana. Isto tem movimento estilo tartaruga enquanto o outro especifica bússola direções nsew (O fato de que os chama UDLR é irrelevante.)
Nível do rio St

2
No futuro, use a Sandbox para obter feedback sobre seus desafios antes de publicá-los no site principal.
Mego3

2
@Labo Tudo bem, não esperamos que novos usuários conheçam todos os detalhes deste site imediatamente. É apenas uma sugestão gentil para a próxima vez. :)
Mego

Respostas:


4

Python 3, 109 99 104 101 bytes

Essa é uma resposta simples que usa números complexos, com entrada como uma sequência separada por espaço ou uma sequência separada por nova linha. Sugestões de golfe são bem-vindas!

Edit: -13 bytes graças ao Labo. +5 bytes para converter para um 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))

1-2 * (r [0] <'R') economizará 2 bytes :)
Labo

Não faça uma função, a leitura da entrada fará com que você salve mais caracteres!
Labo

Atribua 2 variáveis ​​na mesma linha para salvar 2 bytes: d = p = 0
Labo

Joguei novamente a sua resposta e ele gera 99 caracteres! pastie.org/private/hm7lejqosdqnkgo000u7q
Labo

2
@ Labo Não sei se você pode editar a especificação de uma maneira que invalidaria as respostas existentes, mas deixe-me perguntar alguns mods.
Sherlock9

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

demolir

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

2

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)

Rastreia a corrente xe as ycoordenadas. Ao girar, em vez de atualizar a direção, gira o valor atual para que o movimento esteja sempre na direção x-positiva. Números complexos eram muito caros para extrair as coordenadas.


1

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

Entrada é uma sequência de direções delimitadas por espaço, por exemplo "R5 L5 R5 R3".
Imprime a distância de Manhattan entre o local inicial e o destino.

Como?

Inicia na origem do plano complexo l=0;

Com um contador de voltas acumulado no quarto à direita c=0;

Para cada instrução, ia rotação é analisada comparando o primeiro caractere da direção com o caractere 'N'e cé ajustada de acordo.

A distância a percorrer é analisada int(i[1:])e a instrução é executada executando vários passos do tamanho de um bloco na direção dada, usando a cpotência th 0+1jcom 1j**c.

A distância final de Manhattan é a soma das distâncias absolutas da origem nas duas direções - imaginária e real; alcançado comabs(l.imag)+abs(l.real)


11
@ Sherlock9 - Ah, hum resposta convergência. Economize 2 bytes mudando para Python 2 e usando cmpcomo minha resposta, me informe e eu excluirei.
Jonathan Allan

0

JavaScript (ES2016), 98 100

2 bytes salvos 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 para 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)

Menos golfe

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)

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


11
Minha resposta do ES6 foi originalmente de 106 bytes; copiar sua variável intermediária me salvou em 3 bytes; mudar de partida para sua substituição me salvou 2 bytes e, ao copiar o processamento da direção e da distância, ao mesmo tempo, me salvou um byte final, resultando no seguinte 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):, que agora é dois bytes menor que sua resposta ES6, graças aos truques c<'R'||3e n*=~-(d&2).
Neil
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.