Cho một chuỗi N, S, E và W, xuất ra một ổ trục (góc theo chiều kim đồng hồ từ Bắc tính theo độ), chính xác đến 5 chữ số thập phân.

Trong ký hiệu la bàn truyền thống , một chuỗi chỉ gồm 2 ký tự này (như NNW hoặc ESE). Tại đây, bạn cũng phải chấp nhận các chuỗi chứa cả 4 (như WNNNSE) . Chỉ sử dụng 2 biểu tượng cho phép con người hiểu trực giác về ý nghĩa. Cho phép 4 biểu tượng làm cho nó thật kinh khủng khi đọc, nhưng cho phép các cách ngắn hơn để mô tả một ổ trục với độ chính xác nhất định.

(Như đã chỉ ra trong ý kiến của user2357112 , nó quay ra bạn có thể chứng minh rằng đối với bất kỳ mang nhất định, chuỗi 4 biểu tượng sẽ được chính xác độ dài tương tự như chuỗi 2 biểu tượng, vì vậy tôi đã dựa thách thức này trên một giả định sai. Hy vọng rằng việc thiếu mục đích thực tế này sẽ không làm giảm sự thích thú của bạn đối với thử thách ...)

Phương pháp chính xác được mô tả dưới đây và tương đương với ký hiệu truyền thống (nó mở rộng trên đó thay vì thay đổi nó).

Đầu vào

• Đầu vào là một chuỗi duy nhất chỉ chứa các ký tự NESW.
• Đầu vào có thể là một chuỗi các ký tự nếu bạn thích, miễn là điều này không bao gồm bất kỳ quá trình tiền xử lý nào. Ví dụ: [N, [E, [S, [W]]]]không được phép lấy danh sách lồng nhau để giúp xử lý thứ tự xử lý.
• Lấy các ký tự khác nhau là không được phép. Bạn có thể không lấy một chuỗi 1234thay vì NESW.

Đầu ra

• Đầu ra phải là số thập phân hoặc biểu diễn chuỗi của một (không phải là số hữu tỷ / phần).
• Số không lưu trữ không cần phải được hiển thị. Nếu ổ trục là 9.00000, thì đầu ra 9cũng được tính là chính xác đến 5 chữ số thập phân.
• Đầu ra nằm trong phạm vi [0, 360). Đó là, bao gồm 0 nhưng không bao gồm 360.
• Độ chính xác được kiểm tra bằng cách làm tròn đầu ra đến 5 chữ số thập phân. Nếu ổ trục là 0,000005, vòng này đến 0,00001. Đầu ra 0,00001 và 0,000005 đều đúng.
• Đầu ra trong ký hiệu khoa học cho một số đầu vào là chấp nhận được. Ví dụ, 1e-5thay vì 0.00001.

Chuyển đổi

• Các ký tự đơn la bàn điểm N, E, S, và Wtương ứng với 0, 90, 180, và 270 độ tương ứng.
• Chuẩn bị một trong những thứ này cho một chuỗi dẫn đến ổ trục chia đôi ổ đỡ của ký tự đơn và ổ trục của chuỗi gốc.
• Gần nhất trong hai vòng bi chia đôi có thể được chọn, sao cho NE đại diện cho 45 độ, không phải 225 độ.
• Điều này không rõ ràng trừ trường hợp góc bị cắt là 180 độ. Do đó NS, SN, WE, và EWtương ứng với ổ trục undefined, và đầu vào sẽ không bao giờ kết thúc trong bất kỳ trong số này. Tuy nhiên, chúng có thể xuất hiện ở bất kỳ nơi nào khác trong chuỗi đầu vào, vì điều này không gây ra sự mơ hồ.
• Nếu hai ký tự cuối cùng giống hệt nhau, ký tự cuối cùng sẽ là dự phòng vì phép chia sẽ trả về cùng một mang. Vì điều này không thêm gì vào ký hiệu, mã của bạn không cần xử lý việc này. Do đó NN, EE, SS, và WWtương ứng với ổ trục undefined, và đầu vào sẽ không bao giờ kết thúc trong bất kỳ trong số này. Tuy nhiên, chúng có thể xuất hiện ở bất kỳ nơi nào khác trong chuỗi đầu vào.

Ví dụ

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

Các trường hợp thử nghiệm

Một đệ trình chỉ có hiệu lực nếu nó cung cấp đầu ra chính xác cho tất cả các trường hợp thử nghiệm. Lưu ý rằng các trường hợp thử nghiệm đẩy đến giới hạn của những gì có thể được xử lý với độ chính xác gấp đôi. Đối với các ngôn ngữ mặc định với độ chính xác đơn, có lẽ bạn sẽ cần phải sử dụng các byte để chỉ định độ chính xác kép để có được đầu ra chính xác.

Kết quả đầu ra của trường hợp thử nghiệm được hiển thị làm tròn đến 5 chữ số thập phân và độ chính xác tùy ý. Cả hai đều là đầu ra hợp lệ.

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

Chấm điểm

Đây là mã golf . Điểm số là độ dài của mã nguồn tính bằng byte và chiến thắng ngắn nhất.

^{Nhà sư phạm}

<sup>Tôi đã phạm sai lầm khi nghĩ rằng "North by North West" là một hướng la bàn hợp lệ. Một sai lầm hạnh phúc, vì nó đã dẫn đến một ý tưởng thách thức, nhưng sau đó tôi đã phát hiện ra từ trang Wikipedia :

"Tiêu đề của bộ phim Alfred Hitchcock 1959, North by Northwest, thực sự không phải là một hướng trên la bàn 32 gió, mà là bộ phim có liên quan đến hãng hàng không Tây Bắc. "

Nó cũng chỉ ra rằng phương pháp được sử dụng cho thử thách này chỉ phù hợp với các điểm la bàn truyền thống lên đến và bao gồm cả la bàn 16 điểm. La bàn 32 gió được mô tả trên trang đó rất khác biệt và tôi đã thuận tiện bỏ qua sự tồn tại của nó cho thử thách này.

Cuối cùng, đối với bất cứ ai nghĩ rằng tôi nên sử dụng "Đông Nam" thay vì "Đông Nam",.</sup>

JavaScript (ES6), 84 80 78 74 72 byte

Đã lưu một byte nhờ @Titus, 1 nhờ @Neil

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

Mất một lúc, nhưng tôi nghĩ cuối cùng tôi cũng đã hoàn thiện công thức ...

Kiểm tra đoạn

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)

Giải trình

Hãy bắt đầu với trường hợp đơn giản nhất: một chuỗi char đơn. Kết quả chỉ đơn giản là vị trí (được lập chỉ mục 0) của nó trong chuỗi NESW, nhân với 90.

Đối với chuỗi hai char, kết quả nằm ở giữa kết quả của char thứ nhất và kết quả của chuỗi thứ hai. Tuy nhiên, có một nhược điểm: nếu chênh lệch tuyệt đối giữa hai giá trị lớn hơn 180 (ví dụ NWhoặc WN), chúng ta phải 180 theo góc để nó không chỉ hướng ngược lại.

Đối với bất kỳ chuỗi nào dài hơn, kết quả nằm ở giữa kết quả của char đầu tiên và kết quả của phần còn lại của chuỗi. Điều này có thể được khái quát theo cách sau:

• Nếu đầu vào là một char duy nhất, hãy trả về chỉ mục của nó trong chuỗi NESWlần 90.
• Mặt khác, trả về chỉ mục của char đầu tiên trong chuỗi NESWlần 45, cộng với một nửa kết quả của phần còn lại của chuỗi; thêm 180 nếu chênh lệch tuyệt đối giữa hai lớn hơn 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);

Chỉnh sửa: -10 byte bằng cách "mượn" ý tưởng từ đệ trình của ETHproductions
-22 byte nhờ @Titus

Ung dung

// 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 với toán tử hợp nhất null
• -2 byte bằng cách không thay thế N(và hơn thế nữa, vì điều đó cho phép đặt bản dịch vào đầu vòng lặp: Nlà trung thực, nhưng 0được ước tính trong tính toán.)
• +41 byte để sửa lỗi chia đôi ( ho )
• -7 byte trực tiếp và -16 được lấy cảm hứng gián tiếp từ mã @ ETHproductions
• -3 byte bằng cách thay thế strtrbằng một trong những trò tung hứng bit của tôi

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;

Đây chính thức là lần đầu tiên tôi sử dụng toán tử hợp nhất null. Chạy với -r.

PHP 7.1

Việc bù chuỗi âm trong phiên bản PHP sắp tới sẽ tiết kiệm được 12 byte:
Thay thế strlen($s=$argv[1])bằng 0và $sbằng $argv[1].

Byte miễn phí cho (hầu hết) mọi người:

• Tính toán với 0,1,2,3 thay vì 0,90,180,270 và nhân kết quả cuối cùng với 90 sẽ tiết kiệm được hai byte và có thể cho phép chơi gôn thêm.
• Có một số mẫu trong mã ASCII của các ký tự. Hãy thử một trong những thứ này bằng ngôn ngữ của bạn:
  • (a/2%6+2)%5
  • a<87?a/2&3^3:3 hoặc là a/2&3^3*(a<87)
  • a&1?a&2|a/4&1:0
  • a/.8-1&3

Python 3, 133 113 byte

Chỉ cần cải thiện câu trả lời của @ L3viathan vì tôi mới tạo tài khoản này và do đó chưa thể đưa ra nhận xét nào.

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

Đã lưu 6 byte nhờ Emigna. Đã lưu 5 byte nhờ ý tưởng của Titus để hoạt động trên phạm vi [0,4 [và nhân với 90 ở cuối. Đã lưu 5 byte nhờ sự thông thạo của biến thái xor / modulo cổ đại của Adnan.

Vì vậy, mọi góc được giảm từ phạm vi [0,360 [xuống phạm vi [0,4 [trong suốt quá trình thực hiện. Kết quả sau đó được nhân với 90 và hiển thị.

Ç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

Hãy thử trực tuyến!

Các trục tiềm năng của việc chơi golf:

• Không chắc chắn nếu mod 4 được yêu cầu (nó sẽ tiết kiệm 2 byte). Tất cả các trường hợp thử nghiệm hoạt động mà không có nó, nhưng có thể tồn tại một trường hợp khó khăn. Một bằng chứng toán học để xác nhận nó hoặc vô hiệu hóa nó sẽ là đỉnh cao.
• Không có nội dung ngầm ngoài việc hiển thị kết quả (đóng dấu ngoặc kép, đóng ngoặc).

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

Gọi fvới chuỗi.

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

Ung dung

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

Ung dung

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

Giải thích

1. Đọc đầu vào từ stdin
   • Khớp đầu vào theo chỉ mục với c("N","E","S","W")
   • Từ các chỉ số phù hợp: khớp với vectơ độ 0:3*90(thay vì c(0,90,180,270))
   • Đảo ngược và lưu trữ như z
2. Khởi tạo pmức độ tương đương với char cuối cùng trong đầu vào
3. Lưu trữ thời lượng đầu vào như l
4. Lặp lại, tính toán gần nhất của hai vòng bi chia đôi có thể.
5. Nếu chỉ có một đầu vào được đặt, đặt pthànhz
6. Định dạng và in

Hãy thử các trường hợp thử nghiệm trên R-fiddle (lưu ý rằng đây là chức năng do scankhông hoạt động trên 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

Cảm ơn -2 byte @xnor!

APL Dyalog , 55 45 38 byte

Dung dịch

Yêu cầu ⎕IO←0, được mặc định trên nhiều hệ thống. Hỏi hướng.

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

Giải trình

Đi xung quanh vấn đề bằng cách chuyển đổi mỗi bức thư cho một số phức tạp 1∠ q ⇔ một + b · i , sau đó làm giảm tổng từ phải sang trái (sở trường của APL) trong khi bình thường hóa tại mỗi bước. Trận chung kết θ sau đó được chuyển đổi sang độ và bình thường là trong vòng [0, 360):

'NES'⍳⍞các chỉ số của từng chữ cái đầu vào trong "NES"; N → 0, E → 1, S → 2, bất cứ điều gì khác → 3

○2÷⍨chuyển đổi thành các góc theo radian; θ = π · ^x ∕ ₂

¯12○chuyển đổi thành số phức trên vòng tròn đơn vị; e ^{i ·}

(... )/giảm danh sách bằng ... (tức là chèn hàm giữa các thành phần của ...)

 +÷(|+)... tổng bình thường; ^{x _{n - 1} + x _n} ∕ _{| x n - 1 + x n} |

12○chuyển đổi thành góc; θ

÷○÷180×chuyển đổi sang độ; ¹ ∕ _{π · ¹ ∕ 180 · x}

360| phần còn lại khi chia cho 360

Dùng thử trực tuyến!

Giai thoại

Nếu đầu vào và đầu ra là các đơn vị phức tạp trực giao, toàn bộ giải pháp sẽ chỉ là:

(+÷(|+))/

Phần còn lại của mã là phân tích cú pháp đầu vào và định dạng đầu ra.

Lisp thường gặp, 347 327 byte

Cảm ơn @Titus đã cất cánh

Điều này có thể có thể được đánh gôn nhiều hơn, nhưng ít nhất nó hoạt động (tôi nghĩ):

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

Sử dụng:

* (f "WNE")
337.50000
NIL

Chức năng dmất một nhân vật N, E, W, hay Svà trả về mức độ thích hợp. Hàm mđược mức độ kết hợp chính xác của hai hướng cho trước. Hàm flặp qua chuỗi được cung cấp, tính toán mức độ phù hợp và in nó dưới dạng dấu phẩy động.

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

Hãy thử trực tuyến!

Giải trình

Điều này tuân theo một thuật toán tương tự với nhiều câu trả lời khác, chỉ có điều nó sử dụng các phép tính điểm cố định được mô phỏng bằng các số nguyên do Befunge không hỗ trợ dấu phẩy động.

Cảm ơn @Titus về thói quen ASCII-to-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'⍳⎕

Hãy thử trực tuyến!