Враховуючи рядок N, S, E і W, виведіть підшипник (кут за годинниковою стрілкою від півночі в градусах), виправте 5 знаків після коми.

У традиційних позначеннях компаса рядок складається лише з двох цих символів (наприклад, NNW або ESE). Тут ви також повинні прийняти рядки, які містять усі 4 (наприклад, WNNNSE) . Використання лише двох символів дозволяє людині інтуїтивно зрозуміти значення. Якщо дозволити 4 символи, це стає жахливим для читання, але дозволяє коротші способи опису підшипника до заданої точності.

(Як зазначено в коментарі по user2357112 , виявляється, можна довести , що для будь-якого даного підшипника, рядок 4 символу буде точно такої ж довжини , як рядок 2 символи, тому я на основі цього завдання на помилковій передумові. Сподіваємось, ця відсутність практичної мети не погіршує вашу насолоду від виклику ...)

Точний метод описаний нижче і еквівалентний традиційним позначенням (він розширюється на ньому, а не змінюється).

Вхідні дані

• Вхід - це один рядок, що містить лише символи NESW.
• Якщо ви хочете, вхід може представляти собою послідовність символів, якщо це не включає попередню обробку. Наприклад, [N, [E, [S, [W]]]]забороняється брати вкладений список, який допоможе впорядкувати обробку.
• Використання різних символів заборонено. Ви не можете взяти рядок 1234замість NESW.

Вихідні дані

• Вихід повинен бути десятковим числом або рядковим поданням одного (а не раціонального / дробу).
• Задні нулі не потрібно відображати. Якщо підшипник є 9.00000, то вихід 9також вважається правильним до 5 знаків після коми.
• Вихід знаходиться в діапазоні [0, 360). Тобто, включаючи 0, але виключаючи 360.
• Правильність перевіряється округленням результату до 5 знаків після коми. Якщо підшипник 0,000005, це закруглюється до 0,00001. Результати 0,00001 та 0,000005 є правильними.
• Вихід у наукових позначеннях для деяких матеріалів є прийнятним. Наприклад, 1e-5замість 0.00001.

Перетворення

• Одиничний символ компас точки N, E, Sі Wвідповідають 0, 90, 180 і 270 градусів відповідно.
• Попередження одного з них до рядка призводить до підшипника, яке розбиває підшипник одиничного символу та опору вихідної струни.
• Вибирається найближчий з двох можливих підрізних підшипників, так що NE представляє 45 градусів, а не 225 градусів.
• Це однозначно, за винятком випадків, коли кут, який слід розрізати, становить 180 градусів. Тому NS, SN, WEі EWвідповідають невизначеним підшипників, а вхід ніколи не закінчаться ні в одному з них. Однак вони можуть з’являтися деінде у вхідному рядку, оскільки це не викликає двозначності.
• Якщо два останніх символи однакові, остаточний символ буде надлишковим, оскільки бісекція поверне той самий підшипник. Оскільки це нічого не додає до позначень, ваш код не потребує цього. Тому NN, EE, SSі WWвідповідають невизначеним підшипників, а вхід ніколи не закінчаться ні в одному з них. Однак вони можуть з’являтися деінде у вхідному рядку.

Приклади

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

Тестові справи

Подання є дійсним лише в тому випадку, якщо воно дає правильний результат для всіх тестових випадків. Зауважте, що тестові випадки піднімаються до меж того, що можна обробляти з подвійною точністю. Для мов, які за замовчуванням мають одну точність, вам, ймовірно, доведеться витратити байти, щоб вказати подвійну точність, щоб отримати правильні результати.

Результати тестових випадків показані округлими до 5 знаків після коми, а також з довільною точністю. Обидва є дійсними результатами.

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

Оцінка балів

Це код-гольф . Оцінка - це довжина вихідного коду в байтах, і найкоротший виграш.

^{Педантність}

<sup>Я допустив помилку, думаючи, що "Північ на північний захід" - дійсний компас. Щаслива помилка, оскільки вона призвела до виклику ідеї, але я потім виявив на сторінці Вікіпедії :

"Назва фільму Альфреда Хічкока 1959 року на північ від Північного Заходу насправді не напрямна точка 32-вітрового компаса, а фільм містить посилання на Northwest Airlines ".

Також виявляється, що метод, який використовується для цього завдання, узгоджується лише з традиційними точками компаса до 16-ти точкового компаса. 32-вітровий компас, описаний на цій сторінці, є дещо іншим, і я зручно не помітив його існування для цього завдання.

Нарешті, для тих, хто думає, що я повинен використовувати "Південно-Східний" замість "Південний Схід",.</sup>

JavaScript (ES6), 84 80 78 74 72 байт

Збережено байт завдяки @Titus, 1 завдяки @Neil

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

Минув час, але я думаю, що я остаточно вдосконалив формулу ...

Фрагмент тесту

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)

Пояснення

Почнемо з найпростішого випадку: однорядного рядка. Результатом є просто його (0-індексоване) положення в рядку NESW, помножене на 90.

Для двочарових рядків результат лежить на півдорозі між результатом першого знака та результатом другого. Однак є улов: якщо абсолютна різниця між цими двома більша, ніж 180 (наприклад, NWабо WN), ми повинні 180 на кут, щоб він не вказував протилежну сторону.

Для будь-якого більш тривалого рядка результат лежить на півдорозі між результатом першого символу та результатом решти рядка. Це можна узагальнити наступним чином:

• Якщо вхід є одним знаком, поверніть його індекс у рядку NESWразів 90.
• В іншому випадку поверніть індекс першого символу в рядку NESWраз 45 плюс половину результату решти рядка; додайте додаткових 180, якщо абсолютна різниця між ними більше 90.

C # 6, 226 217 207 185 байт

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

Редагувати: -10 байт, запозичивши ідею з подання ETHproductions,
-22 байти завдяки @Titus

Безумовно

// 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 байт

• -7 байт з оператором нульового злиття
• -2 байти, не замінюючи N(і більше, тому що це дозволяє помістити переклад на голову циклу: Nє truthy, але оцінює 0в обчисленні.)
• +41 байт для фіксації бісекції ( кашлю )
• -7 байтів безпосередньо та -16 опосередковано натхненні кодом @ ETHproductions
• -3 байти, замінивши strtrодним із моїх бітових жонглів

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;

Офіційно це перший раз, коли я використовую оператор нульового згортання. Бігайте з -r.

PHP 7.1

Негативні зміщення рядків у майбутній версії PHP заощадять 12 байт:
Замініть strlen($s=$argv[1])на 0і $sна $argv[1].

Безкоштовні байти для (майже) кожного:

• Обчислення 0,1,2,3 замість 0,90,180,270 та помноження кінцевого результату на 90 дозволить заощадити два байти і, ймовірно, дозволить подальший гольф.
• У кодах ASCII символів є деякі візерунки. Спробуйте один із них мовою:
  • (a/2%6+2)%5
  • a<87?a/2&3^3:3 або a/2&3^3*(a<87)
  • a&1?a&2|a/4&1:0
  • a/.8-1&3

Python 3, 133 113 байт

Просто покращую відповідь на @ L3viathan, тому що я щойно зробив цей обліковий запис і тому поки що не можу коментувати.

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 байти

Збережено 6 байт завдяки Еміньї. Збережено 5 байт завдяки ідеї Тіта працювати в діапазоні [0,4] та помножувати на 90 наприкінці. Збережено 5 байт завдяки майстерності Аднана в античній метаморфозі XOR / модуля.

Таким чином, кожен кут зменшується від діапазону [0,360 [до діапазону [0,4] протягом усього виконання. Потім результат множать на 90 і відображають.

Ç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

Спробуйте в Інтернеті!

Потенційні осі гольфу:

• Не впевнений, чи потрібен цей мод 4 (він би заощадив 2 байти). Усі тестові справи працюють без цього, але, можливо, існує хитра справа. Математичний доказ або підтвердити його, або скасувати це було б найкращим.
• Немає неявного матеріалу, окрім відображення результату (закриття лапок, закриття дужок).

Python 3, 146 145 117 107 97 94 93 92 байт

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

Дзвінок fза допомогою рядка.

C, 184 байти

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

Безумовно

// 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 байт

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)

Безумовно

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

Пояснив

1. Прочитайте введення з stdin
   • Збіг введення за індексом до c("N","E","S","W")
   • Із відповідних індексів: відповідність вектору градусів 0:3*90(замість c(0,90,180,270))
   • Зворотний і зберігати як z
2. Ініціалізуйте pдо ступеня, еквівалентної останньому знаку введення
3. Зберегти довжину введення як l
4. Ітеративно обчисліть найближчий з двох можливих розрізних підшипників.
5. Якщо вказано лише один вхід, встановіть pзначенняz
6. Форматування та друк

Спробуйте тестові випадки на R-скрипці (зауважте, що це функція через те, що scanне працює над R-скрипкою)

Haskell, 109 105 103 байт

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

Дякую за -2 байт @xnor!

Діалог APL , 55 45 38 байт

Рішення

Вимагає ⎕IO←0, що для багатьох систем за замовчуванням. Запитує напрямок.

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

Пояснення

Вирішує проблему, перетворюючи кожну букву на комплексну цифру 1∠ θ ⇔ a + b · i , після чого виконуючи зменшення суми справа наліво (форте APL) при нормалізації на кожному кроці. Кінцевий θ перетворюється на градуси і нормалізується в межах [0, 360):

'NES'⍳⍞індекси кожної літери введення у "NES"; N → 0, E → 1, S → 2, все інше → 3

○2÷⍨перетворити на кути в радіанах; θ = π · ^x ∕ ₂

¯12○перетворити на складні числа на одиничному колі; e ^{i · θ}

(... )/зменшити список за допомогою ... (тобто вставити функцію між елементами ...)

 +÷(|+)... нормована сума; ^{x _{n - 1} + x _n} ∕ _{| x n - 1 + x n} |

12○перетворити на кут; θ

÷○÷180×конвертувати в градуси; ¹ ∕ _{π · ¹ ∕ 180 · x}

360| залишок ділення при поділі на 360

СпробуйтеAPL онлайн!

Анекдот

Якби вхід і вихід були ортогональними складними одиницями, все рішення було б просто:

(+÷(|+))/

Решта коду - це аналіз синтаксису введення та форматування.

Лист звичайний, 347 327 байт

Дякуємо @Titus за те, що зняв декілька

Напевно, це може бути більше гольфу, але принаймні це працює (я думаю):

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

Використання:

* (f "WNE")
337.50000
NIL

Функція dприймає символ N, E, Wабо Sі повертає відповідний ступінь. Функція mотримує відповідну комбіновану ступінь двох заданих напрямків. Функція fповторюється через наданий рядок, обчислює відповідний ступінь і друкує його як плаваючу точку.

Befunge, 183 181 175 байт

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

Спробуйте в Інтернеті!

Пояснення

Це дотримується аналогічного алгоритму для багатьох інших відповідей, тільки він використовує обчислення з фіксованою точкою, емільовані цілими числами, оскільки Befunge не підтримує плаваючу крапку.

Дякуємо @Titus за звичайну процедуру ASCII.

 ~ : 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 байт

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

Спробуйте в Інтернеті!