Zweidimensionale Programmiersprachen verfügen häufig über Spiegelbefehle wie /und \zum Umleiten des Befehlszeigers auf dem Raster:

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

In dieser Herausforderung erhalten Sie eine Eingangsrichtung und einen Spiegel und müssen die Ausgangsrichtung bestimmen.

Regeln

Die ankommende Richtung wird als eines der Zeichen NESWund der Spiegel als entweder /oder angegeben \. Sie können diese in beliebiger Reihenfolge erhalten. Sie müssen Großbuchstaben verwenden.

Sie können Eingaben in jedem geeigneten Format vornehmen, einschließlich einer Zeichenfolge mit zwei Zeichen, einer Zeichenfolge mit Trennzeichen zwischen den Zeichen, einem Zeichenpaar in einer Liste oder sogar einem Paar Singleton-Zeichenfolgen. Wenn Sie eine Zeichenfolge mit Trennzeichen verwenden, kann das Trennzeichen keine der Zeichen verwenden NWSE\/.

Die Ausgabe sollte ein Zeichen NESWoder eine Einzelzeichenfolge sein.

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist Code-Golf , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Es gibt nur 8 mögliche Eingaben, die Sie verarbeiten müssen. Es gibt also keine Entschuldigung, Ihren Code nicht auf allen zu testen:

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

Python, 40 38 Bytes

-2 Bytes dank @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

Einfache Suche nach Antworten in einer Liste (AKA-Zeichenfolge), die durch den kleinsten Mod der Summe der funktionierenden Ordnungszahlen indiziert ist.

Testfälle sind auf ideone

Python 2, 40 Bytes

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

Sp3000 hat ein Byte gespeichert ( .index→ .find).

Erläuterung

Wir wollen die Richtungen so abbilden:

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

Wir können die Richtungen 2-Bit-Codes zuweisen und beide Flip als XOR-Verknüpfung des ersten und des zweiten Bits anzeigen:

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

Die Zuordnung zwischen Bitfolgen und Richtungen erfolgt mithilfe der Zeichenfolge k. Jetzt müssen wir nur noch Spiegelzeichen '/'und '\\'den Werten 1und zuordnen 2. Da '/' < '\\'könnten wir naiv (m>'/')+1als Formel verwenden. Aber warte! Lexikographisch,

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

und das haben wir 'NWES'schön zugeteilt k! Also können wir (m>k)+1stattdessen verwenden.

CJam, 14 Bytes

(@MartinEnder hat meine Python-Antwort portiert )

l1b" NESSWNW"=

Wie?

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

Tests sind auf Aditsu

Javascript (ES6), 50 41 40 37 Bytes

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

Dank Lynns Antwort konnten durch den Vergleich 3 weitere Bytes eingespart werden

Verwendung

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-)

Probieren Sie es online! Oder überprüfen Sie die acht Fälle .

Erläuterung

'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

Vielen Dank an @Jakube und @Maltysen für jeweils -1 Byte

@J"NWES"xxJQh>E

Ein Programm, das zwei durch Zeilenumbrüche getrennte, in Anführungszeichen gesetzte Zeichenfolgen eingibt, zuerst die Richtung und dann den Spiegel und das Ergebnis druckt.

Dies ist eine Portierung von @Lynns Python- Antwort .

Probieren Sie es online aus

Wie es funktioniert

@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               

Probieren Sie es online!

Jelly , 14 13 12 Bytes

(ein Port meiner Python-Antwort )
-1 Byte dank @MartinEnder (füge ein Leerzeichen am Ende des Strings hinzu und entferne die Notwendigkeit für Modulo 8)
-1 Byte dank @LuisMendo (nimm ein einziges String-Argument anstatt zwei)

OSị“NESSWNW 

Wie?

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)

Testen Sie es auf TryItOnline

Java 7, 71 70 68 Bytes

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

Schade das charAtund indexOfnimmt so viel Bytes ein ..

Ungolfed & alle Testfälle:

Probieren Sie es hier aus.

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

Ausgabe:

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]

Ziemlich einfach. Kann definitiv mehr golfen werden. Legt fest, ob 1 oder -1 zum Index der Eingabe in hinzugefügt werden soll 'NESW'.

Dies ist ein Lambda-Ausdruck; Um es zu benutzen, stellen Sie es mit dem Präfix f=.

Ideone es!

Java 8, 62 58 56 Bytes

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

Ungolfed Testprogramm

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]

Nimmt die Eingabe als zwei explizite chars, gibt a aus char.

Dies funktioniert wie folgt: Wenn wir die Ausgabe sortieren, möchten wir S /irgendwie gleich N \, W /gleich E \usw. sein. Oder zumindest Zahlen erzeugen, die "nah genug" und dennoch verschieden sind. Wenn wir uns die ASCII-Werte ansehen, erhalten wir eine Tabelle wie die folgende:

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

Das Ausführen eines schnellen Brute-Forcers für die Summationsspalte (abgeleitet aus dem Summieren der ASCII-Codepunkte der Eingaben) zeigt, dass wir 8Folgendes erhalten , wenn wir die Summen modulo nehmen 2 2 | 6 1 | 3 4 | 5 7. Dies zeigt sich in der Zeichenfolge "xNESSWNW", wie Eim Index 2, Nin 6und 1und so weiter.

Also müssen wir nur die Eingaben summieren (implizit von charbis int32auf dem Weg umwandeln), diese nehmen %8und diese verwenden, um in unseren String zu indexieren.

Testfälle

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

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

Akzeptiert zB W/als zweistelligen String-Kommandozeilenparameter. Das \und /macht das Schleifen umständlich; Es hätte 124 Bytes gedauert.

Oktave, 30 Bytes

Verwendete die gleiche Reihenfolge der Argumente wie Jonathan Allan.

Übernimmt die Eingabe als zweistellige Zeichenfolge 'W\'.

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

Probieren Sie es online aus .

C, 44, 35, 34 Bytes

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

Es erfordert zwei Zeichen als zwei Variablen. Es dauert sowohl Klein- als auch Großbuchstaben. Es erfordert viel Bit-Manipulation. Das Fragment a&a/2führt zu einem Wert, der eindeutige Werte für die beiden niedrigeren Bits hat &3und alle höheren Bits abschneidet. Dies wird als Index für die Zeichenfolge "NWES" für den \Spiegel verwendet. Glücklicherweise sind die unteren zwei Bits der ASCII - Zeichen \und /sind 00 und 11 verbunden, die zu XOR mit dem oben erwähnten Index perfekt ist die richtige Richtung für den bekommen /Spiegel.

CJam , 17 Bytes

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

Die Eingabe ist durch Leerzeichen getrennt.

Probieren Sie es online! (Als durch Zeilenvorschub getrennte Testsuite.)

Dies ist die Lösung, die ich vor dem Posten der Herausforderung gefunden habe. Nicht so kurz wie Jonathans zyklische Indexierung, aber ich fand diesen Ansatz sehr interessant (und neuartig).

Erläuterung

Das Ziel ist die Verwendung der Transliteration (dh die Verwendung einer Zeichen-zu-Zeichen-Zuordnung), um das Eingabezeichen durch das Ausgabezeichen zu ersetzen. Dazu müssen wir die richtige Karte auswählen, je nachdem, ob es sich um einen Spiegel handelt /oder nicht \. Wir ordnen von der SWENListe eine andere zu, die wir unter bestimmten Bedingungen auswählen. Wenn die Eingabeliste lautet SWEN, müssen die beiden Ausgabe-Maps die folgenden sein:

in  SWEN
/   ENSW
\   WSNE

Beachten Sie, dass diese in sortierter und umgekehrter Reihenfolge vorliegen (weshalb wir die scheinbar zufällige SWENReihenfolge als Eingabesatz gewählt haben). Wir könnten diese generieren, indem wir die Eingabeliste sortieren und das Ergebnis umkehren, wenn die Eingabe dies aufweist. Es gibt \jedoch einen besseren Weg:

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 für -r) 43

5 Dank an Martin Ender gespart ♦

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

Nimmt die Eingabe als zweistellige Zeichenfolge an.

Mathematica, 98 Bytes

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

Anonyme Funktion. Nimmt zwei Zeichenfolgen als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück.

C 81 Bytes

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

Verwendung

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

Ausgabe:

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

Pyth, 13 Bytes

@."EW¹0`Y"sCM    

Testsuite

Summieren Sie die Codepunkte, den modularen Index und die komprimierte Zeichenfolge.

TI-Basic, 40 Bytes

Codiert die Eingaben fest. Langweilig, aber der kürzeste Weg.

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