Các ngôn ngữ lập trình hai chiều thường có các lệnh nhân bản như /và \để chuyển hướng con trỏ lệnh trên lưới:

>>>>\
    v
    v
<<<</

Trong thử thách này, bạn được cung cấp một hướng đến và một tấm gương và bạn cần xác định hướng đi.

Quy tắc

Hướng đến sẽ được đưa ra là một trong các ký tự NESWvà gương sẽ được cung cấp dưới dạng /hoặc \. Bạn có thể nhận được những thứ này theo bất kỳ thứ tự nào. Bạn phải sử dụng chữ in hoa.

Bạn có thể nhập dữ liệu ở bất kỳ định dạng thuận tiện nào, bao gồm chuỗi hai ký tự, chuỗi sử dụng dấu phân cách giữa các ký tự, một cặp ký tự trong danh sách hoặc thậm chí một cặp chuỗi đơn. Nếu bạn sử dụng một chuỗi có dấu phân cách, thì dấu phân cách không thể sử dụng bất kỳ ký tự nào NWSE\/.

Đầu ra phải là một ký tự từ NESWhoặc chuỗi ký tự đơn.

Bạn có thể viết chương trình hoặc chức năng và sử dụng bất kỳ phương pháp tiêu chuẩn nào để nhận đầu vào và cung cấp đầu ra.

Bạn có thể sử dụng bất kỳ ngôn ngữ lập trình nào , nhưng lưu ý rằng các lỗ hổng này bị cấm theo mặc định.

Đây là môn đánh gôn , vì vậy câu trả lời hợp lệ ngắn nhất - được đo bằng byte - thắng.

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

Chỉ có 8 đầu vào khả dĩ bạn cần xử lý, vì vậy không có lý do gì để không kiểm tra mã của bạn trên tất cả chúng:

N /   -->   W
N \   -->   E
E /   -->   S
E \   -->   N
S /   -->   E
S \   -->   W
W /   -->   N
W \   -->   S

Python, 40 38 byte

-2 byte nhờ @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

lambda d,m:' NESSWNW'[ord(d)+ord(m)&7]

tra cứu đơn giản câu trả lời trong một danh sách (chuỗi AKA) được lập chỉ mục bởi mod nhỏ nhất trong tổng số thứ tự hoạt động.

Các trường hợp thử nghiệm là trên ideone

Python 2, 40 byte

lambda c,m,k="NWES":k[k.find(c)^(m>k)+1]

Sp3000 đã lưu một byte ( .index→ .find).

Giải trình

Chúng tôi muốn lập bản đồ chỉ đường như vậy:

       \
  N ⇄⇄⇄⇄⇄⇄⇄ E
  ⇅         ⇅
  ⇅         ⇅
/ ⇅         ⇅ /
  ⇅         ⇅
  ⇅         ⇅
  W ⇄⇄⇄⇄⇄⇄⇄ S
       \

Chúng ta có thể chỉ định mã 2 bit và xem cả hai lần lật là XOR-ing các bit thứ nhất và thứ hai:

         xor 2
     0 0 ⇄⇄⇄⇄⇄ 1 0
      ⇅         ⇅
      ⇅         ⇅
xor 1 ⇅         ⇅ xor 1
      ⇅         ⇅
      ⇅         ⇅
     0 1 ⇄⇄⇄⇄⇄ 1 1
         xor 2

Ánh xạ giữa các chuỗi bit và hướng xảy ra bằng cách sử dụng chuỗi k. Bây giờ chúng ta chỉ cần ánh xạ các ký tự nhân bản '/'và '\\'các giá trị 1và 2. Kể từ đó '/' < '\\', chúng tôi có thể sử dụng (m>'/')+1một cách ngây thơ như một công thức. Nhưng chờ đã! Thuật ngữ học,

'/' < 'NWES' < '\\'

và chúng tôi đã 'NWES'được chỉ định độc đáo k! Vì vậy, chúng ta có thể sử dụng (m>k)+1thay thế.

CJam, 14 byte

(@MartinEnder chuyển câu trả lời Python của tôi )

l1b" NESSWNW"=

Làm sao?

l1b" NESSWNW"= -
l              - read input
 1b            - cast characters as base 1 digits
   " NESSWNW"  - the string " NESSWNW"
             = - modulo index into the string

Các thử nghiệm trên aditsu

Javascript (ES6), 50 41 40 37 byte

d=>m=>(S="NWES")[S.search(d)^-~(m>S)]

Đã lưu thêm 3 byte bằng cách sử dụng so sánh, nhờ câu trả lời của Lynn

Sử dụng

let f =
d=>m=>(S="NWES")[S.search(d)^-~(m>S)]

console.log(f("N")("/"));  //   -->   W
console.log(f("N")("\\")); //   -->   E
console.log(f("E")("/"));  //   -->   S
console.log(f("E")("\\")); //   -->   N
console.log(f("S")("/"));  //   -->   E
console.log(f("S")("\\")); //   -->   W
console.log(f("W")("/"));  //   -->   N
console.log(f("W")("\\")); //   -->   S

MATL , 19 17 byte

'NWSE'jy&mjy+Eq-)

Hãy thử trực tuyến! Hoặc xác minh tám trường hợp .

Giải trình

'NWSE'    % Push this string
j         % Take first input, say 'W'. Stack contains: 'NWSE', 'W'
y         % Duplicate from below. Stack: 'NWSE', 'W', 'NWSE'
&m        % Index of membership. Stack: 'NWSE', 2
j         % Take second input, say '/'. Stack: 'NWSE', 2, '/'
y         % Duplicate from below. Stack: 'NWSE', 2, '/', 2
+         % Add (char '/' is converted to code point). Stack: 'NWSE', 2, 49 
Eq        % Multiply by 2, subtract 1. Stack: 'NWSE', 2, 97
-         % Subtract. Stack: 'NWSE', -95
)         % Apply -95 as (modular, 1-based) index into 'NWSE'. Stack: 'N'
          % Implicitly display

Pyth, 17 16 15 byte

Cảm ơn @Jakube và @Maltysen cho -1 byte mỗi

@J"NWES"xxJQh>E

Một chương trình lấy đầu vào của hai chuỗi trích dẫn được phân tách bằng dòng mới, đầu tiên là hướng và sau đó là gương và in kết quả.

Đây là một cổng của câu trả lời Python của @ Lynn .

Dùng thử trực tuyến

Làm thế nào nó hoạt động

@J"NWES"xxJQh>E  Program. Inputs: Q, E
 J"NWES"         J="NWES". Yield J
         xJQ     J.index(Q)
             >E  E>Q, lexographically (implicit input fill)
            h    +1
        x        Bitwise XOR of the above two
@                Index into J with the above
                 Implicitly print

05AB1E , 14 byte

‘€Ã‘DIkI'/kÌ^è

‘€Ã‘             # from string "NEWS"
             è   # get element at index
    DIk          # index of 1st input in string "NEWS"
            ^    # XOR
       I'/k      # index of 2nd input in string "/"
           Ì     # +2               

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

Thạch , 14 13 12 byte

(một cổng của câu trả lời Python của tôi )
-1 byte nhờ vào @MartinEnder (thêm khoảng trắng vào cuối chuỗi và loại bỏ nhu cầu về modulo 8)
-1 byte nhờ @LuisMendo (lấy một đối số chuỗi thay vì hai)

OSị“NESSWNW 

Làm sao?

OSị“NESSWNW  - takes a single argument "dm" (direction and mirror), in either order.
                   strings and lists are equivalent in Jelly
 O            - ordinal: [ord(d),ord(m)]
  S           - sum: ord(d)+ord(m)
    “NESSWNW  - string: "NESSWNW "
   ị          - fetch modulo index (the string is 8 long and 1-based)

Kiểm tra nó trên TryItOnline

Java 7, 71 70 68 byte

char c(int d,int m){return"NEWS".charAt("NEWS".indexOf(d)^-~(m%2));}

Quá tệ charAtvà indexOfchiếm quá nhiều byte ..

Ungolfed & tất cả các trường hợp thử nghiệm:

Hãy thử nó ở đây.

class M{
  static char c(int d, int m) {
    return "NEWS".charAt("NEWS".indexOf(d) ^ -~(m%2));
  }

  public static void main(String[] a){
    System.out.print(c('N', '/') + " ");
    System.out.print(c('N', '\\') + " ");
    System.out.print(c('E', '/') + " ");
    System.out.print(c('E', '\\') + " ");
    System.out.print(c('S', '/') + " ");
    System.out.print(c('S', '\\') + " ");
    System.out.print(c('W', '/') + " ");
    System.out.print(c('W', '\\') + " ");
  }
}

Đầu ra:

W E S N E W N S

Python, 63 61 59 byte

lambda d,m,x='NESW'*2:x[x.find(d)+2*(m=='/\\'[d in'NS'])-1]

Khá đơn giản. Chắc chắn có thể được chơi golf nhiều hơn. Quyết định nên thêm 1 hoặc -1 vào chỉ mục của đầu vào 'NESW'.

Đây là một biểu thức lambda; để sử dụng nó, tiền tố nó với f=.

Nghĩa là nó!

Java 8, 62 58 56 byte

(d,m)->"SEWN".charAt("NWES".indexOf(d)^m.indexOf(47)+2);

Chương trình thử nghiệm

import java.util.function.BiFunction;

public class Mirror {

public static void main(String[] args) {
    BiFunction<String, String, Character> function = (d,m)->"SEWN".charAt("NWES".indexOf(d)^m.indexOf(47)+2);

    System.out.println(function.apply("N", "/")); //W
    System.out.println(function.apply("N", "\\")); //E
    System.out.println(function.apply("W", "/")); //N
    System.out.println(function.apply("W", "\\")); //S
    System.out.println(function.apply("E", "/")); //S
    System.out.println(function.apply("E", "\\")); //N
    System.out.println(function.apply("S", "/")); //E
    System.out.println(function.apply("S", "\\")); //W
}

}

PowerShell v2 +, 34 byte

param($a,$b)"xNESSWNW"[(+$a+$b)%8]

Lấy đầu vào là hai chars rõ ràng , đầu ra a char.

Điều này hoạt động như sau: Nếu chúng tôi sắp xếp đầu ra, chúng tôi muốn S / bằng cách nào đó giống như N \, W /bằng nhau E \, v.v. Hoặc, ít nhất, tạo ra các số "đủ gần" nhưng vẫn khác biệt. Nếu chúng ta nhìn vào các giá trị ASCII, chúng ta sẽ nhận được một bảng như dưới đây:

In1   In2       Res.    Sum
S 83  / 47  --> E 69 -> 130
N 78  \ 92  --> E 69 -> 170
W 87  / 47  --> N 78 -> 134
E 69  \ 92  --> N 78 -> 161
W 87  \ 92  --> S 83 -> 179
E 69  / 47  --> S 83 -> 116
N 78  / 47  --> W 87 -> 125
S 83  \ 92  --> W 87 -> 175

Chạy một trình duyệt nhanh chóng trên cột tổng (xuất phát từ tổng các điểm mã ASCII của các đầu vào) cho thấy rằng nếu chúng ta lấy tổng số modulo 8 , chúng ta sẽ nhận được như sau 2 2 | 6 1 | 3 4 | 5 7. Điều đó được chứng minh trong chuỗi "xNESSWNW", như Etại chỉ mục 2, Nlà tại 6và 1, v.v.

Vì vậy, chúng ta chỉ cần tổng hợp các yếu tố đầu (ngầm đúc từ charđể int32trên đường đi), đi mà %8, và sử dụng rằng chỉ mục vào chuỗi của chúng tôi.

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

PS C:\Tools\Scripts\golfing> ('N','/'),('N','\'),('E','/'),('E','\'),('S','/'),('S','\'),('W','/'),('W','\')|%{"$($_[0]) $($_[1]) --> "+(.\mirror-mirror-in-the-code.ps1 ([char]$_[0]) ([char]$_[1]))}
N / --> W
N \ --> E
E / --> S
E \ --> N
S / --> E
S \ --> W
W / --> N
W \ --> S

Mẻ, 111 byte

:goto %1
:W/
:E\
@echo N
@exit/b
:S/
:N\
@echo E
@exit/b
:E/
:W\
@echo S
@exit/b
:N/
:S\
@echo W

Chấp nhận ví dụ W/như một tham số dòng lệnh hai ký tự. Các \và /làm cho vòng lặp vụng về; nó sẽ mất 124 byte.

Octave, 30 byte

Sử dụng thứ tự lập luận tương tự như Jonathan Allan.

Lấy đầu vào là chuỗi hai ký tự 'W\'.

@(x)['NESSWNW'](mod(sum(x),8))

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

C, 44, 35, 34 byte

f(a,b){return"NWES"[a&a/2&3^b&3];}

Nó đòi hỏi hai ký tự là hai biến. Nó có cả chữ thường và chữ hoa Nó sử dụng rất nhiều thao tác bit. Đoạn này a&a/2dẫn đến một giá trị có các giá trị duy nhất cho hai bit thấp hơn, &3cắt bỏ tất cả các bit cao hơn. Điều này được sử dụng như là một chỉ mục vào chuỗi "NWES" cho \gương. May mắn thay, hai bit thấp hơn của các ký tự ASCII \và /lần lượt là 00 và 11, hoàn hảo với XOR với chỉ số đã nói ở trên để có được hướng chính xác cho /gương.

CJam , 17 byte

r"SWEN"_e!r'/#=er

Đầu vào được phân tách bằng không gian.

Hãy thử trực tuyến! (Là một bộ thử nghiệm được phân tách bằng nguồn cấp.)

Đây là giải pháp tôi tìm thấy trước khi đăng tải thử thách. Không ngắn như lập chỉ mục theo chu kỳ của Jonathan, nhưng tôi nghĩ cách tiếp cận này khá thú vị (và tiểu thuyết).

Giải trình

Mục tiêu là sử dụng chuyển ngữ (nghĩa là sử dụng ánh xạ ký tự sang ký tự) để thay thế ký tự đầu vào bằng ký tự đầu ra. Để làm điều này, chúng ta cần chọn bản đồ chính xác dựa trên việc gương là /hay \. Chúng tôi sẽ ánh xạ từ SWENdanh sách này sang danh sách khác mà chúng tôi sẽ chọn theo điều kiện. Nếu danh sách đầu vào là SWEN, hai bản đồ đầu ra cần phải như sau:

in  SWEN
/   ENSW
\   WSNE

Lưu ý rằng đây là những thứ tự được sắp xếp và sắp xếp ngược (đó là lý do tại sao chúng tôi chọn SWENthứ tự dường như ngẫu nhiên làm bộ đầu vào). Chúng ta có thể tạo ra những thứ này bằng cách sắp xếp danh sách đầu vào và đảo ngược kết quả nếu đầu vào có \, nhưng có một cách tốt hơn:

r       e# Read incoming direction.
"SWEN"  e# Push input list for transliteration.
_e!     e# Duplicate and get all permutations. The way, `e!` is implemented, it
        e# always gives the permutations in sort order, regardless of the order
        e# of the input set. Specifically that means that "ENSW" will be first
        e# and "WSNE" will be last in this list.
r       e# Read the mirror.
'/#     e# Find the index of / in this string. If the mirror is '/', then this
        e# gives 0. Otherwise, this gives -1, indicating that '/' was not found.
=       e# Select the corresponding permutation. Indexing is zero-based and
        e# cyclic so that 0 (input '/') gives the first permutation "ENSW" and
        e# -1 (input '\') gives the last permutation "WSNE".
er      e# Perform the transliteration on the incoming direction.
        e# Printing is implicit.

SED 48 (42 + 1 cho -r) 43

Đã cứu 5 nhờ Martin Ender ♦

s,N/|S\\,W,;s,E/|W\\,S,;s,N.|S/,E,;s,..,N,

Lấy đầu vào là một chuỗi hai ký tự.

Toán học, 98 byte

If[#2=="/",{"S",,,,,,,,,"W",,,,,"E",,,,"N"},{"N",,,,,,,,,"E",,,,,"W",,,,"S"}][[LetterNumber@#-4]]&

Chức năng ẩn danh. Lấy hai chuỗi làm đầu vào và trả về một chuỗi làm đầu ra.

C, 81 byte

f(char*a){return a!="N/"&a!="S\\"?a!="N\\"&a!="S/"?a!="W\\"&a!="E/"?78:83:69:87;}

Sử dụng

main()
{
    printf("N/ \t %c\n",f("N/"));
    printf("N\\\t %c\n",f("N\\"));
    printf("E/ \t %c\n",f("E/"));
    printf("E\\\t %c\n",f("E\\"));
    printf("S/ \t %c\n",f("S/"));
    printf("S\\\t %c\n",f("S\\"));
    printf("W/ \t %c\n",f("W/"));
    printf("W\\\t %c\n",f("W\\"));
}

Đầu ra:

N/      : W  
N\      : E  
E/      : S  
E\      : N  
S/      : E  
S\      : W  
W/      : N  
W\      : S  

Bình thường, 13 byte

@."EW¹0`Y"sCM    

Bộ kiểm tra

Tổng các điểm mã, chỉ số mô-đun, chuỗi nén.

TI-Basic, 40 byte

Hardcodes các đầu vào. Chán, nhưng con đường ngắn nhất.

sub("NEWS",1+int(inString("E/W\N\S/N/S\E\W/",Ans)/4),1