Onde eu estou agora?
Dada uma sequência d
, contendo apenas as letras NSWE
, determine as coordenadas que eu viajei (da esquerda para a direita, consumindo avidamente) e a coordenada final em que eu moro.
As regras para leitura de coordenadas da esquerda para a direita:
- Se o próximo caractere for
N
ouS
:- Se o caractere após o
N
ouS
for outroN
ouS
:- Consuma apenas o primeiro
N
ouS
. - Saída
[0,1]
paraN
- Saída
[0,-1]
paraS
- Consuma apenas o primeiro
- Se o caractere após o
N
ouS
éW
ouE
:- Consuma o
N
ouS
e oW
ouE
. - Saída
[1,1]
ou[-1,1]
paraNE
eNW
, respectivamente. - Saída
[1,-1]
ou[-1,-1]
paraSE
eSW
, respectivamente.
- Consuma o
- Se o caractere após o
- Se o personagem for
E
ouW
não precedido por umS
ouN
:- Consuma o
E
ouW
. - Saída
[1,0]
paraE
. - Saída
[-1,0]
paraW
.
- Consuma o
Exemplo Trabalhado
NSWE
[0,1] (North N)
[-1,-1] (South-west SW)
[1,0] (East E)
[0,0] (N+SW+E = Didn't actually move)
Observe que isso pode estar em qualquer formato, eis outros exemplos de saída válida:
[[0,1],[-1,-1],[1,0],[0,0]]
[[[0,1],[-1,-1],[1,0]],[0,0]]
"0,1\n0,-1\n-1,0\n1,0\n0,0"
Etc ...
Mais exemplos
SWSENNESWNE
[-1,-1]
[1,-1]
[0,1]
[1,1]
[-1,-1]
[1,1]
[1,0]
NNEESESSWWNW
[0,1]
[1,1]
[1,0]
[1,-1]
[0,-1]
[-1,-1]
[-1,0]
[-1,1]
[0,0]
NENENEE
[1,1]
[1,1]
[1,1]
[1,0]
[4,3]
NEN
[1,1]
[0,1]
[1,2]
EEE
[1,0]
[1,0]
[1,0]
[3,0]
[4, 3]
ou menos tornaria um pouco mais fácil ver o que está acontecendo na saída do teste.1
,-1j
,(-1+1j)
etc um formato de saída válido?NE
é apenasN+E
não deveria, não importa?Respostas:
Python 2 , 116 bytes
Experimente online!
Com saída como
[(3+4j), 1, -1j, …]
, 91 bytesExperimente online!
Este lambda retorna uma lista de números inteiros gaussianos : o primeiro é a coordenada final e todos os outros são os passos necessários para chegar lá.
fonte
Anexo , 80 bytes
Experimente online!
Esta é uma função anônima que recebe um argumento de string.
Explicação
A primeira tarefa é implementar a fase de análise desta pergunta. Achei mais curto usar um Regex simples para analisar a entrada (
_
):Isso corresponde a todas as ocorrências da regex
[NS][WE]|.
, como visto em muitas outras respostas. Isso produz avidamente as instruções solicitadas.Agora, vamos aplicar uma função de hash a cada direção. Pegamos os pontos de código de cada direção e os somamos. Isso fornece o seguinte mapeamento:
Vamos tentar mapear esses valores para um domínio menor; módulo é útil para isso, e podemos demonstrar que o menor módulo que resulta em valores únicos para todas as entradas fornecidas é 11. Classificando pelos restantes, isso nos dá a seguinte tabela:
Agora, temos uma correspondência de entrada, conforme codificada por
Sum@Ords=>[...]%11
. Em seguida, temos que transformar esses restos em pontos. Vamos tentar derivar outro mapeamento, o que significa que a inserção de "valores de preenchimento esparso" em hashes que não correspondem a direções deve ser útil:Atualmente, temos uma série de pontos, o que pode fornecer uma lista indexável pelo hash:
Agora, vamos comprimir isto, vendo como seu único composto por
-1
s,0
s e1
s. Como a lista representa pares, podemos achatar a lista sem perder dados. Então, se pegarmos cada númerox
e calcularmos1-x
, obteremos a seguinte lista:Podemos converter isso em um número base 3:
Convertendo para a base 10:
Para resumir, pegamos nossos pontos, desemparelhamos eles, pegamos cada elemento subtraído
1
e convertido da base3
, fornecendo-nos22260446188
. Podemos descomprimir como tal:ToBase[22260446188,3]
1-ToBase[22260446188,3]
Chop[1-ToBase[22260446188,3],2]
Isso nos dá o nosso conjunto original de pares. Em seguida, podemos executar a indexação acima mencionada da seguinte maneira:
Como no Attache, a indexação por uma matriz retorna todos os elementos correspondentes a esses índices. (Então
[1,2,3,4][ [0,0,-1,1] ] = [1,1,4,2]
,.) Agora, temos as direções do caminho que o OP percorreu. O que resta é calcular a soma.Então, capturamos esse resultado em um lambda
{...}
e o colocamos como a primeira função em uma composição de função (a##b
), com o segundo sendoV#Sum
. Esta é uma bifurcação que, dada a entradax
, se expande para ser:Sum
, quando recebe uma matriz 2D, soma todas as colunas da matriz (como resultado da soma vetorial). Então, isso emparelha as direções com o destino final e temos nosso resultado final.fonte
JavaScript (ES6), 102 bytes
Retorna uma string.
Experimente online!
fonte
MATL , 45 bytes
Experimente online! Ou verifique todos os casos de teste .
Explicação (com exemplo)
Considere a entrada
'NSWE'
como um exemplo.fonte
Java (JDK 10) , 171 bytes
Experimente online!
Explicações
Graças a
c=~-s[i]/6%4
, o seguinte mapeamento é feito:NS
é verificadoc<2
e mapeado para+1
/-1
usando1-c*2
;EW
é verificadoc>1
e mapeado para+1
/-1
usandoc*2-5
.Créditos
fonte
Retina 0.8.2 , 93 bytes
Experimente online! Explicação:
Duplique a entrada.
Divida a primeira cópia em direções.
Remova linhas em branco estranhas criadas pelo processo acima.
Mude
W
paraJ
para classificar entreE
eN
. (PassarE
para o meioS
eW
também funcionaria.)Classifique cada linha em ordem.
Exclua pares de direções opostas (isso afeta apenas a última linha, é claro).
Conte o número de movimentos horizontais e verticais, adicionando sinais sempre que necessário.
Aqueles de vocês que conhecem as diferenças entre o Retina 0.8.2 e o Retina 1 querem salientar que eu posso salvar 2 bytes no Retina 1 porque ele usa em
*
vez de$*
. Enquanto estava lá, tentei simplificar o processo de divisão, mas não consegui reduzir ainda mais a contagem de bytes, só consegui igualá-la a isto:fonte
Java 10,
269265243 bytesDefinitivamente, não é o idioma certo para este desafio.
Experimente online.
Explicação:
fonte
Perl 5
-n
, 94 bytesExperimente online!
fonte
JavaScript (ES6), 102 bytes
Retorna uma string.
fonte
Ruby ,
7571 bytesExperimente online!
-4 bytes graças a benj2240.
Como retornar números complexos parece ser um formato de saída aceitável, acho que não ficará muito mais difícil do que apenas fazer uma porta da resposta muito agradável de Lynn .
fonte
map
, passando seu bloco diretamente parasum
: Experimente online!F # (Mono) , 269 bytes
Experimente online!
fonte
NSWE
que está actualmente a saída(0,1)
,(-1,-1)
,(1,0)
, mas uma quarta saída deve ser a soma dessas coordenadas, então(0,0)
(porque0+-1+1 = 0
e1+-1+0 = 0
).sed, 125
As liberdades de obtenção com a versão do formato de saída :
A pontuação inclui +1 para o
-r
parâmetro sed.Experimente online .
A saída é a seguinte:
A
caracteres representa o número inteiro + velen(string)
a
caracteres representa o inteiro -ve-len(string)
0
Por exemplo:
,
é [0,0],AA
é [0,2]aaa,
é [-3,0]sed 4.2.2 incluindo extensão exec GNU , 147
A versão do formato de saída sensível :
A pontuação inclui +1 para o
-r
parâmetro sed.A saída é fornecida como coordenadas separadas por espaço, uma por linha. Há uma nova linha extra entre os penúltimos e últimos conjuntos de coordenadas - não tenho certeza se isso é problemático ou não.
Experimente online!
fonte
PHP, 153 bytes
deixe um regex fazer a divisão; percorrer as correspondências, imprimir e resumir os resultados intermediários:
Execute como pipe
-nR
ou experimente online .fonte
C (gcc) , 173 bytes
É interessante fazer isso em um idioma sem suporte a regex!
Experimente online!
fonte