Espejo, espejo, en el código

26

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 , 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
Martin Ender
fuente
1
En los idiomas donde las barras invertidas deben escaparse en la entrada, ¿podemos suponer que la entrada será "\\" cuando corresponda?
JDL
44
@JDL La cadena (o carácter) real debe contener una sola \. Si su respuesta es una presentación de función que toma una cadena, entonces, por supuesto, necesitará \\en el código fuente para llamarla correctamente, pero si está leyendo su entrada desde la entrada estándar, por ejemplo, entonces debería ser una sola \. En otras palabras, si llama a la función de longitud de cadena respectiva de su idioma en la entrada, el resultado siempre debe ser el mismo, independientemente de si la entrada contiene /o no \.
Martin Ender
Bien, esperaba que R tuviera problemas cuando se ingresó un "\" sin escape a través de stdin, pero readline()puedo manejarlo.
JDL
1
@JDL Probablemente necesite ingresar la cadena que escapa (duplicando) ese símbolo, pero la cadena resultante será "N \"
Luis Mendo

Respuestas:

24

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

Jonathan Allan
fuente
Dangit, pensé que estaba siendo muy inteligente tomando los valores ASCII, sumándolos %8y haciendo un índice. Entonces veo que publicaste la misma solución hace más de una hora. Ja Tener un +1.
AdmBorkBork
21

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.

Lynn
fuente
12

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

Jonathan Allan
fuente
6

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

Arnauld
fuente
Uso inteligente de las comparaciones ASCII para obtener su condición al final jugando a su manera ...
WallyWest
6

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
Luis Mendo
fuente
6

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
TheBikingViking
fuente
puede guardar otro byte reemplazándolo <QEcon >E.
Maltysen
4

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!

Emigna
fuente
4

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

Jonathan Allan
fuente
4

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
Kevin Cruijssen
fuente
3

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!

Cobre
fuente
3

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
}

}
Shaun Wild
fuente
3

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
AdmBorkBork
fuente
2

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.

Neil
fuente
Idk, cuento 96 bytes. ¿Te desnudaste \r?
Conor O'Brien
@ ConorO'Brien Escribo mis archivos Batch usando el Bloc de notas, así que no.
Neil
2

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 .

Stewie Griffin
fuente
¡Agradable! Es posible que desee portar a MATL: 'NESSWNW 'is)(ver todos los casos de prueba ). ies input, ses sumy )está indexando, que es modular. Agregué un espacio en la cadena para que el módulo sea 8
Luis Mendo
Gracias :) Siento que es una trampa si agrego eso como una respuesta separada, ya que no lo he escrito yo mismo. Sin embargo, puedo agregarlo a esta respuesta si no quieres responderlo tú mismo :)
Stewie Griffin
Entiendo, probablemente haría lo mismo :-) No quiero modificar mi respuesta, ya que es un enfoque totalmente diferente que no se me ocurrió. Sin embargo, no estoy seguro de que agregarlo a su respuesta tenga sentido, ya que serían dos idiomas diferentes en la respuesta
Luis Mendo
Sería mi primera respuesta, aunque MAT: PI ver que es más largo que su respuesta MAT, por lo que no creo que voy a añadir ...
Stewie Griffin
2

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.

G. Sliepen
fuente
2
¡Agradable! Sin embargo, se perdió un byte -1 obvio: return"NWES"[...](omita el espacio).
Tim Čas
Gracias Tim, no se me ocurrió que eso sería válido C :)
G. Sliepen
1

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.
Martin Ender
fuente
1

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.

Riley
fuente
0

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.

LegionMammal978
fuente
0

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  
Giacomo Garabello
fuente
Funciona solo en valores codificados, ya que utiliza comparaciones de punteros.
Sami Kuhmonen
0

Pyth, 13 bytes

@."EW¹0`Y"sCM    

Banco de pruebas

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

isaacg
fuente
0

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
Timtech
fuente