Dada uma sequência de N, S, E e W, produza um rolamento (ângulo no sentido horário em relação ao norte em graus), corrija até 5 casas decimais.

Na notação tradicional da bússola , uma sequência é composta por apenas 2 desses caracteres (como NNW ou ESE). Aqui você também deve aceitar cadeias que contêm todas as 4 (como WNNNSE) . O uso de apenas 2 símbolos permite que os humanos compreendam intuitivamente o significado. Permitir 4 símbolos torna a leitura horrível, mas permite maneiras mais curtas de descrever um rolamento com uma determinada precisão.

(Como apontado nos comentários do usuário2357112 , verifica-se que você pode provar que, para qualquer rolamento, a sequência de 4 símbolos terá exatamente o mesmo comprimento que a sequência de 2 símbolos, portanto, baseei esse desafio em uma suposição falsa. Espero que essa falta de um objetivo prático não prejudique o seu prazer no desafio ...)

O método exato é descrito abaixo e é equivalente à notação tradicional (ela se expande em vez de alterá-la).

Entrada

• A entrada é uma única sequência que contém apenas os caracteres NESW.
• A entrada pode ser uma sequência de caracteres, se você preferir, desde que isso não inclua nenhum pré-processamento. Por exemplo, [N, [E, [S, [W]]]]não é permitida uma lista aninhada para ajudar na ordem de processamento.
• Não são permitidos caracteres diferentes. Você não pode usar uma sequência de caracteres em 1234vez de NESW.

Saída

• A saída deve ser um número decimal ou representação de sequência de um (não uma fração / racional).
• Zeros à direita não precisam ser exibidos. Se o rolamento for 9.00000, a saída 9também conta como correta com 5 casas decimais.
• A saída está no intervalo [0, 360). Ou seja, incluindo 0, mas excluindo 360.
• A correção é verificada arredondando a saída para 5 casas decimais. Se o rolamento for 0,000005, este arredondará para 0,00001. As saídas 0,00001 e 0,000005 estão corretas.
• A saída em notação científica para algumas entradas é aceitável. Por exemplo, em 1e-5vez de 0.00001.

Conversão

• A pontos de caracteres único bússola N, E, S, e Wcorrespondem a 0, 90, 180, e 270 graus respectivamente.
• Anexar um desses a uma sequência resulta no rolamento que corta o rolamento do caractere único e o rolamento da sequência original.
• O mais próximo dos dois possíveis rolamentos de bissecção é escolhido, de modo que NE representa 45 graus, não 225 graus.
• Isso é inequívoco, exceto onde o ângulo a ser dividido é 180 graus. Portanto NS, SN, WE, e EWcorrespondem aos rolamentos indefinida, e a entrada nunca irá terminar em qualquer um destes. No entanto, eles podem aparecer em qualquer outro lugar na sequência de entrada, pois isso não causa ambiguidade.
• Se os dois caracteres finais forem idênticos, o caractere final será redundante, pois a bissecção retornará o mesmo rumo. Como isso não adiciona nada à notação, seu código não precisa lidar com isso. Portanto NN, EE, SS, e WWcorrespondem aos rolamentos indefinida, e a entrada nunca irá terminar em qualquer um destes. No entanto, eles podem aparecer em qualquer outro lugar na sequência de entrada.

Exemplos

N: 0
E: 90
S: 180
SE: halfway between S and E: 135
NSE: halfway between N and SE: 67.5
NNSE: halfway between N and NSE: 33.75
NNNSE: halfway between N and NNSE: 16.875
NNNNSE: halfway between N and NNNSE: 8.4375

Casos de teste

Um envio é válido apenas se fornecer saída correta para todos os casos de teste. Observe que os casos de teste ultrapassam os limites do que pode ser tratado com precisão dupla. Para idiomas que usam a precisão única como padrão, você provavelmente precisará gastar os bytes para especificar a precisão dupla, a fim de obter resultados corretos.

As saídas do caso de teste são mostradas arredondadas para 5 casas decimais e também com precisão arbitrária. Ambos são saídas válidas.

WNE 337.5 337.5
WEN 337.5 337.5
WEWEWEWEWEWEWEWEWEWEWEN 330.00001 330.000007152557373046875
NESWNESWNESWNESWNESWNESWNESW 90 89.99999932944774627685546875
NNNNNNNNNNNNNNNNNNNNNNNE 0.00001 0.0000107288360595703125
NNNNNNNNNNNNNNNNNNNNNNNW 359.99999 359.9999892711639404296875
SNNNNNNNNNNNNNNNNNNNNNNNE 90.00001 90.00000536441802978515625
SNNNNNNNNNNNNNNNNNNNNNNNW 269.99999 269.99999463558197021484375

Pontuação

Isso é código-golfe . A pontuação é o comprimento do código-fonte em bytes e as vitórias mais curtas.

^Pedantry

<sup>Cometi o erro de pensar que "North by North West" era uma direção válida da bússola. Um erro feliz, pois levou a uma idéia desafiadora, mas descobri na página da Wikipedia :

"O título do filme de Alfred Hitchcock 1959, North by Northwest, na verdade não é um ponto de direção na bússola de 32 ventos, mas o filme contém uma referência à Northwest Airlines ".

Acontece também que o método usado para esse desafio é consistente apenas com os pontos tradicionais da bússola, incluindo a bússola de 16 pontos. A bússola de 32 ventos descrita nessa página é sutilmente diferente e eu negligenciei convenientemente sua existência para esse desafio.

Finalmente, para quem pensa que eu deveria usar "Sudeste" em vez de "Sudeste",.</sup>

JavaScript (ES6), 84 80 78 74 72 bytes

Guardou um byte graças a @Titus, 1 graças a @Neil

f=([c,...s],b="NESW".search(c))=>b*90-(s[0]?(b-=f(s)/90)-4*(b*b>4):0)*45

Demorou um pouco, mas acho que finalmente aperfeiçoei a fórmula ...

Snippet de teste

f=([c,...s],b="NESW".search(c))=>b*90-(s[0]?(b-=f(s)/90)-4*(b*b>4):0)*45
g=(s,n)=>console.log('f("'+s+'"):',f(s),"expected:",n)

g("N", 0)
g("NE", 45)
g("E", 90)
g("SE", 135)
g("S", 180)
g("SW", 225)
g("W", 270)
g("NW", 315)
g("WNE", 337.5)
g("WEN", 337.5)
g("WEWEWEWEWEWEWEWEWEWEWEN", 330.00001)
g("NESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESWNESW", 90)
g("NNNNNNNNNNNNNNNNNNNNNNNE", 0.00001)
g("NNNNNNNNNNNNNNNNNNNNNNNW", 359.99999)
g("SNNNNNNNNNNNNNNNNNNNNNNNE", 90.00001)
g("SNNNNNNNNNNNNNNNNNNNNNNNW", 269.99999)

Explicação

Vamos começar com o caso mais simples: uma string de caractere único. O resultado é simplesmente sua posição (indexada 0) na cadeia de caracteres NESW, multiplicada por 90.

Para uma sequência de dois caracteres, o resultado fica na metade do caminho entre o resultado do primeiro caractere e o resultado do segundo. No entanto, há um problema: se a diferença absoluta entre os dois for maior que 180 (por exemplo, NWou WN), devemos 180 no ângulo para que não aponte na direção oposta.

Para qualquer sequência mais longa, o resultado fica na metade do caminho entre o resultado do primeiro caractere e o resultado do restante da sequência. Isso pode ser generalizado da seguinte maneira:

• Se a entrada for um único caractere, retorne seu índice na string NESWvezes 90.
• Caso contrário, retorne o índice do primeiro caractere na cadeia NESWvezes 45, mais a metade do resultado do restante da cadeia; adicione 180 extras se a diferença absoluta entre os dois for maior que 90.

C # 6, 226 217 207 185 bytes

using System.Linq;double N(string s){double b=f(s.Last());foreach(var c in s.Reverse()){b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0))/2;b=(b+4)%4;}return b*90;}int f(char x)=>"NESW".IndexOf(x);

Edit: -10 bytes por "emprestar" a ideia da submissão da ETHproductions
-22 bytes graças a @Titus

Ungolfed

// Call this method
double N(string s){
    // Initialize bearing with last direction
    double b=f(s.Last());
    // Do backward. Doing last direction once more doesn't impact result
    foreach(var c in s.Reverse()){
        // Average current bearing with new bearing, adjusted with wrapping
        b=(b+f(c)+(b-f(c)>2?4:f(c)-b>2?-4:0))/2;
        // Make bearing back to range [0,4)
        b=(b+4)%4;
    }
    // Change from "full circle = 4" unit to degree
    return b*90;
}
// helper method to convert direction to bearing. This returns bearing with full circle = 4.
int f(char x)=>"NESW".IndexOf(x);

PHP, 95 88 86 100 127 104 101 bytes

• -7 bytes com o operador coalescente nulo
• -2 bytes por não substituir N(e mais, porque isso permite colocar a conversão na cabeça do loop: Né verdade, mas é avaliada 0no cálculo.)
• +41 bytes para corrigir a bissecção ( tosse )
• -7 bytes diretamente e -16 indiretamente inspirados no código @ ETHproductions
• -3 bytes substituindo strtrpor um dos meus malabarismos de bits

for($i=strlen($s=$argv[1]);$i--;$p=($q+$p=$p??$q)/2+2*(abs($q-$p)>2))$q=ord($s[$i])/.8+3&3;echo$p*90;

Esta é oficialmente a primeira vez que eu uso o operador coalescente nulo. Corra com -r.

PHP 7.1

Os deslocamentos negativos de string na próxima versão do PHP economizarão 12 bytes:
Substitua strlen($s=$argv[1])por 0e $scom $argv[1].

Bytes livres para (quase) todos:

• Calcular com 0,1,2,3 em vez de 0,90,180,270 e multiplicar o resultado final por 90 economizará dois bytes e provavelmente permitirá mais golfe.
• Existem alguns padrões nos códigos ASCII dos caracteres. Experimente um destes no seu idioma:
  • (a/2%6+2)%5
  • a<87?a/2&3^3:3 ou a/2&3^3*(a<87)
  • a&1?a&2|a/4&1:0
  • a/.8-1&3

Python 3, 133 113 bytes

Estou melhorando a resposta do @ L3viathan porque acabei de fazer essa conta e, portanto, ainda não posso fazer comentários.

d={"N":0,"E":.5,"S":1,"W":1.5}
def B(s):
 b=d[s[-1]]
 for c in s[::-1]:b=(b+d[c])/2+(abs(b-d[c])>1)
 return b*180

05AB1E ,48. 42. 37. 32 bytes

Economizou 6 bytes graças a Emigna. Economizou 5 bytes graças à idéia de Titus de trabalhar no intervalo [0,4 [e multiplicar por 90 no final. Economizou 5 bytes graças ao domínio de Adnan da antiga metamorfose xor / modulo.

Portanto, todos os ângulos são reduzidos do intervalo [0,360 [para o intervalo [0,4]] durante toda a execução. O resultado é então multiplicado por 90 e exibido.

Ç30^5%R¬U¦vXy+;DX-Ä0›2*+4%U}X90*

It can be divided into two sequentially called subprograms.
First program: convert input string into an array of the corresponding angles in range [0,4[
Ç      Take the ascii value of all input characters
 30^5% Dark ascii manipulation that yields [0,1,2,3] for [N,E,S,W]

Now we have an array of integers in range [0,4[.

Second program: actually compute the final angle
R                          Reverse the array
 ¬                         Take the first value (the last of the non-reversed array)
  U                        Pop it from the stack and set X to the same value
   ¦                       Strip the first element
    v                      For each remaining element
     Xy+;                  Compute the average value between the leftmost value and X
         DX-Ä0›            Push 1 if angular distance cast to integer is > 0 (i.e. if it is >= 1), 0 otherwise. It's equivalent to checking >= 90 degrees
               2*+         Multiply by 2 (=2 if angular distance is >= 1 and 0 otherwise) and add it to the formerly computed average value. It's equivalent to multiplying by 180
                  4%       Perform mod 4. It's equivalent to performing mod 360
                    U      Store the result back to X
                     }     End for, mandatory if input has only one character
                      X90* Push X*90 and implicitly display it

Experimente online!

Eixos potenciais do golfe:

• Não tenho certeza se esse mod 4 é necessário (ele salvaria 2 bytes). Todos os casos de teste funcionam sem ele, mas talvez exista um caso complicado. Uma prova matemática para validá-lo ou anulá-lo seria de primeira qualidade.
• Não há itens implícitos além da exibição do resultado (aspas de fechamento, colchetes de fechamento).

Python 3, 146 145 117 107 97 94 93 92 bytes

f(s):u='NESW'.find(s[0])*90;return(u+f(s[1:]))/2+180*(abs(u-‌​f(s[1:]))>180)if s[1:]else u

Ligue fcom a corda.

C, 184 bytes

double h(char c){return ((c=='E')+(c=='S')*2+(c=='W')*3);}double d(char*s){double f=h(*s);if(s[1]){double t=f;f=(f+d(s+1)/90)/2;if(((t-f)>1)||((f-t)>1))f+=2;if(f>=4)f-=4;}return f*90;}

Ungolfed

// a helper function
double direction_(char ch)
{
    if (ch=='N')
        return 0.;
    else if (ch=='E')
        return 90.;
    else if (ch=='S')
        return 180.;
    else
        return 270.;
}

// this is the main function to call
double direction(char* str)
{
    double fAngle = direction_(str[0]);
    if (str[1])
    {
        double tmp = fAngle + direction(str+1);
        if (tmp>=360.)
            tmp-=360.;
        tmp/=2;

        if (((tmp-fAngle)>90.) || ((tmp-fAngle)<-90.))
        { //  check if we need to take the "other side"; if the resulting angle is more than 90 degrees away, we took the wrong on
            if (tmp>=180.)
                tmp-=180.;
            else
                tmp+=180.;
        }
        fAngle = tmp;
    }
    return fAngle;
}

R, 172 146 bytes

z=rev((0:3*90)[match(scan(,""),c("N","E","S","W"))]);p=z[1];l=length(z);for(i in 2:l)p=(p+z[i])/2+(abs(p-z[i])>180)*180;if(l<2)p=z;sprintf("%f",p)

Ungolfed

z=rev((0:3*90)[match(scan,""),c("N","E","S","W"))]); #1
p=z[1];                                              #2
l=length(z)                                          #3
for(i in 2:l)p=(p+z[i])/2+(abs(p-z[i])>180)*180;     #4
if(l<2)p=z                                           #5
sprintf("%f",p)                                      #6

Explicado

1. Ler entrada de stdin
   • Corresponde a entrada por índice a c("N","E","S","W")
   • Dos índices correspondentes: corresponda ao vetor de graus 0:3*90(em vez de c(0,90,180,270))
   • Inverta e armazene como z
2. Inicialize pcom o grau equivalente ao último caractere na entrada
3. Armazene o comprimento da entrada como l
4. Iterativamente, calcule o mais próximo dos dois possíveis rolamentos de bissecção.
5. Se apenas uma entrada for fornecida, configure pcomoz
6. Formatar e imprimir

Experimente os casos de teste no R-fiddle (observe que esta é uma função devido ao scannão trabalho no R-fiddle)

Haskell, 109 105 103 bytes

h=180
a#b|abs(a-b)<h=n|n>h=n-h|1>0=n+h where n=(a+b)/2 -- calculates the new "mean" on the cirlce
f 'N'=0                                          -- translates characters to angles
f 'E'=90
f 'S'=h
f _=270
foldr1(#).map f                                  -- traverses the whole string

Obrigado por -2 byte @xnor!

Dyalog APL , 55 45 38 bytes

Solução

Requer ⎕IO←0, que é padrão em muitos sistemas. Pede orientação.

360|÷○÷180×12○(+÷(|+))/¯12○○2÷⍨'NES'⍳⍞

Explicação

Contorna o problema convertendo cada letra em um número complexo 1∠ θ ⇔ a + b · i e , em seguida, reduzindo a soma da direita para a esquerda (forte da APL) enquanto normaliza a cada etapa. O θ final é então convertido em graus e normalizado para ficar entre [0, 360):

'NES'⍳⍞Os índices de cada letra de entrada em "NES"; N → 0, E → 1, S → 2, qualquer outra coisa → 3

○2÷⍨converter em ângulos em radianos; θ = π · ^x ∕ ₂

¯12○converter em números complexos no círculo unitário; e ^{i · θ}

(... )/reduza a lista com ... (ou seja, insira a função entre os elementos de ...)

 +÷(|+)... a soma normalizada; ^{x _{n - 1} + x _n} ∕ _{| x n - 1 + x n} |

12○converter em ângulo; θ

÷○÷180×converter em graus; ¹ / _{pi · ¹ / 180 · x}

360| restante da divisão quando dividido por 360

TryAPL online!

Anedota

Se a entrada e a saída fossem unidades complexas ortogonais, toda a solução seria apenas:

(+÷(|+))/

O restante do código está analisando a entrada e a formatação da saída.

Lisp comum, 347 327 bytes

Agradecemos a @Titus por tirar alguns

Provavelmente isso pode ser jogado mais, mas pelo menos funciona (eu acho):

(defun d(c)(if(eql c #\N)0(if(eql c #\E)1(if(eql c #\S)2(if(eql c #\W)3)))))(defun m(a b)(if(> a b)(rotatef a b))(if(<(+(- 4 b)a)(- b a))(+(/(+(- 4 b)a)2)b)(+(/(- b a)2)a)))(defun f(s)(let((c))(setf c(d(char s(1-(length s)))))(do((a)(p(-(length s)2)(1- p)))((< p 0))(setf a(char s p))(setf c(m(d a)c)))(format t"~5$"(* c 90))))

Uso:

* (f "WNE")
337.50000
NIL

Função dleva um personagem N, E, W, ou Se retorna o grau adequado. Função mobtém o grau combinado apropriado de duas direções dadas. A função fpercorre a sequência fornecida, calcula o grau apropriado e a imprime como um ponto flutuante.

Befunge, 183 181 175 bytes

>~#+:#25#%6*#/`#2_$>5%4*:00p"Z}"4*:***20g#v_+2/00g10g-:8`\0\-8`+!v
v5:+*:*:"d"/+55+5$_^#!:\p01/**:*4"}Z":p020<%**:*"(2Z"+**5*:*"0}"!<
>5>+#<%#56#58#:*#/+\#5:#5_$$$,,,".">:#,_@

Experimente online!

Explicação

Isso segue um algoritmo semelhante a muitas das outras respostas, apenas usando cálculos de ponto fixo emulados com números inteiros, já que o Befunge não suporta ponto flutuante.

Obrigado a @Titus pela rotina ASCII-para-int.

 ~ : 5 6* ` _$        while ((c = getchar()) > 30)  // ends with any ctrl char or EOF
> + 2 %6 / 2            push(c / 2 % 6 + 2)         // partial conversion to int

                      do {
  5%                    dir = pop() % 5             // completes the conversion to int   
  4*:00p                dir *= 4; lowres_dir = dir  // used by the 180-flip calculation
  "Z}"4*:***            dir *= 22500000             // this is 90000000 / 4 
  20g_                  if (!first_pass) {
    +2/                   dir = (dir+last_dir)/2    // last_dir is second item on stack
    00g10g-               diff = lowres_dir - last_lowres_dir
    :8`\0\-8`+!!          flip = diff>8 || -diff>8
    "}0"*:*5**+           dir += flip * 180000000   // add 180 degrees if we need to flip
    "Z2("*:**%            dir %= 360000000          // keep within the 360 degree range
                        }
  020p                  first_pass = false
  :"Z}"4*:**/10p        last_lowres_dir = dir / 22500000
  \                     last_dir = dir              // saved as second item on stack
  :!_                 } while (!stack.empty())

$                     pop()                         // this leaves the final dir on top
5+55+/                dir = (dir + 5)/10            // round down to 5 decimal places
"d":*:*+              dir += 100000000              // add a terminating digit
                      while (true) {                // convert into chars on stack
:55 + % 6 8 * +\ : _    push(dir%10+'0'); if (!dir) break
   > < 5 5 : /+ 5 5     dir /= 10
                      }

$$$                   pop() x 3                     // drop the chars we don't need
,,,                   putchar(pop()) x 3            // output first three chars
"."                   push('.')                     // add a decimal point
>:#,_@                while(c=pop()) putchar(c)     // output the remaining chars

APL (Dyalog Classic) , 30 27 bytes

90×(4|2÷⍨+-4×2<∘|-)/'NES'⍳⎕

Experimente online!