ภาษาโปรแกรมสองมิติมักจะมีคำสั่งมิรเรอร์เช่น/และ\เปลี่ยนเส้นทางตัวชี้คำสั่งในตาราง:

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

ในความท้าทายนี้คุณจะได้รับทิศทางขาเข้าและกระจกเงาและคุณต้องกำหนดทิศทางขาออก

กฎระเบียบ

ทิศทางเข้ามาจะได้รับเป็นหนึ่งในตัวละครNESWและกระจกจะได้รับเป็นอย่างใดอย่างหนึ่งหรือ/ \คุณอาจได้รับสิ่งเหล่านี้ในลำดับใดก็ได้ คุณต้องใช้ตัวอักษรตัวพิมพ์ใหญ่

คุณสามารถป้อนข้อมูลในรูปแบบที่สะดวกรวมถึงสตริงอักขระสองตัวสตริงที่ใช้ตัวคั่นระหว่างอักขระอักขระคู่ในรายการหรือแม้แต่สตริงเดี่ยว หากคุณใช้สตริงที่มีตัวคั่นตัวคั่นจะไม่สามารถใช้อักขระใด ๆNWSE\/ได้

เอาต์พุตควรเป็นอักขระจากNESWหรือสตริงอักขระเดี่ยว

คุณสามารถเขียนโปรแกรมหรือฟังก์ชั่นและใช้วิธีการมาตรฐานของเราในการรับอินพุตและให้เอาต์พุต

คุณอาจใช้ภาษาการเขียนโปรแกรมใด ๆแต่โปรดทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามตามค่าเริ่มต้น

นี่คือรหัสกอล์ฟดังนั้นคำตอบที่สั้นที่สุดที่ถูกต้อง - วัดเป็นไบต์ - ชนะ

กรณีทดสอบ

มีเพียง 8 อินพุตที่เป็นไปได้ที่คุณต้องจัดการดังนั้นจึงไม่มีข้อแก้ตัวใด ๆ ที่จะไม่ทดสอบโค้ดของคุณกับพวกเขาทั้งหมด:

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

Python 40 40ไบต์

-2 ไบต์ขอบคุณ @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

ค้นหาคำตอบธรรมดาในรายการ (สตริง AKA) จัดทำดัชนีโดย mod ที่เล็กที่สุดของผลรวมของเลขลำดับที่ใช้งานได้

กรณีทดสอบอยู่ในideone

Python 2, 40 ไบต์

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

Sp3000 บันทึกหนึ่งไบต์ ( .index→ .find)

คำอธิบาย

เราต้องการทำแผนที่เส้นทางดังนี้:

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

เราสามารถกำหนดทิศทางรหัส 2 บิตและดูการพลิกทั้งสองเป็น XOR-ing บิตแรกและบิตที่สอง:

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

kการทำแผนที่ระหว่างบิตสตริงและทิศทางที่เกิดขึ้นโดยใช้สตริง ตอนนี้เราก็ต้อง map ตัวละครกระจก'/'และ'\\'ค่าที่และ1 2เนื่องจาก'/' < '\\'เราไม่สามารถใช้(m>'/')+1เป็นสูตรได้อย่างไร้เดียงสา แต่เดี๋ยวก่อน! lexicographically,

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

และเราได้'NWES'รับมอบหมายอย่างดีให้k! ดังนั้นเราสามารถใช้(m>k)+1แทน

CJam, 14 ไบต์

(@MartinEnder แจ้งคำตอบของPythonของฉัน)

l1b" NESSWNW"=

อย่างไร?

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

การทดสอบอยู่ในaditsu

Javascript (ES6), 50 41 40 37 ไบต์

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

บันทึกอีก 3 ไบต์โดยใช้การเปรียบเทียบต้องขอบคุณคำตอบของ Lynn

การใช้

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 ไบต์

ขอบคุณ @Jakube และ @Maltysen สำหรับแต่ละ -1 ไบต์

@J"NWES"xxJQh>E

โปรแกรมที่รับอินพุตของสตริงที่ยกมาสองบรรทัดที่คั่นด้วยบรรทัดใหม่ก่อนอื่นกำหนดทิศทางจากนั้นเป็นมิรเรอร์และพิมพ์ผลลัพธ์

นี่คือท่าเรือ @ ลินน์หลามคำตอบ

ลองออนไลน์

มันทำงานอย่างไร

@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 ไบต์

(พอร์ตของคำตอบ Pythonของฉัน)
-1 ไบต์ขอบคุณ @MartinEnder (เพิ่มช่องว่างที่ส่วนท้ายของสตริงและลบความต้องการโมดูโล 8)
-1 ไบต์ขอบคุณ @LuisMendo (ใช้อาร์กิวเมนต์สตริงเดี่ยวมากกว่าสอง)

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

Java 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

Python, 63 61 59 ไบต์

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

ค่อนข้างง่าย สามารถตีกอล์ฟได้มากกว่านี้อย่างแน่นอน ตัดสินใจว่าจะเพิ่ม 1 หรือ -1 ลงในดัชนีของอินพุต'NESW'หรือไม่

นี่คือการแสดงออกแลมบ์ดา; f=ที่จะใช้มันคำนำหน้ามันด้วย

ไอเดียมัน!

Java 8, 62 58 56 ไบต์

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

โปรแกรมทดสอบ Ungolfed

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

วิ่งเดรัจฉาน forcer รวดเร็วใน summations คอลัมน์ (มาจากข้อสรุปจุดรหัส 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/เป็นพารามิเตอร์บรรทัดคำสั่งสตริงอักขระสองตัว \และ/ทำให้การวนลูปที่น่าอึดอัดใจ; มันจะใช้เวลา 124 ไบต์

อ็อกเทฟ 30 ไบต์

ใช้ลำดับของการขัดแย้งเช่นเดียวกับ Jonathan Allan

'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ผลในมูลค่าที่มีค่าไม่ซ้ำกันสำหรับที่ต่ำกว่าสองบิตการ&3ตัดบิตที่สูงขึ้นทั้งหมด ใช้เป็นดัชนีในสตริง "NWES" สำหรับ\มิเรอร์ โชคดีที่อักขระ ASCII สองบิตที่ต่ำกว่า\และ/คือ 00 และ 11 ตามลำดับซึ่งเหมาะสำหรับ XOR ด้วยดัชนีข้างต้นเพื่อให้ได้ทิศทางที่ถูกต้องสำหรับ/มิเรอร์

CJam , 17 ไบต์

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

อินพุตถูกคั่นด้วยช่องว่าง

ลองออนไลน์! (ในฐานะชุดทดสอบที่แยกบรรทัดด้วยฟีด)

นี่เป็นวิธีการแก้ปัญหาที่ฉันพบก่อนโพสต์ความท้าทาย ไม่สั้นเท่ากับการจัดทำดัชนีแบบวนรอบของโจนาธาน แต่ฉันคิดว่าวิธีนี้น่าสนใจมาก (และแปลกใหม่)

คำอธิบาย

เป้าหมายคือใช้การทับศัพท์ (เช่นใช้การจับคู่ระหว่างอักขระกับอักขระ) เพื่อแทนที่อักขระอินพุตด้วยอักขระเอาต์พุต การทำเช่นนี้เราต้องเลือกแผนที่ที่ถูกต้องขึ้นอยู่กับว่าเป็นกระจกหรือ/ \เราจะแมปจาก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 (42 + 1 สำหรับ -r) 43

บันทึก 5 ขอบคุณ Martin Ender ♦

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

รับอินพุตเป็นสตริงอักขระสองตัว

Mathematica ขนาด 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-Basic, 40 ไบต์

ฮาร์ดอินพุตอินพุต น่าเบื่อ แต่วิธีที่สั้นที่สุด

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