Specchio, specchio, nel codice


26

I linguaggi di programmazione bidimensionali hanno spesso comandi mirror simili /e \per reindirizzare il puntatore di istruzioni sulla griglia:

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

In questa sfida, ti viene data una direzione in entrata e uno specchio e devi determinare la direzione in uscita.

Regole

La direzione in arrivo verrà indicata come uno dei personaggi NESWe lo specchio verrà indicato come uno /o \. Puoi riceverli in qualsiasi ordine. È necessario utilizzare lettere maiuscole.

Puoi inserire input in qualsiasi formato conveniente, inclusa una stringa di due caratteri, una stringa che utilizza un separatore tra i caratteri, una coppia di caratteri in un elenco o persino una coppia di stringhe singleton. Se si utilizza una stringa con separatore, il separatore non può utilizzare nessuno dei caratteri NWSE\/.

L'output deve essere un carattere di una NESWstringa di caratteri singoli.

È possibile scrivere un programma o una funzione e utilizzare uno dei nostri metodi standard per ricevere input e fornire output.

È possibile utilizzare qualsiasi linguaggio di programmazione , ma si noti che queste scappatoie sono vietate per impostazione predefinita.

Questo è , quindi la risposta valida più breve - misurata in byte - vince.

Casi test

Ci sono solo 8 possibili input che devi gestire, quindi non ci sono scuse per non testare il tuo codice su tutti loro:

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

1
Nelle lingue in cui è necessario eseguire il escape delle barre rovesciate sull'input, è consentito supporre che l'input sarà "\\" dove appropriato?
JDL,

4
@JDL La stringa (o il carattere) effettiva dovrebbe contenere un singolo \. Se la tua risposta è un invio di una funzione che accetta una stringa, ovviamente avrai bisogno \\del codice sorgente per chiamarla correttamente, ma se stai leggendo il tuo input dallo standard input, per esempio, dovrebbe essere un singolo \. In altre parole, se si chiama la funzione di lunghezza stringa corrispondente della propria lingua sull'input, il risultato dovrebbe essere sempre lo stesso, indipendentemente dal fatto che l'input contenga /o \.
Martin Ender,

Bene, mi aspettavo che R avesse dei problemi quando un "\" senza caratteri di escape è stato inserito tramite stdin, ma readline()posso gestirlo.
JDL,

1
@JDL Probabilmente dovrai inserire la stringa con escape (duplicando) quel simbolo, ma la stringa risultante sarà "N \"
Luis Mendo,

Risposte:


24

Python, 40 38 byte

-2 byte grazie a @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

semplice ricerca di risposta in un elenco (stringa AKA) indicizzato dalla mod più piccola della somma degli ordinali che funziona.

I casi di test sono su ideone


Dangit, pensavo di essere super intelligente prendendo i valori ASCII, sommandoli, %8loro e facendo un indice. Poi vedo che hai pubblicato la stessa soluzione più di un'ora fa. Hah. Prendi un +1.
AdmBorkBork,

21

Python 2, 40 byte

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

Sp3000 ha salvato un byte ( .index.find).

Spiegazione

Vogliamo mappare le indicazioni in questo modo:

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

Possiamo assegnare i codici delle direzioni a 2 bit e visualizzare entrambi i lanci come XOR come il primo e il secondo bit:

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

La mappatura tra stringhe di bit e direzioni avviene usando la stringa k. Ora dobbiamo solo mappare i caratteri speculari '/'e '\\'i valori 1e 2. Da allora '/' < '\\', potremmo usare ingenuamente (m>'/')+1come formula. Ma aspetta! lessicografico,

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

e ci siamo 'NWES'ben assegnati a k! Quindi possiamo usare (m>k)+1invece.


12

CJam, 14 byte

(@MartinEnder ha portato la mia risposta Python )

l1b" NESSWNW"=

Come?

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

I test sono su aditsu


6

Javascript (ES6), 50 41 40 37 byte

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

Hai salvato altri 3 byte usando il confronto, grazie alla risposta di Lynn

uso

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


Uso intelligente dei confronti ASCII per ottenere le tue condizioni alla fine giocando a modo tuo ...
WallyWest

6

MATL , 19 17 byte

'NWSE'jy&mjy+Eq-)

Provalo online! Oppure verifica gli otto casi .

Spiegazione

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

Grazie a @Jakube e @Maltysen per -1 byte ciascuno

@J"NWES"xxJQh>E

Un programma che accetta input di due stringhe tra virgolette separate da nuova riga, prima la direzione e poi il mirror, e stampa il risultato.

Questa è una porta della risposta Python di @ Lynn .

Provalo online

Come funziona

@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

puoi salvare un altro byte sostituendolo <QEcon >E.
Maltysen,

4

05AB1E , 14 byte

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

Provalo online!


4

Gelatina , 14 13 12 byte

(una porta della mia risposta Python )
-1 byte grazie a @MartinEnder (aggiungi uno spazio alla fine della stringa e rimuovi la necessità di modulo 8)
-1 byte grazie a @LuisMendo (accetta un singolo argomento stringa anziché due)

OSị“NESSWNW 

Come?

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)

Provalo su TryItOnline


4

Java 7, 71 70 68 byte

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

Peccato che charAteindexOf occupa così tanti byte ..

Ungolfed e tutti i casi di test:

Provalo qui.

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

Produzione:

W E S N E W N S

3

Python, 63 61 59 byte

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

Abbastanza semplice. Può sicuramente giocare a golf di più. Decide se aggiungere 1 o -1 all'indice dell'input in'NESW' .

Questa è un'espressione lambda; per usarlo, aggiungilo come prefissof= .

Ideone esso!


3

Java 8, 62 58 56 byte

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

Programma di test non golfato

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 byte

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

Accetta input come due espliciti char, output a char.

Funziona come segue: se ordiniamo l'output, vogliamo S /in qualche modo uguagliare lo stesso di N \, W /uguagliare E \, ecc. O, almeno, produrre numeri che sono "abbastanza vicini" ma ancora distinti. Se osserviamo i valori ASCII, otteniamo una tabella come la seguente:

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

Eseguendo un bruto-forcer sulla colonna delle sommazioni (derivato dalla somma dei punti di codice ASCII degli input) si mostra che se prendiamo le somme modulo 8, otteniamo quanto segue 2 2 | 6 1 | 3 4 | 5 7. Ciò è evidenziato nella stringa "xNESSWNW", come Enell'indice 2, Nin 6e 1, e così via.

Quindi, abbiamo solo bisogno di sommare gli input (implicitamente il cast da chara int32lungo la strada), prenderlo %8e usarlo per indicizzarlo nella nostra stringa.

Casi 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

Lotto, 111 byte

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

Accetta ad es W/. Come parametro della riga di comando della stringa di due caratteri. Il \e /rendere il loop imbarazzante; avrebbe impiegato 124 byte.


Idk, conto 96 byte. Ti sei spogliato \r?
Conor O'Brien,

@ ConorO'Brien Scrivo i miei file batch usando Blocco note, quindi no.
Neil,

2

Ottava, 30 byte

Usava lo stesso ordine di argomenti di Jonathan Allan.

Accetta l'input come stringa di due caratteri 'W\'.

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

Provalo online .


Bello! Potresti voler eseguire il porting su MATL: 'NESSWNW 'is)(vedi tutti i casi di test ). iè input, sè sume )sta indicizzando, che è modulare. Ho aggiunto uno spazio nella stringa in modo che il modulo sia 8
Luis Mendo

Grazie :) Mi sento barare se lo aggiungo come risposta separata, dal momento che non l'ho scritto da solo. Posso aggiungerlo a questa risposta anche se non vuoi rispondere tu stesso :)
Stewie Griffin

Capisco, probabilmente farei lo stesso :-) Non voglio modificare la mia risposta, in quanto è un approccio totalmente diverso che non ho trovato. Non sono sicuro che aggiungerlo alla tua risposta abbia senso, tuttavia, poiché sarebbero due lingue diverse nella risposta
Luis Mendo,

Sarebbe la mia prima risposta MATL: PI vedo che è più lungo della tua risposta MATL, quindi non credo che lo aggiungerò ...
Stewie Griffin,

2

C, 44, 35, 34 byte

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

Richiede due caratteri come due variabili. Ci vogliono sia lettere minuscole che maiuscole. Usa molta manipolazione dei bit. Il frammento si a&a/2traduce in un valore che ha valori univoci per i due bit inferiori, &3taglia tutti i bit più alti. Questo è stato usato come indice nella stringa "NWES" per il \mirror. Fortunatamente, i due bit inferiori dei caratteri ASCII \e /sono rispettivamente 00 e 11, il che è perfetto per XOR con l'indice di cui sopra per ottenere la direzione corretta per il /mirror.


2
Bello! Hai perso un ovvio -1 byte, però: return"NWES"[...](ometti lo spazio).
Tim Čas,

Grazie Tim, non mi era mai venuto in mente che sarebbe stato valido C :)
G. Sliepen,

1

CJam , 17 byte

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

L'input è separato dallo spazio.

Provalo online! (Come una suite di test separata da avanzamento riga.)

Questa è la soluzione che ho trovato prima di pubblicare la sfida. Non breve come l'indicizzazione ciclica di Jonathan, ma ho pensato che questo approccio fosse piuttosto interessante (e romanzo).

Spiegazione

L'obiettivo è utilizzare la traslitterazione (ovvero utilizzando una mappatura carattere-carattere) per sostituire il carattere di input con il carattere di output. Per fare ciò, dobbiamo selezionare la mappa corretta in base al fatto che il mirror sia /o \. Mapperemo SWENdall'elenco a un altro che selezioneremo in modo condizionale. Se l'elenco di input è SWEN, le due mappe di output devono essere le seguenti:

in  SWEN
/   ENSW
\   WSNE

Si noti che questi sono in ordine e in ordine inverso (motivo per cui abbiamo scelto l' SWENordine apparentemente casuale come set di input). Potremmo generarli ordinando l'elenco di input e invertendo il risultato se l'input ha \, ma c'è un modo migliore:

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

Salvato 5 grazie a Martin Ender ♦

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

Accetta l'input come una stringa di due caratteri.


0

Mathematica, 98 byte

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

Funzione anonima. Accetta due stringhe come input e restituisce una stringa come output.


0

C, 81 byte

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

uso

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

Produzione:

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

Funziona solo su valori hardcoded poiché utilizza confronti di puntatori.
Sami Kuhmonen,

0

Pyth, 13 byte

@."EW¹0`Y"sCM    

Suite di test

Somma i punti del codice, l'indice modulare, la stringa compressa.


0

TI-Basic, 40 byte

Codifica hard degli input. Noioso, ma il modo più breve.

sub("NEWS",1+int(inString("E/W\N\S/N/S\E\W/",Ans)/4),1
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.