Bahasa pemrograman dua dimensi sering memiliki perintah cermin seperti /dan \untuk mengarahkan ulang pointer instruksi di grid:

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

Dalam tantangan ini, Anda diberi arah masuk dan cermin dan Anda perlu menentukan arah keluar.

Aturan

Arah masuk akan diberikan sebagai salah satu karakter NESWdan cermin akan diberikan sebagai salah satu /atau \. Anda dapat menerima ini dalam urutan apa pun. Anda harus menggunakan huruf besar.

Anda dapat mengambil input dalam format apa pun yang nyaman, termasuk string dua karakter, string menggunakan pemisah antara karakter, sepasang karakter dalam daftar, atau bahkan sepasang string tunggal. Jika Anda menggunakan string dengan pemisah, pemisah tidak dapat menggunakan karakter apa pun NWSE\/.

Output harus berupa karakter dari NESWatau string karakter tunggal.

Anda dapat menulis sebuah program atau fungsi dan menggunakan salah satu metode standar kami untuk menerima input dan memberikan output.

Anda dapat menggunakan bahasa pemrograman apa pun , tetapi perhatikan bahwa celah ini dilarang secara default.

Ini adalah kode-golf , sehingga jawaban terpendek yang valid - diukur dalam byte - menang.

Uji Kasus

Hanya ada 8 kemungkinan input yang perlu Anda tangani, jadi tidak ada alasan untuk tidak menguji kode Anda pada semuanya:

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

Python, 40 38 byte

-2 byte terima kasih kepada @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

pencarian jawaban secara sederhana dalam daftar (string AKA) yang diindeks oleh mod terkecil dari jumlah ordinal yang berfungsi.

Kasus uji ada di ideone

Python 2, 40 byte

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

Sp3000 disimpan satu byte ( .index→ .find).

Penjelasan

Kami ingin memetakan arah seperti ini:

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

Kita dapat menetapkan kode 2-arah arah, dan melihat kedua membalik sebagai XOR-ing bit pertama dan kedua:

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

Pemetaan antara string bit dan arah terjadi menggunakan string k. Sekarang kita hanya perlu memetakan karakter cermin '/'dan '\\'ke nilai 1dan 2. Karena '/' < '\\', kita bisa menggunakan (m>'/')+1sebagai formula secara naif . Tapi tunggu! Leksikografis,

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

dan kami telah 'NWES'ditugaskan dengan baik k! Jadi kita bisa menggunakannya (m>k)+1.

CJam, 14 byte

(@MartinEnder mengirim jawaban Python saya )

l1b" NESSWNW"=

Bagaimana?

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

Tes ada di aditsu

Javascript (ES6), 50 41 40 37 byte

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

Disimpan 3 byte lebih banyak dengan menggunakan perbandingan, berkat jawaban Lynn

Pemakaian

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

Cobalah online! Atau verifikasi delapan kasus .

Penjelasan

'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

Terima kasih kepada @Jakube dan @Maltysen untuk -1 byte masing-masing

@J"NWES"xxJQh>E

Sebuah program yang mengambil input dari dua string kutipan yang dipisahkan baris-baru, pertama arah dan kemudian cermin, dan mencetak hasilnya.

Ini adalah port dari jawaban Python @ Lynn .

Cobalah online

Bagaimana itu bekerja

@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               

Cobalah online!

Jelly , 14 13 12 byte

(port jawaban Python saya )
-1 byte terima kasih kepada @MartinEnder (tambahkan spasi di akhir string dan hapus kebutuhan modulo 8)
-1 byte terima kasih kepada @LuisMendo (gunakan argumen string tunggal daripada dua)

OSị“NESSWNW 

Bagaimana?

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)

Uji di TryItOnline

Java 7, 71 70 68 byte

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

Terlalu buruk charAtdan indexOfmemakan banyak byte ..

Tidak dikumpulkan & semua uji kasus:

Coba di sini.

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

Keluaran:

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]

Cukup mudah. Pasti bisa bermain golf lebih banyak. Memutuskan apakah akan menambahkan 1 atau -1 ke indeks input dalam 'NESW'.

Ini adalah ungkapan lambda; untuk menggunakannya, awali dengan f=.

Ide itu!

Java 8, 62 58 56 byte

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

Program tes tidak digabungkan

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]

Mengambil input sebagai dua chars eksplisit , output a char.

Ini berfungsi sebagai berikut: Jika kita mengurutkan output, kita ingin S /entah bagaimana sama dengan N \, W /untuk sama E \, dll. Atau, setidaknya, menghasilkan angka yang "cukup dekat" namun masih berbeda. Jika kita melihat nilai ASCII, kita mendapatkan tabel seperti di bawah ini:

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

Menjalankan brute-forcer cepat pada kolom penjumlahan (berasal dari menjumlahkan poin kode ASCII dari input) menunjukkan bahwa jika kita mengambil modulo penjumlahan 8, kita mendapatkan yang berikut 2 2 | 6 1 | 3 4 | 5 7. Itu dibuktikan dalam string "xNESSWNW", seperti Epada indeks 2,N di 6dan 1, dan seterusnya.

Jadi, kita hanya perlu menjumlahkan input (secara implisit berpindah dari charkeint32 sepanjang jalan), mengambil itu %8, dan menggunakannya untuk mengindeks ke dalam string kita.

Uji Kasus

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

Menerima mis. W/Sebagai parameter baris perintah string dua karakter. Itu \dan /membuat looping canggung; itu akan mengambil 124 byte.

Oktaf, 30 byte

Menggunakan urutan argumen yang sama dengan Jonathan Allan.

Mengambil input sebagai string dua karakter 'W\'.

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

Cobalah online .

C, 44, 35, 34 byte

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

Dibutuhkan dua karakter sebagai dua variabel. Dibutuhkan huruf besar dan kecil. Ini menggunakan banyak manipulasi bit. Fragmen a&a/2menghasilkan nilai yang memiliki nilai unik untuk dua bit yang lebih rendah, &3memotong semua bit yang lebih tinggi. Ini digunakan sebagai indeks ke string "NWES" untuk \cermin. Untungnya, dua bit lebih rendah dari karakter ASCII \dan /masing-masing adalah 00 dan 11, yang sempurna untuk XOR dengan indeks yang disebutkan di atas untuk mendapatkan arah yang benar untuk /mirror.

CJam , 17 byte

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

Input dipisahkan oleh ruang.

Cobalah online!(Sebagai rangkaian uji yang dipisahkan dengan linefeed.)

Ini adalah solusi yang saya temukan sebelum memposting tantangan. Tidak sesingkat pengindeksan Jonathan, tapi saya pikir pendekatan ini cukup menarik (dan novel).

Penjelasan

Tujuannya adalah menggunakan transliterasi (yaitu menggunakan pemetaan karakter-ke-karakter) untuk mengganti karakter input dengan karakter output. Untuk melakukan ini, kita perlu memilih peta yang benar berdasarkan apakah cermin itu /atau tidak \. Kami akan memetakan dari SWENdaftar ke daftar lain yang akan kami pilih dengan syarat. Jika daftar inputnya adalah SWEN, dua peta output harus sebagai berikut:

in  SWEN
/   ENSW
\   WSNE

Perhatikan bahwa ini adalah dalam urutan dan urutan-terbalik (itulah sebabnya kami memilih urutan yang tampaknya acak SWENsebagai set input). Kita dapat membuat ini dengan mengurutkan daftar input dan membalikkan hasilnya jika inputnya ada \, tetapi ada cara yang lebih baik:

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

Disimpan 5 berkat Martin Ender ♦

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

Mengambil input sebagai string dua karakter.

Mathematica, 98 byte

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

Fungsi anonim. Mengambil dua string sebagai input dan mengembalikan string sebagai output.

C, 81 byte

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

Pemakaian

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

Keluaran:

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

Pyth, 13 byte

@."EW¹0`Y"sCM    

Suite uji

Jumlahkan poin kode, indeks modular, string terkompresi.

TI-Basic, 40 byte

Hardcodes input. Membosankan, tapi cara terpendek.

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