I linguaggi di programmazione bidimensionali hanno spesso comandi mirror simili /e \per reindirizzare il puntatore di istruzioni sulla griglia:

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

In questa sfida, ti viene data una direzione in entrata e uno specchio e devi determinare la direzione in uscita.

Regole

La direzione in arrivo verrà indicata come uno dei personaggi NESWe lo specchio verrà indicato come uno /o \. Puoi riceverli in qualsiasi ordine. È necessario utilizzare lettere maiuscole.

Puoi inserire input in qualsiasi formato conveniente, inclusa una stringa di due caratteri, una stringa che utilizza un separatore tra i caratteri, una coppia di caratteri in un elenco o persino una coppia di stringhe singleton. Se si utilizza una stringa con separatore, il separatore non può utilizzare nessuno dei caratteri NWSE\/.

L'output deve essere un carattere di una NESWstringa di caratteri singoli.

È possibile scrivere un programma o una funzione e utilizzare uno dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è code-golf , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

Ci sono solo 8 possibili input che devi gestire, quindi non ci sono scuse per non testare il tuo codice su tutti loro:

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

Python, 40 38 byte

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

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

semplice ricerca di risposta in un elenco (stringa AKA) indicizzato dalla mod più piccola della somma degli ordinali che funziona.

I casi di test sono su ideone

Python 2, 40 byte

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

Sp3000 ha salvato un byte ( .index→ .find).

Spiegazione

Vogliamo mappare le indicazioni in questo modo:

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

Possiamo assegnare i codici delle direzioni a 2 bit e visualizzare entrambi i lanci come XOR come il primo e il secondo bit:

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

La mappatura tra stringhe di bit e direzioni avviene usando la stringa k. Ora dobbiamo solo mappare i caratteri speculari '/'e '\\'i valori 1e 2. Da allora '/' < '\\', potremmo usare ingenuamente (m>'/')+1come formula. Ma aspetta! lessicografico,

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

e ci siamo 'NWES'ben assegnati a k! Quindi possiamo usare (m>k)+1invece.

CJam, 14 byte

(@MartinEnder ha portato la mia risposta Python )

l1b" NESSWNW"=

Come?

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

I test sono su aditsu

Javascript (ES6), 50 41 40 37 byte

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

Hai salvato altri 3 byte usando il confronto, grazie alla risposta di 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 byte

'NWSE'jy&mjy+Eq-)

Provalo online! Oppure verifica gli otto casi .

Spiegazione

'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

Grazie a @Jakube e @Maltysen per -1 byte ciascuno

@J"NWES"xxJQh>E

Un programma che accetta input di due stringhe tra virgolette separate da nuova riga, prima la direzione e poi il mirror, e stampa il risultato.

Questa è una porta della risposta Python di @ Lynn .

Provalo online

Come funziona

@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               

Provalo online!

Gelatina , 14 13 12 byte

(una porta della mia risposta Python )
-1 byte grazie a @MartinEnder (aggiungi uno spazio alla fine della stringa e rimuovi la necessità di modulo 8)
-1 byte grazie a @LuisMendo (accetta un singolo argomento stringa anziché due)

OSị“NESSWNW 

Come?

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)

Provalo su TryItOnline

Java 7, 71 70 68 byte

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

Peccato che charAteindexOf occupa così tanti byte ..

Ungolfed e tutti i casi di test:

Provalo qui.

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

Produzione:

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]

Abbastanza semplice. Può sicuramente giocare a golf di più. Decide se aggiungere 1 o -1 all'indice dell'input in'NESW' .

Questa è un'espressione lambda; per usarlo, aggiungilo come prefissof= .

Ideone esso!

Java 8, 62 58 56 byte

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

Programma di test non golfato

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]

Accetta input come due espliciti char, output a char.

Funziona come segue: se ordiniamo l'output, vogliamo S /in qualche modo uguagliare lo stesso di N \, W /uguagliare E \, ecc. O, almeno, produrre numeri che sono "abbastanza vicini" ma ancora distinti. Se osserviamo i valori ASCII, otteniamo una tabella come la seguente:

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

Eseguendo un bruto-forcer sulla colonna delle sommazioni (derivato dalla somma dei punti di codice ASCII degli input) si mostra che se prendiamo le somme modulo 8, otteniamo quanto segue 2 2 | 6 1 | 3 4 | 5 7. Ciò è evidenziato nella stringa "xNESSWNW", come Enell'indice 2, Nin 6e 1, e così via.

Quindi, abbiamo solo bisogno di sommare gli input (implicitamente il cast da chara int32lungo la strada), prenderlo %8e usarlo per indicizzarlo nella nostra stringa.

Casi test

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

Lotto, 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

Accetta ad es W/. Come parametro della riga di comando della stringa di due caratteri. Il \e /rendere il loop imbarazzante; avrebbe impiegato 124 byte.

Ottava, 30 byte

Usava lo stesso ordine di argomenti di Jonathan Allan.

Accetta l'input come stringa di due caratteri 'W\'.

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

Provalo online .

C, 44, 35, 34 byte

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

Richiede due caratteri come due variabili. Ci vogliono sia lettere minuscole che maiuscole. Usa molta manipolazione dei bit. Il frammento si a&a/2traduce in un valore che ha valori univoci per i due bit inferiori, &3taglia tutti i bit più alti. Questo è stato usato come indice nella stringa "NWES" per il \mirror. Fortunatamente, i due bit inferiori dei caratteri ASCII \e /sono rispettivamente 00 e 11, il che è perfetto per XOR con l'indice di cui sopra per ottenere la direzione corretta per il /mirror.

CJam , 17 byte

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

L'input è separato dallo spazio.

Provalo online! (Come una suite di test separata da avanzamento riga.)

Questa è la soluzione che ho trovato prima di pubblicare la sfida. Non breve come l'indicizzazione ciclica di Jonathan, ma ho pensato che questo approccio fosse piuttosto interessante (e romanzo).

Spiegazione

L'obiettivo è utilizzare la traslitterazione (ovvero utilizzando una mappatura carattere-carattere) per sostituire il carattere di input con il carattere di output. Per fare ciò, dobbiamo selezionare la mappa corretta in base al fatto che il mirror sia /o \. Mapperemo SWENdall'elenco a un altro che selezioneremo in modo condizionale. Se l'elenco di input è SWEN, le due mappe di output devono essere le seguenti:

in  SWEN
/   ENSW
\   WSNE

Si noti che questi sono in ordine e in ordine inverso (motivo per cui abbiamo scelto l' SWENordine apparentemente casuale come set di input). Potremmo generarli ordinando l'elenco di input e invertendo il risultato se l'input ha \, ma c'è un modo migliore:

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

Salvato 5 grazie a Martin Ender ♦

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

Accetta l'input come una stringa di due caratteri.

Mathematica, 98 byte

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

Funzione anonima. Accetta due stringhe come input e restituisce una stringa come output.

C, 81 byte

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

Produzione:

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

Pyth, 13 byte

@."EW¹0`Y"sCM    

Suite di test

Somma i punti del codice, l'indice modulare, la stringa compressa.

TI-Basic, 40 byte

Codifica hard degli input. Noioso, ma il modo più breve.

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