İki boyutlu programlama dilleri genellikle ızgaradaki komut göstergesini yönlendiren /ve \yönlendiren ayna komutlarına sahiptir :

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

Bu mücadelede size bir giriş yönü ve bir ayna verilir ve giden yönü belirlemeniz gerekir.

kurallar

Gelen yön karakterlerden biri olarak verilecek NESWve ayna ya /da olarak verilecektir \. Bunları istediğiniz sırada alabilirsiniz. Büyük harf kullanmanız gerekir.

İki karakterli bir dize, karakterler arasındaki bazı ayırıcıları kullanan bir dize, bir listedeki bir çift karakter veya bir çift tekil dizge gibi herhangi bir uygun biçimde girdi alabilirsiniz. Ayırıcılı bir dize kullanırsanız, ayırıcı karakterlerden hiçbirini kullanamaz NWSE\/.

Çıktı, bir karakterden NESWveya bir karakterden oluşan bir karakter olmalıdır

Bir program veya fonksiyon yazabilir ve standart girdi alma ve çıktı alma yöntemlerimizden herhangi birini kullanabilirsiniz .

Herhangi bir programlama dilini kullanabilirsiniz , ancak bu boşlukların varsayılan olarak yasak olduğunu unutmayın .

Bu kod-golf , yani en kısa geçerli cevap - bayt cinsinden - kazanır.

Test Kılıfları

Kullanmanız gereken sadece 8 giriş vardır, bu nedenle kodunuzu hepsinde test etmemeniz için hiçbir sebep yoktur

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

Python, 40 38 bayt

@MitchSchwartz sayesinde -2 bayt (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

Çalışan sıra toplamının en küçük kipiyle indekslenen bir listede (AKA string) düz cevabın aranması.

Test vakaları ideone üzerinde

Python 2,40 bayt

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

Sp3000 bir bayt kaydetti ( .index→ .find).

açıklama

Şu gibi yol tariflerini haritalamak istiyoruz:

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

Yönleri 2 bitlik kodlar atayabilir ve her iki klibin de birinci ve ikinci bitleri XOR olarak görüntüleyebiliriz:

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

Bit dizeleri ve yol tarifleri arasındaki eşleme, dizge kullanılarak yapılır k. Şimdi sadece ayna karakterleri eşleştirmek için ihtiyaç '/'ve '\\'değerlerine 1ve 2. O zaman '/' < '\\', kesinlikle (m>'/')+1bir formül olarak kullanabiliyorduk . Fakat bekle! leksikografik,

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

ve biz 'NWES'güzel atadık k! Böylece (m>k)+1onun yerine kullanabiliriz .

CJam, 14 bayt

(@MartinEnder Python cevabımı iletti )

l1b" NESSWNW"=

Nasıl?

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

Testler aditsu'da

Javascript (ES6), 50 41 40 37 bayt

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

Lynn'in cevabı sayesinde karşılaştırma kullanarak 3 bayt daha tasarruf etti

kullanım

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 bayt

'NWSE'jy&mjy+Eq-)

Çevrimiçi deneyin! Veya sekiz vakayı doğrulayın .

açıklama

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

Her biri -1 bayt için @Jakube ve @Maltysen'e teşekkürler

@J"NWES"xxJQh>E

İki yeni satırla ayrılmış alıntı dizenin girişini alan, önce yön, sonra ayna ve bir sonucu yazdırır.

Bu @ Lynn'in Python cevabının limanı .

Çevrimiçi deneyin

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Jelly , 14 13 12 bayt

( Python cevabımın bir limanı )
@MartinEnder sayesinde -1 bayt (dizgenin sonuna bir boşluk ekler ve modulo 8 gereksinimini kaldırır)
@LuisMendo sayesinde -1 bayt (iki yerine tek bir dize argümanı alır)

OSị“NESSWNW 

Nasıl?

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'da test edin

Java 7, 71 70 68 bayt

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

Çok kötü charAtve indexOfçok fazla bayt alır ..

Ungolfed ve tüm test durumları:

Burada dene.

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

Çıktı:

W E S N E W N S

Python, 63 61 59 bayt

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

Oldukça basit. Kesinlikle daha çok golf oynayabilirsin. İçindeki girişin dizinine 1 mi yoksa 1 mi mi ekleneceğine karar verir 'NESW'.

Bu bir lambda ifadesidir; kullanmak için önek ile birlikte kullanın f=.

Ideone!

Java 8, 62 58 56 bayt

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

Ungolfed test programı

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 bayt

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

Girişi iki açık olarak alır char s olarak alır, çıktı a char.

Bu aşağıdaki gibi çalışır: bir nevi çıkış, biz isterseniz S /nasılsa aynı eşit N \, W /eşit E \, vb Or, en azından, hala henüz ayrı "yeterince yakın" olan üretim sayıları. ASCII değerlerine bakarsak aşağıdaki gibi bir tablo alırız:

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

Toplama sütununda hızlı bir kabadayı çalıştırma (girdilerin ASCII kod noktalarının toplanmasından türetilmiş), modulo toplamlarını 8alırsak aşağıdakileri elde ettiğimizi gösterir 2 2 | 6 1 | 3 4 | 5 7. Yani dizede kanıtlandığı oluyor "xNESSWNW"gibi Eendeksinde ise 2, Naltındadır6 ve 1, vb.

Bu nedenle, sadece girdileri toplamamız chargerekiyor.int32 yol boyunca), al %8ve kullanım bizim dizeye indeksine.

Test Kılıfları

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

Toplu iş, 111 bayt

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

Örneğin W/, iki karakterli bir dize komut satırı parametresi olarak kabul eder. \Ve /zor döngü yapmak; 124 byte alırdı.

Oktav, 30 bayt

Jonathan Allan ile aynı argüman dizisini kullandı.

Girişi iki karakterli dizge olarak alır 'W\'.

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

Çevrimiçi deneyin .

C, 44, 35, 34 bayt

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

İki değişken olarak iki karakter gerektirir. Hem küçük hem de büyük harf alır. Çok fazla bit manipülasyon kullanır. Parça a&a/2, alt iki bit için benzersiz değerlere sahip bir değerle sonuçlanır, &3tüm yüksek bitleri keser. Bu, \ayna için "NWES" dizgisine bir dizin olarak kullanılır . Neyse ki, alt iki ASCII karakter bitleri \ve /doğru yöne almak için yukarıda belirtilen dizini ile XOR için mükemmel olan sırasıyla 00 ve 11 olan /ayna.

CJam , 17 bayt

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

Giriş boşlukla ayrılmış.

Çevrimiçi deneyin! (Satır ayrılmış bir test takımı olarak.)

Bu, mücadeleyi göndermeden önce bulduğum çözüm. Jonathan'ın döngüsel indekslemesi kadar kısa değil, ama bu yaklaşımın oldukça ilginç (ve yeni) olduğunu düşündüm.

açıklama

Amaç, girdi karakterini çıktı karakteriyle değiştirmek için harf çevirisi (yani karakter karakter eşlemesi kullanarak) kullanmaktır. Bunu yapmak için, aynanın /ya da olduğuna göre doğru haritayı seçmemiz gerekir \. Biz dan map edeceğiz SWENbiz şartlı seçeceğiz başka birine listede. Giriş listesi ise SWEN, iki çıkış haritasının aşağıdaki olması gerekir:

in  SWEN
/   ENSW
\   WSNE

Bunların sıralı ve ters sıralı olduklarına dikkat edin (bu nedenle SWENgirdi kümesi olarak görünüşte rastgele sırayı seçtik ). Bunları giriş listesini ve giriş varsa sonucu tersine çevirerek oluşturabiliriz \, ancak daha iyi bir yol var:

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 için 42 + 1) 43

Martin Ender 5 sayesinde 5 kurtardı ♦

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

Girdiyi iki karakterli dizge olarak alır.

Mathematica, 98 bayt

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

Anonim işlev Girdi olarak iki dizge alır ve çıktı olarak bir dizge döndürür.

C, 81 bayt

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

kullanım

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

Çıktı:

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

Pyth, 13 bayt

@."EW¹0`Y"sCM    

Test odası

Kod noktalarını, modüler indeksi, sıkıştırılmış dizeyi toplayın.

TI-Basic, 40 bayt

Girişleri sabit kodlar. Sıkıcı, ama en kısa yol.

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