Data una stringa di N, S, E e W, produce un rilevamento (angolo in senso orario da nord in gradi), corretto con 5 decimali.

Nella notazione bussola tradizionale , una stringa è composta da solo 2 di questi caratteri (come NNW o ESE). Qui devi anche accettare le stringhe che contengono tutte e 4 (come WNNNSE) . L'uso di soli 2 simboli consente agli umani di comprendere intuitivamente il significato. Consentire 4 simboli rende orribile la lettura, ma consente modi più brevi di descrivere un rilevamento con una data precisione.

(Come sottolineato nei commenti di user2357112 , risulta che puoi dimostrare che per ogni dato rilevamento , la stringa di 4 simboli avrà esattamente la stessa lunghezza della stringa di 2 simboli, quindi ho basato questa sfida su un presupposto falso. Speriamo che questa mancanza di uno scopo pratico non toglie il godimento della sfida ...)

Il metodo esatto è descritto di seguito ed è equivalente alla notazione tradizionale (si espande su di esso anziché modificarlo).

Ingresso

• L'input è una singola stringa contenente solo i caratteri NESW.
• L'input può essere una sequenza di caratteri, se si preferisce, purché ciò non includa alcuna preelaborazione. Ad esempio, [N, [E, [S, [W]]]]non è consentito prendere un elenco nidificato per facilitare l'ordine di elaborazione.
• Non è consentito assumere personaggi diversi. Non puoi prendere una stringa di 1234invece di NESW.

Produzione

• L'output deve essere un numero decimale o una rappresentazione di stringa di uno (non un razionale / frazione).
• Gli zeri finali non devono essere visualizzati. Se il rilevamento è 9.00000, quindi anche l'output 9conta come corretto con 5 decimali.
• L'output è compreso nell'intervallo [0, 360). Cioè, incluso 0 ma escluso 360.
• La correttezza viene verificata arrotondando l'output a 5 cifre decimali. Se il cuscinetto è 0,000005, questo arrotondamento a 0,00001. Le uscite 0.00001 e 0.000005 sono entrambe corrette.
• L'output in notazione scientifica per alcuni input è accettabile. Ad esempio, 1e-5invece di 0.00001.

Conversione

• Inoltre, il singolo carattere bussola N, E, S, e Wcorrispondono rispettivamente a 0, 90, 180, e 270 gradi.
• Preparando uno di questi a una stringa si ottiene il rilevamento che taglia in due il rilevamento del carattere singolo e il rilevamento della stringa originale.
• Viene scelto il più vicino dei due possibili cuscinetti bisecati, in modo che NE rappresenti 45 gradi, non 225 gradi.
• Ciò è inequivocabile, tranne nel caso in cui l'angolo da bisecare sia di 180 gradi. Pertanto NS, SN, WE, e EWcorrispondono ai cuscinetti non definite, e l'ingresso finiranno mai in uno di questi. Possono tuttavia apparire in qualsiasi altro punto della stringa di input, poiché ciò non causa ambiguità.
• Se gli ultimi due personaggi sono identici, il personaggio finale sarà ridondante poiché la bisection restituirà lo stesso rilevamento. Poiché ciò non aggiunge nulla alla notazione, il codice non deve gestirlo. Pertanto NN, EE, SS, e WWcorrispondono ai cuscinetti non definite, e l'ingresso finiranno mai in uno di questi. Possono tuttavia apparire in qualsiasi altro punto della stringa di input.

Esempi

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

Casi test

Un invio è valido solo se fornisce un output corretto per tutti i casi di test. Si noti che i casi di test spingono ai limiti di ciò che può essere gestito con doppia precisione. Per le lingue che hanno come impostazione predefinita la precisione singola, sarà probabilmente necessario spendere i byte per specificare la doppia precisione per ottenere output corretti.

Le uscite del test case sono mostrate arrotondate con 5 cifre decimali e con precisione arbitraria. Entrambi sono output validi.

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

punteggio

Questo è code-golf . Il punteggio è la lunghezza del codice sorgente in byte e il più breve vince.

^Pedanteria

<sup>Ho fatto l'errore di pensare che "North by North West" fosse una valida direzione della bussola. Un errore felice, dal momento che ha portato a un'idea di sfida, ma ho scoperto poi dalla pagina di Wikipedia :

"Il titolo del film di Alfred Hitchcock del 1959, North by Northwest, in realtà non è un punto di direzione sulla bussola a 32 venti, ma il film contiene un riferimento a Northwest Airlines ".

Si scopre anche che il metodo utilizzato per questa sfida è coerente solo con i punti cardinali tradizionali fino alla bussola a 16 punti inclusa. La bussola a 32 venti descritta in quella pagina è leggermente diversa e ho trascurato convenientemente la sua esistenza per questa sfida.

Infine, per chiunque pensi che dovrei usare "Southeast" anziché "South East",.</sup>

JavaScript (ES6), 84 80 78 74 72 byte

Salvataggio di un byte grazie a @Titus, 1 grazie a @Neil

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

Ci è voluto un po ', ma penso di aver finalmente perfezionato la formula ...

Snippet di prova

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)

Spiegazione

Cominciamo con il caso più semplice: una stringa a carattere singolo. Il risultato è semplicemente la sua posizione (indicizzata 0) nella stringa NESW, moltiplicata per 90.

Per una stringa di due caratteri, il risultato si trova a metà strada tra il risultato del primo carattere e il risultato del secondo. Tuttavia, c'è un problema: se la differenza assoluta tra i due è maggiore di 180 (ad esempio NWo WN), dobbiamo 180 all'angolo in modo che non punti nella direzione opposta.

Per ogni stringa più lunga, il risultato si trova a metà strada tra il risultato del primo carattere e il risultato del resto della stringa. Questo può essere generalizzato nel modo seguente:

• Se l'input è un singolo carattere, restituisce il suo indice nella stringa per NESW90.
• In caso contrario, restituisce l'indice del primo carattere nella stringa per NESW45 volte, più metà del risultato del resto della stringa; aggiungere un ulteriore 180 se la differenza assoluta tra i due è maggiore di 90.

C # 6, 226 217 207 185 byte

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

Modifica: -10 byte "prendendo in prestito" l'idea dall'invio di ETHproductions
-22 byte grazie 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 byte

• -7 byte con l'operatore di coalescenza null
• -2 byte non sostituendo N(e altro, perché ciò consente di mettere la traduzione in testa al loop: Nè vero, ma valuta0 nel calcolo).
• +41 byte per il fissaggio della dissezione ( tosse )
• -7 byte direttamente e -16 ispirati indirettamente al codice di @ ETHproductions
• -3 byte sostituendo strtrcon uno dei miei bit giocoleria

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;

Questa è ufficialmente la prima volta in assoluto che utilizzo l'operatore null coalescing. Corri con-r .

PHP 7.1

Gli offset di stringa negativi nella prossima versione di PHP salveranno 12 byte:
sostituisci strlen($s=$argv[1])con 0e $scon $argv[1].

Byte gratuiti per (quasi) tutti:

• Calcolando con 0,1,2,3 anziché 0,90,180,270 e moltiplicando il risultato finale con 90 si risparmieranno due byte e probabilmente consentirà un ulteriore golf.
• Ci sono alcuni schemi nei codici ASCII dei caratteri. Prova uno di questi nella tua lingua:
  • (a/2%6+2)%5
  • a<87?a/2&3^3:3 o a/2&3^3*(a<87)
  • a&1?a&2|a/4&1:0
  • a/.8-1&3

Python 3, 133 113 byte

Sto solo migliorando la risposta di @ L3viathan perché ho appena creato questo account e quindi non posso ancora fare commenti.

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 byte

6 byte salvati grazie a Emigna. Risparmiato 5 byte grazie all'idea di Titus di lavorare sul range [0,4 [e moltiplicare per 90 alla fine. Salvati 5 byte grazie alla padronanza di Adnan delle antiche metamorfosi xor / modulo.

Quindi ogni angolo viene ridotto dalla gamma [0,360 [alla gamma [0,4 [per tutta l'esecuzione. Il risultato viene quindi moltiplicato per 90 e visualizzato.

Ç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

Provalo online!

Potenziali assi del golf:

• Non sono sicuro se è necessaria quella mod 4 (risparmierebbe 2 byte). Tutti i casi di test funzionano senza di essa, ma forse esiste un caso complicato. Una prova matematica per convalidarla o annullarla sarebbe di prim'ordine.
• Non ci sono elementi impliciti oltre alla visualizzazione del risultato (virgolette di chiusura, parentesi quadre di chiusura).

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

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

Chiama fcon la stringa.

C, 184 byte

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 byte

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

spiegato

1. Leggi input da stdin
   • Abbina input per indice a c("N","E","S","W")
   • Dagli indici corrispondenti: abbina al vettore dei gradi 0:3*90(invece dic(0,90,180,270) )
   • Invertire e conservare come z
2. Inizializzare p al grado equivalente all'ultimo carattere in input
3. Memorizza la lunghezza dell'input come l
4. Iterativamente, calcola il più vicino dei due possibili cuscinetti bisecati.
5. Se viene fornito un solo ingresso, impostare psuz
6. Formatta e stampa

Prova i casi di test su R-fiddle (nota che questa è una funzione a causa del scanmancato funzionamento di R-fiddle)

Haskell, 109 105 103 byte

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

Grazie per -2 byte @xnor!

Dyalog APL , 55 45 38 byte

Soluzione

Richiede ⎕IO←0, che è predefinito su molti sistemi. Chiede una direzione.

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

Spiegazione

Risolve il problema convertendo ogni lettera in un numero complesso 1∠ θ ⇔ a + b · i , quindi facendo una riduzione della somma da destra a sinistra (il forte di APL) mentre si normalizza ad ogni passo. Il θ finale viene quindi convertito in gradi e normalizzato per essere entro [0, 360):

'NES'⍳⍞gli indici di ciascuna lettera di input in "NES"; N → 0, E → 1, S → 2, qualsiasi altra cosa → 3

○2÷⍨convertire in angoli in radianti; θ = π · ^x ∕ ₂

¯12○converti in numeri complessi sul cerchio unitario; e ^{i · θ}

(... )/riduci l'elenco con ... (ovvero inserisci la funzione tra gli elementi di ...)

 +÷(|+)... la somma normalizzata; ^{x _{n - 1} + x _n} ∕ _{| x n - 1 + x n} |

12○converti in angolo; θ

÷○÷180×convertire in gradi; ¹ ∕ _{π · ¹ ∕ 180 · x}

360| resto della divisione quando diviso per 360

ProvaAPL online!

aneddoto

Se input e output fossero unità complesse ortogonali, l'intera soluzione sarebbe solo:

(+÷(|+))/

Il resto del codice sta analizzando l'input e formattando l'output.

Lisp comune, 347 327 byte

Grazie a @Titus per il decollo

Questo può probabilmente essere giocato a golf di più, ma almeno funziona (penso):

(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

Funzione dprende un personaggio N, E, W, o Se restituisce il livello appropriato. La funzione mottiene il grado combinato appropriato di due direzioni date. La funzione fscorre attraverso la stringa fornita, calcola il grado appropriato e lo stampa come virgola mobile.

Befunge, 183 181 175 byte

>~#+:#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_$$$,,,".">:#,_@

Provalo online!

Spiegazione

Questo segue un algoritmo simile a molte delle altre risposte, solo che utilizza calcoli a virgola fissa emulati con numeri interi poiché Befunge non supporta il virgola mobile.

Grazie a @Titus per la routine da ASCII a 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 byte

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

Provalo online!