Los lenguajes de programación bidimensionales a menudo tienen comandos espejo como /y \para redirigir el puntero de instrucciones en la cuadrícula:

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

En este desafío, se le da una dirección entrante y un espejo y necesita determinar la dirección saliente.

Reglas

La dirección entrante se dará como uno de los personajes NESWy el espejo se dará como /o \. Puede recibirlos en cualquier orden. Debes usar letras mayúsculas.

Puede tomar la entrada en cualquier formato conveniente, incluida una cadena de dos caracteres, una cadena que use un separador entre los caracteres, un par de caracteres en una lista o incluso un par de cadenas de un solo tono. Si usa una cadena con separador, el separador no puede usar ninguno de los caracteres NWSE\/.

La salida debe ser un carácter de NESWuna cadena de un solo carácter.

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas por defecto.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

Solo hay 8 posibles entradas que necesita manejar, por lo que no hay excusa para no probar su código en todas ellas:

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

Python, 40 38 bytes

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

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

búsqueda simple de respuesta en una lista (cadena AKA) indexada por el mod más pequeño de la suma de ordinales que funciona.

Los casos de prueba están en ideona

Python 2, 40 bytes

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

Sp3000 guardó un byte ( .index→ .find).

Explicación

Queremos mapear las direcciones así:

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

Podemos asignar códigos de 2 bits a las direcciones y ver ambos cambios como XOR al primer y segundo bits:

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

La asignación entre cadenas de bits y direcciones se realiza utilizando la cadena k. Ahora solo necesitamos mapear los caracteres espejo '/'y '\\'los valores 1y 2. Desde entonces '/' < '\\', podríamos usar ingenuamente (m>'/')+1como una fórmula. ¡Pero espera! Lexicográficamente

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

y hemos 'NWES'asignado muy bien k! Entonces podemos usar (m>k)+1en su lugar.

CJam, 14 bytes

(@MartinEnder portó mi respuesta de Python )

l1b" NESSWNW"=

¿Cómo?

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

Las pruebas están en aditsu

Javascript (ES6), 50 41 40 37 bytes

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

Ahorré 3 bytes más al usar la comparación, gracias a la respuesta 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-)

Pruébalo en línea! O verificar los ocho casos .

Explicación

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

Gracias a @Jakube y @Maltysen por -1 byte cada uno

@J"NWES"xxJQh>E

Un programa que toma la entrada de dos cadenas entre comillas separadas por una nueva línea, primero la dirección y luego el espejo, e imprime el resultado.

Este es un puerto de la respuesta Python de @ Lynn .

Pruébalo en línea

Cómo 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               

Pruébalo en línea!

Jalea , 14 13 12 bytes

(un puerto de mi respuesta de Python )
-1 byte gracias a @MartinEnder (agregue un espacio al final de la cadena y elimine la necesidad del módulo 8)
-1 byte gracias a @LuisMendo (tome un solo argumento de cadena en lugar de dos)

OSị“NESSWNW 

¿Cómo?

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)

Pruébelo en TryItOnline

Java 7, 71 70 68 bytes

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

Lástima que charAty indexOfocupa tantos bytes ...

Sin golf y todos los casos de prueba:

Pruébalo aquí

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

Salida:

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]

Bastante simple. Definitivamente se puede jugar más al golf. Decide si agregar 1 o -1 al índice de entrada en 'NESW'.

Esta es una expresión lambda; para usarlo, prefijalo con f=.

Ideone it!

Java 8, 62 58 56 bytes

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

Programa de prueba sin golf

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]

Toma la entrada como dos chars explícitos , emite a char.

Esto funciona de la siguiente manera: Si la salida de clase, queremos S /a la igualdad de alguna manera lo mismo que N \, W /al igual E \, etc, o, al menos, los números producen que son "lo suficientemente cerca" y aún así distinta. Si observamos los valores ASCII, obtenemos una tabla como la siguiente:

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

Ejecutar un forzador de fuerza bruta rápido en la columna de sumas (derivado de sumar los puntos de código ASCII de las entradas) muestra que si tomamos el módulo de sumas 8, obtenemos lo siguiente 2 2 | 6 1 | 3 4 | 5 7. Eso se evidencia en la cadena "xNESSWNW", como Eestá en el índice 2, Nestá en 6y 1, y así sucesivamente.

Por lo tanto, sólo tenemos que sumar las entradas (fundición implícitamente chara int32lo largo del camino), que llevará %8, y el uso que para indexar en nuestra cadena.

Casos de prueba

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

Acepta, por ejemplo, W/como un parámetro de línea de comando de cadena de dos caracteres. El \y /hacer bucle torpe; habría tomado 124 bytes.

Octava, 30 bytes

Usó el mismo orden de argumentos que Jonathan Allan.

Toma la entrada como una cadena de dos caracteres 'W\'.

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

Pruébalo en línea .

C, 44, 35, 34 bytes

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

Requiere dos caracteres como dos variables. Se necesita tanto mayúsculas como minúsculas. Utiliza mucha manipulación de bits. El fragmento a&a/2da como resultado un valor que tiene valores únicos para los dos bits inferiores, &3corta todos los bits superiores. Esto se utiliza como un índice en la cadena "NWES" para el \espejo. Por suerte, los dos bits más bajos de los caracteres ASCII \y /son 00 y 11 respectivamente, lo cual es perfecto para XOR con el índice antes mencionado para obtener la dirección correcta para el /espejo.

CJam , 17 bytes

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

La entrada está separada por espacios.

Pruébalo en línea! (Como un conjunto de pruebas separado por salto de línea).

Esta es la solución que encontré antes de publicar el desafío. No es tan corto como la indexación cíclica de Jonathan, pero pensé que este enfoque es bastante interesante (y novedoso).

Explicación

El objetivo es utilizar la transliteración (es decir, el uso de un mapeo de caracteres a caracteres) para reemplazar el carácter de entrada con el carácter de salida. Para hacer esto, debemos seleccionar el mapa correcto en función de si el espejo es /o \. Asignaremos de la SWENlista a otra que seleccionaremos condicionalmente. Si la lista de entrada es SWEN, los dos mapas de salida deben ser los siguientes:

in  SWEN
/   ENSW
\   WSNE

Tenga en cuenta que estos están en orden ordenado y en orden inverso (es por eso que elegimos el SWENorden aparentemente aleatorio como el conjunto de entrada). Podríamos generarlos al ordenar la lista de entrada y revertir el resultado si la entrada tiene \, pero hay una mejor manera:

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 gracias a Martin Ender ♦

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

Toma la entrada como una cadena de dos caracteres.

Mathematica, 98 bytes

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

Función anónima. Toma dos cadenas como entrada y devuelve una cadena como salida.

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

Salida:

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

Pyth, 13 bytes

@."EW¹0`Y"sCM    

Banco de pruebas

Suma los puntos de código, índice modular, cadena comprimida.

TI-Basic, 40 bytes

Codifica las entradas. Aburrido, pero el camino más corto.

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