Les langages de programmation bidimensionnels ont souvent des commandes miroir comme /et \pour rediriger le pointeur d'instructions sur la grille:

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

Dans ce défi, vous recevez une direction entrante et un miroir et vous devez déterminer la direction sortante.

Règles

La direction entrante sera donnée comme l'un des caractères NESWet le miroir sera donné comme /ou \. Vous pouvez les recevoir dans n'importe quel ordre. Vous devez utiliser des lettres majuscules.

Vous pouvez prendre des entrées dans n'importe quel format pratique, y compris une chaîne de deux caractères, une chaîne utilisant un séparateur entre les caractères, une paire de caractères dans une liste ou même une paire de chaînes singleton. Si vous utilisez une chaîne avec séparateur, le séparateur ne peut utiliser aucun des caractères NWSE\/.

La sortie doit être un caractère de NESWou une chaîne à un seul caractère.

Vous pouvez écrire un programme ou une fonction et utiliser l'une de nos méthodes standard de réception d'entrée et de sortie.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

Il s'agit de code-golf , donc la réponse valide la plus courte - mesurée en octets - l'emporte.

Cas de test

Il n'y a que 8 entrées possibles que vous devez gérer, il n'y a donc aucune excuse pour ne pas tester votre code sur chacune d'entre elles:

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

Python, 40 38 octets

-2 octets grâce à @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

recherche simple de réponse dans une liste (chaîne AKA) indexée par le plus petit mod de la somme des ordinaux qui fonctionne.

Les cas de test sont sur idéone

Python 2, 40 octets

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

Sp3000 a enregistré un octet ( .index→ .find).

Explication

Nous voulons cartographier les directions comme suit:

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

Nous pouvons affecter les codes de direction à 2 bits et afficher les deux flips comme XOR-ing les premier et deuxième bits:

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

Le mappage entre les chaînes de bits et les directions s'effectue à l'aide de la chaîne k. Il ne nous reste plus qu'à mapper les caractères miroirs '/'et '\\'les valeurs 1et 2. Depuis '/' < '\\', nous pourrions naïvement utiliser (m>'/')+1comme formule. Mais attendez! Lexicographiquement,

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

et nous nous sommes 'NWES'gentiment assignés à k! Nous pouvons donc utiliser à la (m>k)+1place.

CJam, 14 octets

(@MartinEnder a porté ma réponse Python )

l1b" NESSWNW"=

Comment?

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

Les tests sont sur aditsu

Javascript (ES6), 50 41 40 37 octets

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

Enregistré 3 octets de plus en utilisant la comparaison, grâce à la réponse de Lynn

Usage

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 octets

'NWSE'jy&mjy+Eq-)

Essayez-le en ligne! Ou vérifiez les huit cas .

Explication

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

Merci à @Jakube et @Maltysen pour -1 octet chacun

@J"NWES"xxJQh>E

Un programme qui prend en entrée deux chaînes entre guillemets séparés par des sauts de ligne, d'abord la direction, puis le miroir, et imprime le résultat.

Il s'agit d'un portage de la réponse Python de @ Lynn .

Essayez-le en ligne

Comment ça marche

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

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

Essayez-le en ligne!

Gelée , 14 13 12 octets

(un port de ma réponse Python )
-1 octet grâce à @MartinEnder (ajouter un espace à la fin de la chaîne et supprimer le besoin de modulo 8)
-1 octet grâce à @LuisMendo (prendre un seul argument de chaîne plutôt que deux)

OSị“NESSWNW 

Comment?

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)

Testez-le sur TryItOnline

Java 7, 71 70 68 octets

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

Dommage charAtet indexOfprend tellement d'octets ..

Non testés et tous les cas de test:

Essayez-le ici.

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

Sortie:

W E S N E W N S

Python, 63 61 59 octets

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

Assez simple. Peut certainement être joué au golf plus. Décide d'ajouter 1 ou -1 à l'index de l'entrée dans 'NESW'.

Il s'agit d'une expression lambda; pour l'utiliser, préfixez-le avec f=.

Ideone it!

Java 8, 62 58 56 octets

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

Programme de test non golfé

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 octets

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

Prend l'entrée comme deux chars explicites , produit unchar .

Cela fonctionne comme suit: Si nous trions la sortie, nous voulons S /en quelque sorte égaler N \, W /égaler E \, etc. Ou, au moins, produire des nombres qui sont "assez proches" mais toujours distincts. Si nous regardons les valeurs ASCII, nous obtenons un tableau comme ci-dessous:

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

L'exécution d'un brutal forcer rapide sur la colonne des sommations (dérivée de la sommation des points de code ASCII des entrées) montre que si nous prenons les sommes modulo 8, nous obtenons ce qui suit 2 2 | 6 1 | 3 4 | 5 7. Cela est mis en évidence dans la chaîne "xNESSWNW", comme Ec'est à l'index 2, Nest à 6et1 , et ainsi de suite.

Donc, nous avons juste besoin de additionner les entrées (transtypage implicite du charau int32long du chemin), de prendre cela%8 et de l'utiliser pour indexer dans notre chaîne.

Cas de test

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

Lot, 111 octets

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

Accepte par W/exemple un paramètre de ligne de commande de chaîne à deux caractères. Le \et /rend la boucle maladroite; cela aurait pris 124 octets.

Octave, 30 octets

Utilisé le même ordre d'arguments que Jonathan Allan.

Prend l'entrée comme une chaîne de deux caractères 'W\'.

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

Essayez-le en ligne .

C, 44, 35, 34 octets

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

Il nécessite deux caractères comme deux variables. Il faut à la fois des minuscules et des majuscules. Il utilise beaucoup de manipulation de bits. Le fragment se a&a/2traduit par une valeur qui a des valeurs uniques pour les deux bits inférieurs, &3coupe tous les bits supérieurs. Ceci utilisé comme index dans la chaîne "NWES" pour le \miroir. Heureusement, les deux bits inférieurs des caractères ASCII \et /sont 00 et 11 respectivement, ce qui est parfait pour XOR avec l'index susmentionné pour obtenir la bonne direction pour le /miroir.

CJam , 17 octets

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

L'entrée est séparée par des espaces.

Essayez-le en ligne!(En tant que suite de tests séparés par des sauts de ligne.)

C'est la solution que j'ai trouvée avant de poster le défi. Pas aussi court que l'indexation cyclique de Jonathan, mais j'ai trouvé cette approche assez intéressante (et nouvelle).

Explication

L'objectif est d'utiliser la translittération (c'est-à-dire en utilisant un mappage de caractère à caractère) pour remplacer le caractère d'entrée par le caractère de sortie. Pour ce faire, nous devons sélectionner la bonne carte selon que le miroir est /ou \. Nous allons mapper de la SWENliste à une autre que nous sélectionnerons conditionnellement. Si la liste d'entrée est SWEN, les deux mappes de sortie doivent être les suivantes:

in  SWEN
/   ENSW
\   WSNE

Notez que ceux-ci sont classés par ordre trié et inversé (c'est pourquoi nous avons choisi l' SWENordre apparemment aléatoire comme ensemble d'entrée). Nous pourrions les générer en triant la liste d'entrée et en inversant le résultat si l'entrée a \, mais il existe une meilleure façon:

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

Enregistré 5 grâce à Martin Ender ♦

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

Prend l'entrée comme une chaîne de deux caractères.

Mathematica, 98 octets

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

Fonction anonyme. Prend deux chaînes en entrée et renvoie une chaîne en sortie.

C, 81 octets

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

Usage

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

Sortie:

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

Pyth, 13 octets

@."EW¹0`Y"sCM    

Suite de tests

Additionnez les points de code, l'index modulaire, la chaîne compressée.

TI-Basic, 40 octets

Codez en dur les entrées. Ennuyeux, mais le plus court chemin.

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