Miroir, Miroir, dans le Code


26

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

1
Dans les langues où les barres obliques inverses doivent être échappées en entrée, pouvons-nous supposer que l'entrée sera "\\" le cas échéant?
JDL

4
@JDL La chaîne (ou le caractère) réel doit contenir un seul \. Si votre réponse est une soumission de fonction qui prend une chaîne, alors vous aurez bien sûr besoin \\dans le code source de l'appeler correctement, mais si vous lisez votre entrée à partir d'une entrée standard, par exemple, alors ce devrait être une seule \. En d'autres termes, si vous appelez la fonction de longueur de chaîne respective de votre langue sur l'entrée, le résultat doit toujours être le même, que l'entrée contienne /ou \.
Martin Ender

D'accord, je m'attendais à ce que R ait des problèmes lorsqu'un "\" non échappé a été entré via stdin, mais readline()je peux le gérer.
JDL

1
@JDL Vous devez probablement entrer la chaîne qui échappe (duplique) ce symbole, mais la chaîne résultante sera "N \"
Luis Mendo

Réponses:


24

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


Dangit, je pensais que j'étais super intelligent en prenant les valeurs ASCII, en les additionnant %8et en faisant un index. Ensuite, je vois que vous avez publié la même solution il y a plus d'une heure. Hah. Avoir un +1.
AdmBorkBork

21

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.


12

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


6

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


Utilisation intelligente des comparaisons ASCII pour obtenir votre condition à la fin en jouant votre chemin ...
WallyWest

6

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

6

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

vous pouvez enregistrer un autre octet en le remplaçant <QEpar >E.
Maltysen

4

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!


4

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


4

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

3

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!


3

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
}

}

3

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

2

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.


Idk, je compte 96 octets. Vous en êtes dépouillé \r?
Conor O'Brien

@ ConorO'Brien J'écris mes fichiers batch à l'aide du Bloc-notes, donc non.
Neil

2

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 .


Agréable! Vous pouvez souhaiter effectuer un portage vers MATL: 'NESSWNW 'is)(voir tous les cas de test ). iest input, sest sumet )est l'indexation, qui est modulaire. J'ai ajouté un espace dans la chaîne pour que le modulo soit 8
Luis Mendo

Merci :) Je sens que c'est de la triche si j'ajoute cela comme une réponse séparée, car je ne l'ai pas écrit moi-même. Je peux l'ajouter à cette réponse si vous ne voulez pas y répondre vous-même :)
Stewie Griffin

Je comprends, je ferais probablement la même chose :-) Je ne veux pas modifier ma réponse, car c'est une approche totalement différente que je n'ai pas trouvée. Je ne suis pas sûr que l'ajouter à votre réponse soit logique, car ce serait deux langues différentes dans la réponse
Luis Mendo

Ce serait ma première réponse MATL cependant: PI voit qu'elle est plus longue que votre réponse MATL, donc je ne pense pas que je vais l'ajouter ...
Stewie Griffin

2

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.


2
Agréable! Vous avez manqué un -1 octet évident, cependant: return"NWES"[...](omettez l'espace).
Tim Čas

Merci Tim, il ne m'était pas
venu à l'idée

1

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.

1

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.


0

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.


0

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  

Fonctionne uniquement sur les valeurs codées en dur car utilise des comparaisons de pointeurs.
Sami Kuhmonen

0

Pyth, 13 octets

@."EW¹0`Y"sCM    

Suite de tests

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


0

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
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.