As linguagens de programação bidimensionais geralmente têm comandos de espelho como /e \para redirecionar o ponteiro de instruções na grade:

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

Neste desafio, você recebe uma direção de entrada e um espelho e precisa determinar a direção de saída.

Regras

A direção de entrada será dada como um dos caracteres NESWe o espelho será dado como /ou \. Você pode recebê-los em qualquer ordem. Você deve usar letras maiúsculas.

Você pode inserir dados em qualquer formato conveniente, incluindo uma sequência de dois caracteres, uma sequência usando algum separador entre os caracteres, um par de caracteres em uma lista ou até mesmo um par de sequências singleton. Se você usar uma seqüência de caracteres com separador, o separador não poderá usar nenhum dos caracteres NWSE\/.

A saída deve ser um caractere NESWou uma cadeia de caracteres únicos.

Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e saída.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.

Casos de teste

Existem apenas 8 entradas possíveis que você precisa manipular, portanto, não há desculpa para não testar seu código em todas elas:

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

Python, 40 38 bytes

-2 bytes graças a @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

pesquisa simples de resposta em uma lista (string AKA) indexada pelo menor mod da soma dos ordinais que funciona.

Os casos de teste são em ideone

Python 2, 40 bytes

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

O Sp3000 salvou um byte ( .index→ .find).

Explicação

Queremos mapear as direções da seguinte forma:

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

Podemos atribuir as direções códigos de 2 bits e visualizar os dois movimentos como XOR no primeiro e no segundo bits:

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

O mapeamento entre cadeias de bits e direções acontece usando a cadeia k. Agora só precisamos mapear caracteres de espelho '/'e '\\'os valores 1e 2. Desde então '/' < '\\', poderíamos ingenuamente usar (m>'/')+1como uma fórmula. Mas espere! Lexicograficamente,

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

e nós 'NWES'atribuímos muito bem a k! Então, podemos usar em seu (m>k)+1lugar.

CJam, 14 bytes

(@MartinEnder portou minha resposta em Python )

l1b" NESSWNW"=

Quão?

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

Os testes estão no aditsu

Javascript (ES6), 50 41 40 37 bytes

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

Economizou mais 3 bytes usando a comparação, graças à resposta de Lynn

Uso

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 bytes

'NWSE'jy&mjy+Eq-)

Experimente online! Ou verifique os oito casos .

Explicação

'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

Pitão, 17 16 15 bytes

Graças a @Jakube e @Maltysen por -1 byte cada

@J"NWES"xxJQh>E

Um programa que recebe entrada de duas seqüências de caracteres entre aspas separadas por nova linha, primeiro a direção e depois o espelho e imprime o resultado.

Esta é uma porta da resposta Python do @ Lynn .

Experimente online

Como funciona

@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 bytes

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

Experimente online!

Geléia , 14 13 12 bytes

(uma porta da minha resposta Python )
-1 byte graças a @MartinEnder (adicione um espaço no final da string e remova a necessidade do módulo 8)
-1 byte graças a @LuisMendo (use um argumento de string única em vez de dois)

OSị“NESSWNW 

Quão?

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)

Teste no TryItOnline

Java 7, 71 70 68 bytes

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

Pena que charAte indexOfocupa tantos bytes ..

Casos não testados e todos os testes:

Experimente aqui.

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

Saída:

W E S N E W N S

Python, 63 61 59 bytes

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

Bem simples. Definitivamente pode ser jogado mais. Decide se deve adicionar 1 ou -1 ao índice da entrada em 'NESW'.

Esta é uma expressão lambda; para usá-lo, prefixe-o com f=.

Ideone it!

Java 8, 62 58 56 bytes

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

Programa de teste ungolfed

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 bytes

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

Recebe a entrada como dois chars explícitos , produz a char.

Isso funciona da seguinte maneira: se classificarmos a saída, queremos, S /de alguma forma, igual a N \, W /igual a E \etc. etc. Ou, pelo menos, produzir números que sejam "próximos o suficiente" e ainda assim distintos. Se olharmos para os valores ASCII, obtemos uma tabela como a abaixo:

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

A execução rápida de um forçador bruto na coluna de somas (derivada da soma dos pontos de código ASCII das entradas) mostra que, se usarmos o módulo de somas 8, obtemos o seguinte 2 2 | 6 1 | 3 4 | 5 7. Isso é evidenciado na string "xNESSWNW", como Eestá no índice 2, Nestá em 6e 1, e assim por diante.

Então, só precisamos somar as entradas (convertendo implicitamente de charao int32longo do caminho), pegar isso %8e usá-lo para indexar em nossa string.

Casos de teste

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

Lote, 111 bytes

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

Aceita, por exemplo, W/como um parâmetro de linha de comando de cadeia de dois caracteres. O \e/ torna o loop estranho; levaria 124 bytes.

Oitava, 30 bytes

Usou a mesma ordem de argumentos que Jonathan Allan.

Toma a entrada como uma sequência de dois caracteres 'W\'.

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

Experimente online .

C, 44, 35, 34 bytes

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

Requer dois caracteres como duas variáveis. É preciso tanto maiúsculas e minúsculas. Ele usa muita manipulação de bits. O fragmento a&a/2resulta em um valor que possui valores exclusivos para os dois bits inferiores, &3corta todos os bits superiores. Isso é usado como um índice para a sequência "NWES" do \espelho. Felizmente, os dois bits inferiores dos caracteres ASCII \e /são 00 e 11 respectivamente, o que é perfeito para o XOR com o índice mencionado acima para obter a direção correta para o /espelho.

CJam , 17 bytes

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

A entrada é separada por espaço.

Experimente online!(Como um conjunto de testes separado por avanço de linha.)

Essa é a solução que encontrei antes de postar o desafio. Não é tão curto quanto a indexação cíclica de Jonathan, mas achei que essa abordagem é bastante interessante (e inovadora).

Explicação

O objetivo é usar a transliteração (isto é, usando um mapeamento de caractere a caractere) para substituir o caractere de entrada pelo caractere de saída. Para fazer isso, precisamos selecionar o mapa correto com base em se o espelho é /ou \. Mapearemos da SWENlista para outra que selecionaremos condicionalmente. Se a lista de entrada for SWEN, os dois mapas de saída precisam ser os seguintes:

in  SWEN
/   ENSW
\   WSNE

Observe que eles estão na ordem classificada e na ordem inversa (e é por isso que escolhemos a SWENordem aparentemente aleatória como o conjunto de entrada). Poderíamos gerá-los classificando a lista de entradas e revertendo o resultado, se a entrada tiver \, mas existe uma maneira melhor:

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 para -r) 43

Guardado 5 graças a Martin Ender ♦

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

Recebe a entrada como uma sequência de dois caracteres.

Mathematica, 98 bytes

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

Função anônima. Pega duas seqüências como entrada e retorna uma sequência como saída.

C, 81 bytes

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

Uso

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

Saída:

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

Pitão, 13 bytes

@."EW¹0`Y"sCM    

Suíte de teste

Soma os pontos de código, índice modular, sequência compactada.

TI-Basic, 40 bytes

Codifica as entradas. Chato, mas o caminho mais curto.

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