Dwuwymiarowe języki programowania często mają polecenia lustrzane, takie jak /i \do przekierowania wskaźnika instrukcji na siatce:

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

W tym wyzwaniu otrzymasz kierunek i lustro i musisz określić kierunek wychodzenia.

Zasady

Kierunek nadejścia będzie podany jako jeden z znaków, NESWa lustro podany jako jeden /lub \. Możesz otrzymać je w dowolnej kolejności. Musisz używać wielkich liter.

Możesz przyjmować dane wejściowe w dowolnym dogodnym formacie, w tym ciąg dwóch znaków, ciąg znaków, używając separatora między znakami, parę znaków na liście, a nawet parę ciągów singletonów. Jeśli używasz łańcucha z separatorem, separator nie może użyć żadnego ze znaków NWSE\/.

Dane wyjściowe powinny być znakami NESWlub ciągami jednoznakowymi.

Możesz napisać program lub funkcję i użyć dowolnej z naszych standardowych metod otrzymywania danych wejściowych i dostarczania danych wyjściowych.

Możesz używać dowolnego języka programowania , ale pamiętaj, że te luki są domyślnie zabronione.

To jest golf golfowy , więc wygrywa najkrótsza ważna odpowiedź - mierzona w bajtach .

Przypadki testowe

Jest tylko 8 możliwych danych wejściowych, które musisz obsłużyć, więc nie ma wymówki, aby nie testować kodu na wszystkich z nich:

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

Python, 40 38 bajtów

-2 bajty dzięki @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

proste wyszukiwanie odpowiedzi na liście (ciąg znaków AKA) indeksowanej przez najmniejszy mod sumy działających rzędnych.

Przypadki testowe są na ideone

Python 2, 40 bajtów

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

Sp3000 zapisał jeden bajt ( .index→ .find).

Wyjaśnienie

Chcemy tak mapować kierunki:

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

Możemy przypisać kierunki 2-bitowe kody i zobaczyć oba przerzuty jako XOR-y dla pierwszego i drugiego bitu:

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

Mapowanie między łańcuchami bitów i kierunkami odbywa się za pomocą łańcucha k. Teraz musimy tylko odwzorować znaki lustrzane '/'oraz '\\'na wartości 1i 2. Odtąd '/' < '\\'moglibyśmy naiwnie używać (m>'/')+1jako formuły. Ale poczekaj! Leksykograficznie,

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

i do czego 'NWES'ładnie przypisaliśmy k! Więc możemy użyć (m>k)+1zamiast tego.

CJam, 14 bajtów

(@MartinEnder przeniósł moją odpowiedź w języku Python )

l1b" NESSWNW"=

W jaki sposób?

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

Testy odbywają się na aditsu

JavaScript (ES6), 50 41 40 37 bajtów

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

Oszczędność 3 kolejnych bajtów dzięki zastosowaniu porównania dzięki odpowiedzi Lynn

Stosowanie

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 bajtów

'NWSE'jy&mjy+Eq-)

Wypróbuj online! Lub sprawdź osiem przypadków .

Wyjaśnienie

'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 bajtów

Dzięki @Jakube i @Maltysen za -1 bajt każdy

@J"NWES"xxJQh>E

Program, który pobiera dane z dwóch ciągów cudzysłowu oddzielonych znakiem nowej linii, najpierw kierunek, a następnie odbicie lustrzane i wypisuje wynik.

To jest port odpowiedzi na Python @ Lynn .

Wypróbuj online

Jak to działa

@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 bajtów

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

Wypróbuj online!

Galaretka , 14 13 12 bajtów

(port mojej odpowiedzi w Pythonie )
-1 bajt dzięki @MartinEnder (dodaj spację na końcu łańcucha i usuń potrzebę modulo 8)
-1 bajt dzięki @LuisMendo (weź jeden argument ciągu zamiast dwóch)

OSị“NESSWNW 

W jaki sposób?

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)

Przetestuj na TryItOnline

Java 7, 71 70 68 bajtów

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

Szkoda charAti indexOfzajmuje tyle bajtów ...

Nieskluczone i wszystkie przypadki testowe:

Wypróbuj tutaj.

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

Wydajność:

W E S N E W N S

Python, 63 61 59 bajtów

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

Dość proste. Zdecydowanie można golfa więcej. Decyduje, czy dodać 1 czy -1 do indeksu wejścia w 'NESW'.

To jest wyrażenie lambda; aby z niego skorzystać, należy go poprzedzić f=.

Ideone to!

Java 8, 62 58 56 bajtów

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

Nie testowany program testowy

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 bajty

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

Bierze dane wejściowe jako dwa jawne chars, wyniki a char.

Działa to w następujący sposób: Jeśli sortujemy dane wyjściowe, chcemy S /w jakiś sposób równać się z tym N \, W /aby być równym E \itp. Lub przynajmniej produkować liczby, które są „wystarczająco blisko”, a jednak nadal różnią się między sobą. Jeśli spojrzymy na wartości ASCII, otrzymamy tabelę taką jak poniżej:

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

Uruchomienie szybkiego brute-forcera w kolumnie podsumowań (pochodzącej ze zsumowania punktów kodu ASCII danych wejściowych) pokazuje, że jeśli weźmiemy sumę modulo 8, otrzymamy następujące 2 2 | 6 1 | 3 4 | 5 7. Dowodem na to, że w ciągu "xNESSWNW", co Ejest wskaźnikiem 2, Njest 6i 1, i tak dalej.

Musimy więc tylko zsumować dane wejściowe (pośrednio rzutując od chardo int32), wziąć to %8i użyć do indeksowania w naszym ciągu.

Przypadki testowe

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

Partia, 111 bajtów

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

Akceptuje np. Dwuznakowy W/parametr wiersza poleceń. \I /zrobić pętlę niewygodne; zajęłoby 124 bajty.

Oktawa, 30 bajtów

Używał tej samej kolejności argumentów co Jonathan Allan.

Pobiera dane wejściowe jako ciąg dwóch znaków 'W\'.

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

Wypróbuj online .

C, 44, 35, 34 bajtów

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

Wymaga dwóch znaków jako dwóch zmiennych. Zajmuje zarówno małe, jak i wielkie litery. Używa wielu manipulacji bitowych. Fragment a&a/2daje wartość, która ma unikalne wartości dla dwóch niższych bitów, &3odcina wszystkie wyższe bity. Użyto go jako indeksu w ciągu „NWES” dla \lustra. Na szczęście dwa dolne bity znaków ASCII \oraz /odpowiednio 00 i 11, są idealne dla XOR z wyżej wymienionym indeksem, aby uzyskać właściwy kierunek dla /zwierciadła.

CJam , 17 bajtów

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

Wejście jest oddzielone spacją.

Wypróbuj online! (Jako pakiet testowy oddzielony od linii).

To jest rozwiązanie, które znalazłem przed opublikowaniem wyzwania. Nie tak krótki jak cykliczne indeksowanie Jonathana, ale pomyślałem, że to podejście jest dość interesujące (i nowatorskie).

Wyjaśnienie

Celem jest użycie transliteracji (tj. Użycie odwzorowania między znakami) w celu zastąpienia znaku wejściowego znakiem wyjściowym. Aby to zrobić, musimy wybrać poprawną mapę w oparciu o to, czy lustro jest /czy \. Zmapujemy z SWENlisty na inną, którą wybieramy warunkowo. Jeśli lista wejściowa to SWEN, dwie mapy wyjściowe muszą być następujące:

in  SWEN
/   ENSW
\   WSNE

Zauważ, że są one posortowane i posortowane odwrotnie (dlatego wybraliśmy pozornie losową SWENkolejność jako zestaw danych wejściowych). Możemy je wygenerować, sortując listę danych wejściowych i odwracając wynik, jeśli dane wejściowe mają \, ale istnieje lepszy sposób:

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

Oszczędności 5 dzięki Martinowi Enderowi ♦

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

Pobiera dane wejściowe jako ciąg dwóch znaków.

Mathematica, 98 bajtów

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

Funkcja anonimowa. Pobiera dwa łańcuchy jako dane wejściowe i zwraca łańcuch jako dane wyjściowe.

C, 81 bajtów

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

Stosowanie

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

Wydajność:

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

Pyth, 13 bajtów

@."EW¹0`Y"sCM    

Zestaw testowy

Zsumuj punkty kodowe, indeks modułowy, skompresowany ciąg.

TI-Basic, 40 bajtów

Zakoduj wejścia. Nudna, ale najkrótsza droga.

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