두 차원 프로그래밍 언어는 종종 거울 명령처럼 가지고 /와 \그리드의 명령 포인터를 리디렉션 할 :

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

이 과제에서는 들어오는 방향과 거울이 제공되며 나가는 방향을 결정해야합니다.

규칙

들어오는 방향은 문자 NESW중 하나로 주어지고 미러는 /또는 로 지정됩니다 \. 당신은 어떤 순서 로든지받을 수 있습니다. 대문자를 사용해야합니다.

2 자 문자열, 문자 사이의 구분 기호를 사용하는 문자열, 목록의 문자 쌍 또는 단일 문자열 쌍을 포함하여 편리한 형식으로 입력 할 수 있습니다. 구분 기호가있는 문자열을 사용하는 경우 구분 기호는 문자를 사용할 수 없습니다 NWSE\/.

출력은 문자 NESW이거나 단일 문자 문자열 이어야 합니다.

당신은 쓸 수 있습니다 프로그램이나 기능을 하고, 우리의 사용 표준 방법 입력을 수신하고 출력을 제공합니다.

모든 프로그래밍 언어를 사용할 수 있지만 이러한 허점 은 기본적으로 금지되어 있습니다.

이것은 code-golf 이므로 바이트 단위로 측정 된 가장 짧은 유효한 답변이 이깁니다.

테스트 사례

처리해야 할 입력은 8 개뿐이므로 모든 코드를 테스트하지 않은 이유는 없습니다.

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

파이썬, 40 38 바이트

@MitchSchwartz 덕분에 -2 바이트 (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

작동하는 서수 합계의 가장 작은 모드로 인덱싱 된 목록 (AKA 문자열)에서 응답의 일반 조회.

테스트 사례는 아이디어입니다

파이썬 2, 40 바이트

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

Sp3000은 1 바이트를 저장했습니다 ( .index→ .find).

설명

방향을 다음과 같이 매핑하려고합니다.

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

방향을 2 비트 코드로 할당하고 두 플립을 첫 번째 및 두 번째 비트를 XOR하는 것으로 볼 수 있습니다.

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

비트 문자열과 방향 사이의 매핑은 문자열을 사용하여 발생합니다 k. 이제 우리는 거울 문자 매핑해야 '/'하고 '\\'값에을 1하고 2. 이후 '/' < '\\', 순진하게 (m>'/')+1공식으로 사용할 수있었습니다 . 하지만 기다려! 사 전적으로

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

그리고 우리는 'NWES'훌륭하게 할당되었습니다 k! (m>k)+1대신 사용할 수 있습니다 .

CJam, 14 바이트

(@MartinEnder는 내 파이썬 답변을 포팅했습니다 )

l1b" NESSWNW"=

방법?

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

테스트는 aditsu에 있습니다

자바 스크립트 (ES6), 50 41 40 37 바이트

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

Lynn의 답변 덕분에 비교를 사용하여 3 바이트를 더 절약했습니다.

용법

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 바이트

'NWSE'jy&mjy+Eq-)

온라인으로 사용해보십시오! 또는 여덟 경우를 확인하십시오 .

설명

'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 바이트

각각 -1 바이트의 @Jakube 및 @Maltysen 덕분에

@J"NWES"xxJQh>E

줄 바꿈으로 구분 된 두 개의 따옴표로 묶인 문자열을 먼저 입력 한 다음 방향을 입력 한 다음 결과를 인쇄하는 프로그램입니다.

이것은 @Lynn의 Python answer 포트입니다 .

온라인으로 사용해보십시오

작동 원리

@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 바이트

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

온라인으로 사용해보십시오!

젤리 , 14 13 12 바이트

(내 파이썬 답변 의 포트 )
@MartinEnder 덕분에 -1 바이트 (문자열 끝에 공백을 추가하고 모듈로 8이 필요 없음)
-1 바이트 @@ LuisMendo 덕분에 (2 대신 단일 문자열 인수를 취하십시오)

OSị“NESSWNW 

방법?

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)

TryItOnline에서 테스트

자바 7, 71 70 68 바이트

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

너무 나쁜 charAt와는 indexOf너무 많은 바이트를 차지합니다 ..

Ungolfed 및 모든 테스트 사례 :

여기에서 시도하십시오.

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

산출:

W E S N E W N S

파이썬, 63 61 59 바이트

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

꽤 간단합니다. 확실히 더 골프 수 있습니다. 의 입력 색인에 1 또는 -1을 추가할지 여부를 결정합니다 'NESW'.

이것은 람다 식입니다. 사용하려면 앞에 접두사를 붙이십시오 f=.

무시 했어!

자바 8, 62 58 56 바이트

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

언 골프 테스트 프로그램

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 바이트

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

입력을 두 개의 명시 적 chars 로 취하고 a를 출력합니다 char.

이 작품은 다음과 같습니다 : 우리는 종류의 출력이, 우리가 원하는 경우 S /어떻게 든 같은 동일하게 N \, W /동일하게 E \, 등 또는, 적어도, 아직 아직 뚜렷한 "충분히 가까이"있는 생산 번호. ASCII 값을 보면 다음과 같은 테이블이 나타납니다.

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

summations 열에서 빠른 brute-forcer를 실행하면 (입력의 ASCII 코드 포인트를 합한 결과) 합을 취 8하면 다음과 같은 결과가 나타납니다 2 2 | 6 1 | 3 4 | 5 7. 즉 문자열에 입증 것 "xNESSWNW"같은 E인덱스이고 2, N에있다 6하고 1, 등등.

그래서, 우리가 (이 암시에서 캐스팅 입력 합 필요 char로 int32길을 따라)을 가져가 %8, 사용 우리의 문자열로 인덱스.

테스트 사례

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

배치, 111 바이트

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

예를 들어 W/2 문자 문자열 명령 행 매개 변수로 사용합니다. \와 /어색한 반복하게; 124 바이트가 걸렸을 것입니다.

옥타브, 30 바이트

Jonathan Allan과 동일한 순서의 인수를 사용했습니다.

입력을 2 자 문자열로 가져옵니다 'W\'.

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

온라인으로 사용해보십시오 .

C, 44, 35, 34 바이트

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

두 개의 변수로 두 개의 문자가 필요합니다. 소문자와 대문자가 모두 필요합니다. 많은 비트 조작을 사용합니다. 프래그먼트 a&a/2는 하위 2 비트에 대해 고유 한 값을 갖는 값을 생성하고 &3모든 상위 비트를 차단합니다. \미러 의 문자열 "NWES"에 대한 색인으로 사용되었습니다 . 다행히도, 낮은 두 ASCII 문자의 비트 \와 /의 올바른 방향을 얻기 위해 상기 인덱스 XOR으로 완벽하다 각각 00 및 11이다 /거울.

CJam , 17 바이트

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

입력은 공백으로 구분됩니다.

온라인으로 사용해보십시오! (줄 바꿈으로 구분 된 테스트 스위트입니다.)

이것이 도전 과제를 게시하기 전에 찾은 솔루션입니다. Jonathan의 순환 색인 작성만큼 짧지는 않지만이 접근법은 매우 흥미롭고 참신하다고 생각했습니다.

설명

목표는 음역을 사용하여 (즉 문자 대 문자 매핑을 사용하여) 입력 문자를 출력 문자로 바꾸는 것입니다. 그러기 위해서는 미러인지 /또는 에 따라 올바른 맵을 선택해야합니다 \. SWEN목록에서 조건부로 선택할 다른 목록으로 매핑 합니다. 입력 목록이 SWEN인 경우 두 출력 맵은 다음과 같아야합니다.

in  SWEN
/   ENSW
\   WSNE

이것들은 정렬 된 순서와 역 정렬 된 순서로되어 있습니다 (이렇게해서 임의의 SWEN순서를 입력 세트로 선택했습니다 ). 입력이 정렬되어 있으면 입력 목록을 정렬하고 결과를 반대로하여이를 생성 할 수 \있지만 더 좋은 방법이 있습니다.

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 (-r의 경우 42 + 1) 43

Martin Ender 덕분에 5를 저장했습니다 ♦

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

입력을 두 개의 문자열로 사용합니다.

수학, 98 바이트

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

익명의 기능. 두 개의 문자열을 입력으로 사용하고 문자열을 출력으로 반환합니다.

C, 81 바이트

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

용법

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

산출:

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

Pyth, 13 바이트

@."EW¹0`Y"sCM    

테스트 스위트

코드 포인트, 모듈 식 인덱스, 압축 문자열을 합산하십시오.

TI 기본, 40 바이트

입력을 하드 코드합니다. 지루하지만 가장 짧은 길.

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