二维编程语言通常具有镜像命令，例如/和，\以重定向网格上的指令指针：

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

在此挑战中，您将获得一个传入方向和一个镜像，并且需要确定传出方向。

规则

传入方向将被指定为字符之一，NESW而镜像将被指定为/或\。您可以按任何顺序收到这些。您必须使用大写字母。

您可以采用任何方便的格式输入，包括两个字符的字符串，在字符之间使用一些分隔符的字符串，列表中的一对字符，甚至一对单例字符串。如果确实使用带分隔符的字符串，则分隔符不能使用任何字符NWSE\/。

输出应为一个字符NESW或单个字符的字符串。

您可以编写程序或函数，并使用我们的任何标准方法来接收输入和提供输出。

您可以使用任何编程语言，但是请注意，默认情况下，这些漏洞是禁止的。

这是代码高尔夫球，因此以字节为单位的最短有效答案为准。

测试用例

您只需要处理8种可能的输入，因此没有理由不对所有代码进行测试：

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

Python，40 38字节

-2个字节，感谢@MitchSchwartz- (ord(d)+ord(m))%8>ord(d)+ord(m)&7

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

以有效的序数总和的最小mod索引的列表（AKA字符串）中的答案的简单查找。

测试用例在ideone上

Python 2，40个字节

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

Sp3000保存了一个字节（.index→ .find）。

说明

我们想要这样映射方向：

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

我们可以为方向分配2位代码，并在对第一位和第二位进行XOR运算的同时查看两个翻转：

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

位字符串和方向之间的映射使用字符串发生k。现在我们只需要映射镜像字符'/'并映射'\\'到值1和2。由于'/' < '\\'，我们可以天真地(m>'/')+1用作公式。可是等等！从词法上讲，

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

并且我们已经'NWES'很好地分配给了k！因此我们可以(m>k)+1改用。

CJam，14个字节

（@MartinEnder移植了我的Python答案）

l1b" NESSWNW"=

怎么样？

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

测试在aditsu

Javascript（ES6），50 41 40 37字节

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

多亏Lynn的回答，通过比较节省了3个字节

用法

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字节

'NWSE'jy&mjy+Eq-)

在线尝试！还是核实这八种情况。

说明

'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字节

感谢@Jakube和@Maltysen每个-1个字节

@J"NWES"xxJQh>E

该程序接受两个换行符分隔的带引号的字符串的输入，首先输入方向，然后输入镜像，然后打印结果。

这是@Lynn的Python 答案的端口。

在线尝试

怎么运行的

@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个字节

‘€Ã‘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               

在线尝试！

果冻，14 13 12 字节

（我的Python回答的端口）
@MartinEnder，感谢-1个字节（在字符串末尾添加一个空格，消除对模8的需要）
感谢@LuisMendo，感谢-1个字节（接受一个字符串参数，而不是两个字符串）

OSị“NESSWNW 

怎么样？

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)

在TryItOnline上测试

Java 7、71 70 68字节

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

太可惜了charAt，indexOf占用了太多字节。

取消测试和所有测试用例：

在这里尝试。

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', '\\') + " ");
  }
}

输出：

W E S N E W N S

Python，63 61 59字节

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

很简单 绝对可以打更多的高尔夫球。决定是要在输入的索引中添加1还是-1 'NESW'。

这是一个lambda表达式；要使用它，请给它加上前缀f=。

伊迪恩！

Java 8，62 58 56字节

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

非高尔夫测试程序

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个字节

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

将输入作为两个显式chars，输出a char。

它的工作原理如下：如果对输出进行排序，我们希望S /以某种方式等于N \，W /等于E \等，或者至少产生“足够接近”但仍然不同的数字。如果我们查看ASCII值，则会得到一个如下表：

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

在sumsums列上运行一个快速暴力破解程序（从求和输入的ASCII码点求和）表明，如果我们对求和模取模8，我们将得到以下结果2 2 | 6 1 | 3 4 | 5 7。这在字符串中得到了证明"xNESSWNW"，正如E在index处2，N在6和处一样1，依此类推。

因此，我们只需要对输入求和（隐式地转换为从char到int32）%8，并采用that并将其用于索引到字符串中。

测试用例

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

批处理，111字节

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

接受W/作为两个字符的字符串命令行参数。该\和/使循环尴尬; 这将花费124个字节。

八度，30字节

使用与乔纳森·艾伦相同的论据顺序。

将输入作为两个字符的字符串'W\'。

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

在线尝试。

C，44， 35， 34个字节

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

它需要两个字符作为两个变量。它需要大小写。它使用很多位操作。片段a&a/2产生的值对于低两位具有唯一的值，&3将所有高位切掉。它用作\镜像的字符串“ NWES”的索引。幸运的是，ASCII字符的低两位\和/分别为00和11，这是完美的XOR与上述索引以获得为正确的方向/反射镜。

CJam，17个字节

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

输入以空格分隔。

在线尝试！（作为换行分隔的测试套件。）

这是我在发布挑战之前找到的解决方案。不像乔纳森（Jonathan）的循环索引那么短，但是我认为这种方法非常有趣（而且新颖）。

说明

目标是使用音译（即使用字符到字符映射）将输入字符替换为输出字符。为此，我们需要根据镜子是/还是来选择正确的地图\。我们将从SWEN列表中映射到我们将有条件选择的另一个列表。如果输入列表为SWEN，则两个输出映射必须为以下内容：

in  SWEN
/   ENSW
\   WSNE

请注意，它们是按排序和反向排序的顺序（这就是为什么我们选择看似随机的SWEN顺序作为输入集的原因）。我们可以通过对输入列表进行排序并在输入具有时反转结果来生成这些\，但是有更好的方法：

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对于-r）43

感谢Martin Ender节省了5

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

将输入作为两个字符串。

Mathematica，98个字节

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

匿名函数。将两个字符串作为输入，并返回一个字符串作为输出。

C，81个字节

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

用法

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\\"));
}

输出：

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

Pyth，13个字节

@."EW¹0`Y"sCM    

测试套件

将代码点，模块化索引和压缩字符串相加。

TI基本（40字节）

硬编码输入。无聊，但最短的方法。

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