Spiegel, Spiegel, im Code

26

Zweidimensionale Programmiersprachen verfügen häufig über Spiegelbefehle wie /und \zum Umleiten des Befehlszeigers auf dem Raster:

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

In dieser Herausforderung erhalten Sie eine Eingangsrichtung und einen Spiegel und müssen die Ausgangsrichtung bestimmen.

Regeln

Die ankommende Richtung wird als eines der Zeichen NESWund der Spiegel als entweder /oder angegeben \. Sie können diese in beliebiger Reihenfolge erhalten. Sie müssen Großbuchstaben verwenden.

Sie können Eingaben in jedem geeigneten Format vornehmen, einschließlich einer Zeichenfolge mit zwei Zeichen, einer Zeichenfolge mit Trennzeichen zwischen den Zeichen, einem Zeichenpaar in einer Liste oder sogar einem Paar Singleton-Zeichenfolgen. Wenn Sie eine Zeichenfolge mit Trennzeichen verwenden, kann das Trennzeichen keine der Zeichen verwenden NWSE\/.

Die Ausgabe sollte ein Zeichen NESWoder eine Einzelzeichenfolge sein.

Sie können ein Programm oder eine Funktion schreiben und eine unserer Standardmethoden zum Empfangen und Bereitstellen von Eingaben verwenden.

Sie können jede Programmiersprache verwenden , beachten Sie jedoch, dass diese Lücken standardmäßig verboten sind.

Das ist , also gewinnt die kürzeste gültige Antwort - gemessen in Bytes .

Testfälle

Es gibt nur 8 mögliche Eingaben, die Sie verarbeiten müssen. Es gibt also keine Entschuldigung, Ihren Code nicht auf allen zu testen:

N /   -->   W
N \   -->   E
E /   -->   S
E \   -->   N
S /   -->   E
S \   -->   W
W /   -->   N
W \   -->   S
Martin Ender
quelle
1
Dürfen wir in Sprachen, in denen Backslashes bei der Eingabe maskiert werden müssen, gegebenenfalls von der Eingabe "\\" ausgehen?
JDL
4
@JDL Die tatsächliche Zeichenfolge (oder das tatsächliche Zeichen) sollte eine einzelne Zeichenfolge enthalten \. Wenn es sich bei Ihrer Antwort um eine Funktionsübermittlung handelt, die einen String enthält, müssen Sie \\den Quellcode natürlich korrekt aufrufen, aber wenn Sie beispielsweise Ihre Eingabe von der Standardeingabe lesen, sollte es sich um eine einzelne Eingabe handeln \. Mit anderen Worten, wenn Sie die entsprechende Zeichenfolgenlängenfunktion Ihrer Sprache für die Eingabe aufrufen, sollte das Ergebnis immer gleich sein, unabhängig davon, ob die Eingabe /oder enthält \.
Martin Ender
In Ordnung, ich hatte erwartet, dass R Probleme hat, wenn ein "\" ohne Fluchtzeichen über stdin eingegeben wird, aber ich readline()kann damit umgehen.
JDL
1
@JDL Sie müssen wahrscheinlich die Zeichenfolge eingeben, die diesem Symbol entgeht (dupliziert), aber die resultierende Zeichenfolge ist "N \"
Luis Mendo

Antworten:

24

Python, 40 38 Bytes

-2 Bytes dank @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

Einfache Suche nach Antworten in einer Liste (AKA-Zeichenfolge), die durch den kleinsten Mod der Summe der funktionierenden Ordnungszahlen indiziert ist.

Testfälle sind auf ideone

Jonathan Allan
quelle
Verdammt, ich fand es super clever, die ASCII-Werte zu nehmen, sie zu summieren %8und einen Index zu erstellen . Dann haben Sie dieselbe Lösung vor über einer Stunde gepostet. Hah Habe eine +1.
AdmBorkBork
21

Python 2, 40 Bytes

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

Sp3000 hat ein Byte gespeichert ( .index.find).

Erläuterung

Wir wollen die Richtungen so abbilden:

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

Wir können die Richtungen 2-Bit-Codes zuweisen und beide Flip als XOR-Verknüpfung des ersten und des zweiten Bits anzeigen:

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

Die Zuordnung zwischen Bitfolgen und Richtungen erfolgt mithilfe der Zeichenfolge k. Jetzt müssen wir nur noch Spiegelzeichen '/'und '\\'den Werten 1und zuordnen 2. Da '/' < '\\'könnten wir naiv (m>'/')+1als Formel verwenden. Aber warte! Lexikographisch,

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

und das haben wir 'NWES'schön zugeteilt k! Also können wir (m>k)+1stattdessen verwenden.

Lynn
quelle
12

CJam, 14 Bytes

(@MartinEnder hat meine Python-Antwort portiert )

l1b" NESSWNW"=

Wie?

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

Tests sind auf Aditsu

Jonathan Allan
quelle
6

Javascript (ES6), 50 41 40 37 Bytes

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

Dank Lynns Antwort konnten durch den Vergleich 3 weitere Bytes eingespart werden

Verwendung

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

Arnauld
quelle
Clevere Verwendung von ASCII-Vergleichen, um Ihren Zustand am Ende nach Ihren
Wünschen zu bestimmen
6

MATL , 19 17 Bytes

'NWSE'jy&mjy+Eq-)

Probieren Sie es online! Oder überprüfen Sie die acht Fälle .

Erläuterung

'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
Luis Mendo
quelle
6

Pyth, 17 16 15 Bytes

Vielen Dank an @Jakube und @Maltysen für jeweils -1 Byte

@J"NWES"xxJQh>E

Ein Programm, das zwei durch Zeilenumbrüche getrennte, in Anführungszeichen gesetzte Zeichenfolgen eingibt, zuerst die Richtung und dann den Spiegel und das Ergebnis druckt.

Dies ist eine Portierung von @Lynns Python- Antwort .

Probieren Sie es online aus

Wie es funktioniert

@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
TheBikingViking
quelle
Sie können durch das Ersetzen ein weiteres Byte speichern <QEmit >E.
Maltysen
4

05AB1E , 14 Bytes

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

Probieren Sie es online!

Emigna
quelle
4

Jelly , 14 13 12 Bytes

(ein Port meiner Python-Antwort )
-1 Byte dank @MartinEnder (füge ein Leerzeichen am Ende des Strings hinzu und entferne die Notwendigkeit für Modulo 8)
-1 Byte dank @LuisMendo (nimm ein einziges String-Argument anstatt zwei)

OSị“NESSWNW 

Wie?

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)

Testen Sie es auf TryItOnline

Jonathan Allan
quelle
4

Java 7, 71 70 68 Bytes

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

Schade das charAtund indexOfnimmt so viel Bytes ein ..

Ungolfed & alle Testfälle:

Probieren Sie es hier aus.

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

Ausgabe:

W E S N E W N S
Kevin Cruijssen
quelle
3

Python, 63 61 59 Bytes

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

Ziemlich einfach. Kann definitiv mehr golfen werden. Legt fest, ob 1 oder -1 zum Index der Eingabe in hinzugefügt werden soll 'NESW'.

Dies ist ein Lambda-Ausdruck; Um es zu benutzen, stellen Sie es mit dem Präfix f=.

Ideone es!

Kupfer
quelle
3

Java 8, 62 58 56 Bytes

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

Ungolfed Testprogramm

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
}

}
Shaun Wild
quelle
3

PowerShell v2 +, 34 Byte

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

Nimmt die Eingabe als zwei explizite chars, gibt a aus char.

Dies funktioniert wie folgt: Wenn wir die Ausgabe sortieren, möchten wir S /irgendwie gleich N \, W /gleich E \usw. sein. Oder zumindest Zahlen erzeugen, die "nah genug" und dennoch verschieden sind. Wenn wir uns die ASCII-Werte ansehen, erhalten wir eine Tabelle wie die folgende:

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

Das Ausführen eines schnellen Brute-Forcers für die Summationsspalte (abgeleitet aus dem Summieren der ASCII-Codepunkte der Eingaben) zeigt, dass wir 8Folgendes erhalten , wenn wir die Summen modulo nehmen 2 2 | 6 1 | 3 4 | 5 7. Dies zeigt sich in der Zeichenfolge "xNESSWNW", wie Eim Index 2, Nin 6und 1und so weiter.

Also müssen wir nur die Eingaben summieren (implizit von charbis int32auf dem Weg umwandeln), diese nehmen %8und diese verwenden, um in unseren String zu indexieren.

Testfälle

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
AdmBorkBork
quelle
2

Batch, 111 Bytes

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

Akzeptiert zB W/als zweistelligen String-Kommandozeilenparameter. Das \und /macht das Schleifen umständlich; Es hätte 124 Bytes gedauert.

Neil
quelle
Idk, ich zähle 96 Bytes. Hast du dich davon befreit \r?
Conor O'Brien
@ ConorO'Brien Ich schreibe meine Batch-Dateien mit Notepad, also nein.
Neil
2

Oktave, 30 Bytes

Verwendete die gleiche Reihenfolge der Argumente wie Jonathan Allan.

Übernimmt die Eingabe als zweistellige Zeichenfolge 'W\'.

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

Probieren Sie es online aus .

Stewie Griffin
quelle
Nett! Möglicherweise möchten Sie nach MATL portieren: 'NESSWNW 'is)(siehe alle Testfälle ). iis input, sis sumund )is indexing ist modular aufgebaut. Ich habe ein Leerzeichen in der Zeichenfolge hinzugefügt, damit das Modulo 8 ist
Luis Mendo
Danke :) Ich fühle mich betrogen, wenn ich das als separate Antwort hinzufüge, da ich es selbst nicht geschrieben habe. Ich kann es zu dieser Antwort hinzufügen, wenn Sie es nicht selbst beantworten möchten :)
Stewie Griffin
Ich verstehe, ich würde wahrscheinlich das Gleiche tun :-) Ich möchte meine Antwort nicht ändern, da es ein völlig anderer Ansatz ist, den ich mir nicht ausgedacht habe. Es ist jedoch nicht sicher, ob es Sinn macht, es zu Ihrer Antwort hinzuzufügen, da die Antwort zwei verschiedene Sprachen enthalten würde
Luis Mendo
Es wäre allerdings meine erste MATL-Antwort: Ich sehe, es ist länger als Ihre MATL-Antwort, also glaube ich nicht, dass ich es hinzufügen werde ...
Stewie Griffin,
2

C, 44, 35, 34 Bytes

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

Es erfordert zwei Zeichen als zwei Variablen. Es dauert sowohl Klein- als auch Großbuchstaben. Es erfordert viel Bit-Manipulation. Das Fragment a&a/2führt zu einem Wert, der eindeutige Werte für die beiden niedrigeren Bits hat &3und alle höheren Bits abschneidet. Dies wird als Index für die Zeichenfolge "NWES" für den \Spiegel verwendet. Glücklicherweise sind die unteren zwei Bits der ASCII - Zeichen \und /sind 00 und 11 verbunden, die zu XOR mit dem oben erwähnten Index perfekt ist die richtige Richtung für den bekommen /Spiegel.

G. Sliepen
quelle
2
Nett! Sie haben jedoch ein offensichtliches -1-Byte übersehen: return"NWES"[...](Leerzeichen weglassen).
Tim Čas
Danke Tim, es war mir nicht aufgefallen, dass das gültig sein würde C :)
G. Sliepen
1

CJam , 17 Bytes

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

Die Eingabe ist durch Leerzeichen getrennt.

Probieren Sie es online! (Als durch Zeilenvorschub getrennte Testsuite.)

Dies ist die Lösung, die ich vor dem Posten der Herausforderung gefunden habe. Nicht so kurz wie Jonathans zyklische Indexierung, aber ich fand diesen Ansatz sehr interessant (und neuartig).

Erläuterung

Das Ziel ist die Verwendung der Transliteration (dh die Verwendung einer Zeichen-zu-Zeichen-Zuordnung), um das Eingabezeichen durch das Ausgabezeichen zu ersetzen. Dazu müssen wir die richtige Karte auswählen, je nachdem, ob es sich um einen Spiegel handelt /oder nicht \. Wir ordnen von der SWENListe eine andere zu, die wir unter bestimmten Bedingungen auswählen. Wenn die Eingabeliste lautet SWEN, müssen die beiden Ausgabe-Maps die folgenden sein:

in  SWEN
/   ENSW
\   WSNE

Beachten Sie, dass diese in sortierter und umgekehrter Reihenfolge vorliegen (weshalb wir die scheinbar zufällige SWENReihenfolge als Eingabesatz gewählt haben). Wir könnten diese generieren, indem wir die Eingabeliste sortieren und das Ergebnis umkehren, wenn die Eingabe dies aufweist. Es gibt \jedoch einen besseren Weg:

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.
Martin Ender
quelle
1

SED 48 (42 + 1 für -r) 43

5 Dank an Martin Ender gespart ♦

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

Nimmt die Eingabe als zweistellige Zeichenfolge an.

Riley
quelle
0

Mathematica, 98 Bytes

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

Anonyme Funktion. Nimmt zwei Zeichenfolgen als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück.

LegionMammal978
quelle
0

C 81 Bytes

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

Verwendung

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

Ausgabe:

N/      : W  
N\      : E  
E/      : S  
E\      : N  
S/      : E  
S\      : W  
W/      : N  
W\      : S  
Giacomo Garabello
quelle
Funktioniert nur mit fest codierten Werten, da Zeigervergleiche verwendet werden.
Sami Kuhmonen
0

Pyth, 13 Bytes

@."EW¹0`Y"sCM    

Testsuite

Summieren Sie die Codepunkte, den modularen Index und die komprimierte Zeichenfolge.

isaacg
quelle
0

TI-Basic, 40 Bytes

Codiert die Eingaben fest. Langweilig, aber der kürzeste Weg.

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