Espelho, Espelho, no Código


26

As linguagens de programação bidimensionais geralmente têm comandos de espelho como /e \para redirecionar o ponteiro de instruções na grade:

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

Neste desafio, você recebe uma direção de entrada e um espelho e precisa determinar a direção de saída.

Regras

A direção de entrada será dada como um dos caracteres NESWe o espelho será dado como /ou \. Você pode recebê-los em qualquer ordem. Você deve usar letras maiúsculas.

Você pode inserir dados em qualquer formato conveniente, incluindo uma sequência de dois caracteres, uma sequência usando algum separador entre os caracteres, um par de caracteres em uma lista ou até mesmo um par de sequências singleton. Se você usar uma seqüência de caracteres com separador, o separador não poderá usar nenhum dos caracteres NWSE\/.

A saída deve ser um caractere NESWou uma cadeia de caracteres únicos.

Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e saída.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é , então a resposta mais curta e válida - medida em bytes - vence.

Casos de teste

Existem apenas 8 entradas possíveis que você precisa manipular, portanto, não há desculpa para não testar seu código em todas elas:

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

1
Nos idiomas em que as barras invertidas devem ser escapadas na entrada, podemos assumir que a entrada será "\\" quando apropriado?
JDL 02/09

4
@JDL A string (ou caractere) real deve conter uma única \. Se sua resposta for um envio de função que usa uma string, é claro que você precisará \\no código-fonte para chamá-lo corretamente, mas se estiver lendo sua entrada da entrada padrão, por exemplo, deve ser uma única \. Em outras palavras, se você chamar a respectiva função de comprimento de seqüência de caracteres do idioma na entrada, o resultado sempre será o mesmo, independentemente de a entrada conter /ou \.
Martin Ender

Tudo bem, eu esperava que o R tivesse problemas quando um "\" sem escape foi inserido via stdin, mas readline()posso lidar com isso.
JDL 02/09

1
@JDL Você provavelmente precisará digitar a seqüência de escape (duplicação) que símbolo, mas a resultante seqüência será "N \"
Luis Mendo

Respostas:


24

Python, 40 38 bytes

-2 bytes graças a @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

pesquisa simples de resposta em uma lista (string AKA) indexada pelo menor mod da soma dos ordinais que funciona.

Os casos de teste são em ideone


Porra, eu pensei que estava sendo super inteligente pegando os valores ASCII, somando- %8os e fazendo um índice. Então vejo que você postou a mesma solução há mais de uma hora. Hah. Tenha um +1.
AdmBorkBork 02/09

21

Python 2, 40 bytes

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

O Sp3000 salvou um byte ( .index.find).

Explicação

Queremos mapear as direções da seguinte forma:

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

Podemos atribuir as direções códigos de 2 bits e visualizar os dois movimentos como XOR no primeiro e no segundo bits:

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

O mapeamento entre cadeias de bits e direções acontece usando a cadeia k. Agora só precisamos mapear caracteres de espelho '/'e '\\'os valores 1e 2. Desde então '/' < '\\', poderíamos ingenuamente usar (m>'/')+1como uma fórmula. Mas espere! Lexicograficamente,

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

e nós 'NWES'atribuímos muito bem a k! Então, podemos usar em seu (m>k)+1lugar.


12

CJam, 14 bytes

(@MartinEnder portou minha resposta em Python )

l1b" NESSWNW"=

Quão?

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

Os testes estão no aditsu


6

Javascript (ES6), 50 41 40 37 bytes

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

Economizou mais 3 bytes usando a comparação, graças à resposta de 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 inteligente de comparações ASCII para obter a sua condição no final do seu jeito ...
WallyWest

6

MATL , 19 17 bytes

'NWSE'jy&mjy+Eq-)

Experimente online! Ou verifique os oito casos .

Explicação

'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

Pitão, 17 16 15 bytes

Graças a @Jakube e @Maltysen por -1 byte cada

@J"NWES"xxJQh>E

Um programa que recebe entrada de duas seqüências de caracteres entre aspas separadas por nova linha, primeiro a direção e depois o espelho e imprime o resultado.

Esta é uma porta da resposta Python do @ Lynn .

Experimente online

Como funciona

@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

você pode salvar outro byte, substituindo <QEpor >E.
Maltysen 2/09/16

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               

Experimente online!


4

Geléia , 14 13 12 bytes

(uma porta da minha resposta Python )
-1 byte graças a @MartinEnder (adicione um espaço no final da string e remova a necessidade do módulo 8)
-1 byte graças a @LuisMendo (use um argumento de string única em vez de dois)

OSị“NESSWNW 

Quão?

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)

Teste no TryItOnline


4

Java 7, 71 70 68 bytes

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

Pena que charAte indexOfocupa tantos bytes ..

Casos não testados e todos os testes:

Experimente aqui.

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

Saída:

W E S N E W N S

3

Python, 63 61 59 bytes

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

Bem simples. Definitivamente pode ser jogado mais. Decide se deve adicionar 1 ou -1 ao índice da entrada em 'NESW'.

Esta é uma expressão lambda; para usá-lo, prefixe-o com f=.

Ideone it!


3

Java 8, 62 58 56 bytes

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

Programa de teste ungolfed

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 bytes

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

Recebe a entrada como dois chars explícitos , produz a char.

Isso funciona da seguinte maneira: se classificarmos a saída, queremos, S /de alguma forma, igual a N \, W /igual a E \etc. etc. Ou, pelo menos, produzir números que sejam "próximos o suficiente" e ainda assim distintos. Se olharmos para os valores ASCII, obtemos uma tabela como a abaixo:

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

A execução rápida de um forçador bruto na coluna de somas (derivada da soma dos pontos de código ASCII das entradas) mostra que, se usarmos o módulo de somas 8, obtemos o seguinte 2 2 | 6 1 | 3 4 | 5 7. Isso é evidenciado na string "xNESSWNW", como Eestá no índice 2, Nestá em 6e 1, e assim por diante.

Então, só precisamos somar as entradas (convertendo implicitamente de charao int32longo do caminho), pegar isso %8e usá-lo para indexar em nossa string.

Casos de teste

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

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

Aceita, por exemplo, W/como um parâmetro de linha de comando de cadeia de dois caracteres. O \e/ torna o loop estranho; levaria 124 bytes.


Idk, conto 96 bytes. Você tirou \risso?
Conor O'Brien

@ ConorO'Brien Eu escrevo meus arquivos em lote usando o Bloco de Notas, então não.
Neil

2

Oitava, 30 bytes

Usou a mesma ordem de argumentos que Jonathan Allan.

Toma a entrada como uma sequência de dois caracteres 'W\'.

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

Experimente online .


Agradável! Você pode querer portar para MATL: 'NESSWNW 'is)(veja todos os casos de teste ). ié input, sé sume )está indexando, que é modular. I adicionado um espaço na cadeia de modo a que o módulo é de 8
Luis Mendo

Obrigado :) Eu acho que é trapaça se eu adicionar isso como uma resposta separada, já que eu não a escrevi. I pode adicioná-lo a esta resposta, embora se você não quer responder-lo sozinho :)
Stewie Griffin

Entendo, provavelmente faria o mesmo :-) Não quero modificar minha resposta, pois é uma abordagem totalmente diferente que não propus. Porém, não tenho certeza de que adicioná-lo à sua resposta faz sentido, pois seriam dois idiomas diferentes na resposta.
Luis Mendo

Seria minha primeira resposta MATL embora: PI ver que é mais do que a sua resposta MATL, então eu não acho que eu vou adicioná-lo ...
Stewie Griffin

2

C, 44, 35, 34 bytes

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

Requer dois caracteres como duas variáveis. É preciso tanto maiúsculas e minúsculas. Ele usa muita manipulação de bits. O fragmento a&a/2resulta em um valor que possui valores exclusivos para os dois bits inferiores, &3corta todos os bits superiores. Isso é usado como um índice para a sequência "NWES" do \espelho. Felizmente, os dois bits inferiores dos caracteres ASCII \e /são 00 e 11 respectivamente, o que é perfeito para o XOR com o índice mencionado acima para obter a direção correta para o /espelho.


2
Agradável! Você perdeu um óbvio -1 byte, no entanto: return"NWES"[...](omita o espaço).
Tim Čas 4/09/16

Graças Tim, não tinha ocorreu-me que isso seria C válido :)
G. Sliepen

1

CJam , 17 bytes

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

A entrada é separada por espaço.

Experimente online!(Como um conjunto de testes separado por avanço de linha.)

Essa é a solução que encontrei antes de postar o desafio. Não é tão curto quanto a indexação cíclica de Jonathan, mas achei que essa abordagem é bastante interessante (e inovadora).

Explicação

O objetivo é usar a transliteração (isto é, usando um mapeamento de caractere a caractere) para substituir o caractere de entrada pelo caractere de saída. Para fazer isso, precisamos selecionar o mapa correto com base em se o espelho é /ou \. Mapearemos da SWENlista para outra que selecionaremos condicionalmente. Se a lista de entrada for SWEN, os dois mapas de saída precisam ser os seguintes:

in  SWEN
/   ENSW
\   WSNE

Observe que eles estão na ordem classificada e na ordem inversa (e é por isso que escolhemos a SWENordem aparentemente aleatória como o conjunto de entrada). Poderíamos gerá-los classificando a lista de entradas e revertendo o resultado, se a entrada tiver \, mas existe uma maneira melhor:

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

Guardado 5 graças a Martin Ender ♦

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

Recebe a entrada como uma sequência de dois caracteres.


0

Mathematica, 98 bytes

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

Função anônima. Pega duas seqüências como entrada e retorna uma sequência como saída.


0

C, 81 bytes

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

Saída:

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

Funciona apenas em valores codificados, pois usa comparações de ponteiros.
Sami Kuhmonen 4/09/16


0

TI-Basic, 40 bytes

Codifica as entradas. Chato, mas o caminho mais curto.

sub("NEWS",1+int(inString("E/W\N\S/N/S\E\W/",Ans)/4),1
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.