Зеркало, Зеркало, в Коде

26

Двумерные языки программирования часто имеют зеркальные команды, такие как /и \для перенаправления указателя команд на сетке:

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

В этом задании вы получаете входящее направление и зеркало, и вам необходимо определить исходящее направление.

правила

Входящее направление будет дано в качестве одного из персонажей NESWи зеркало будет дано либо как /или \. Вы можете получить их в любом порядке. Вы должны использовать заглавные буквы.

Вы можете вводить данные в любом удобном формате, включая двухсимвольную строку, строку с использованием некоторого разделителя между символами, пару символов в списке или даже пару одиночных строк. Если вы используете строку с разделителем, разделитель не может использовать ни один из символов NWSE\/.

Вывод должен быть символом NESWили односимвольной строкой.

Вы можете написать программу или функцию и использовать любой из наших стандартных методов получения ввода и предоставления вывода.

Вы можете использовать любой язык программирования , но учтите, что эти лазейки по умолчанию запрещены.

Это код-гольф , поэтому самый короткий действительный ответ - измеренный в байтах - выигрывает.

Тестовые случаи

Есть только 8 возможных входов, которые вам нужно обработать, поэтому нет оправдания тому, чтобы не проверять ваш код на всех из них:

N /   -->   W
N \   -->   E
E /   -->   S
E \   -->   N
S /   -->   E
S \   -->   W
W /   -->   N
W \   -->   S
code-golf string code-golf natural-language code-golf internet stack-exchange-api code-golf code-golf conversion code-golf string code-golf math arithmetic code-golf string whitespace code-golf graphical-output internet code-golf string code-golf string random permutations code-golf string code-golf string Мартин Эндер
источник
1
На языках, где обратная косая черта должна быть экранирована при вводе, мы можем допустить, что ввод будет "\\", где это уместно?
JDL
4
@JDL Фактическая строка (или символ) должна содержать один \. Если ваш ответ представляет собой отправку функции, которая принимает строку, то, конечно, вам потребуется \\исходный код для ее правильного вызова, но если вы читаете свой ввод, например, из стандартного ввода, то он должен быть единичным \. Другими словами, если вы вызываете соответствующую функцию длины строки вашего языка на входе, результат всегда должен быть одинаковым, независимо от того, содержит ли вход /или \.
Мартин Эндер
Хорошо, я ожидал, что у R возникнут проблемы, когда через stdin будет введен неэкранированный символ "\", но он readline()может справиться с этим.
JDL
1
@JDL Вам, вероятно, нужно ввести строку, экранирующую (дублирующую) этот символ, но полученная строка будет «N \»
Луис Мендо,

Ответы:

24

Python, 40 38 байт

-2 байта благодаря @MitchSchwartz (ord(d)+ord(m))%8->ord(d)+ord(m)&7

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

простой поиск ответа в списке (строка АКА), проиндексированный наименьшим модом из суммы ординалов, которые работают.

Тестовые случаи на ideone

Джонатан Аллан
источник
Дангит, я думал, что я был очень умен, принимая значения ASCII, суммируя их, %8их и делая индекс. Тогда я вижу, что вы отправили то же самое решение более часа назад. Хах. Есть +1.
AdmBorkBork
21

Python 2, 40 байт

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

Sp3000 сохранил один байт ( .index→ .find).

объяснение

Мы хотим отобразить направления следующим образом:

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

Мы можем назначить направлениям 2-битные коды и рассматривать оба броска как XOR, используя первый и второй биты:

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

Отображение между битовыми строками и направлениями происходит с использованием строки k. Теперь нам просто нужно отобразить зеркальные символы '/'и '\\'значения 1и 2. Так как '/' < '\\'мы могли наивно использовать (m>'/')+1в качестве формулы. Но ждать! Лексикографически,

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

и мы 'NWES'приятно назначены k! Таким образом, мы можем использовать (m>k)+1вместо этого.

Линн
источник
12

CJam, 14 байтов

(@MartinEnder перенес мой ответ на Python )

l1b" NESSWNW"=

Как?

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

Тесты по адитсу

Джонатан Аллан
источник
6

Javascript (ES6), 50 41 40 37 байт

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

Благодаря ответу Линн сэкономил еще 3 байта с помощью сравнения

использование

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
источник
Умное использование сравнений ASCII, чтобы получить ваше состояние в конце, играя в вашу сторону ...
WallyWest
6

MATL , 19 17 байт

'NWSE'jy&mjy+Eq-)

Попробуйте онлайн! Или проверьте восемь случаев .

объяснение

'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 байтов

Спасибо @Jakube и @Maltysen за -1 байт каждый

@J"NWES"xxJQh>E

Программа, которая принимает ввод двух строк в кавычках, разделенных новой строкой, сначала направление, а затем зеркало, и печатает результат.

Это порт ответа @ Lynn's Python .

Попробуйте онлайн

Как это работает

@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
источник
Вы можете сохранить другой байт, заменив <QEна >E.
Maltysen
4

Желе , 14 13 12 байт

(порт моего ответа на Python )
-1 байт благодаря @MartinEnder (добавьте пробел в конец строки и удалите необходимость по модулю 8)
-1 байт благодаря @LuisMendo (принимайте один строковый аргумент вместо двух)

OSị“NESSWNW

Как?

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)

Проверьте это на TryItOnline

Джонатан Аллан
источник
4

Java 7, 71 70 68 байт

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

Жаль charAtи indexOfзанимает столько байтов ..

Ungolfed & все тестовые случаи:

Попробуй это здесь.

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

Выход:

W E S N E W N S
Кевин Круйссен
источник
3

Python, 63 61 59 байт

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

Довольно просто Определенно можно играть в гольф больше. Решает, добавлять ли 1 или -1 к индексу ввода в 'NESW'.

Это лямбда-выражение; чтобы использовать его, добавьте к нему префикс f=.

Идео это!

медь
источник
3

Ява 8, 62 58 56 байт

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

Тестовая программа 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 байта

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

Принимает ввод как два явных char s, выводит a char.

Это работает следующим образом: если мы сортируем выходные данные, мы хотим S /как-то равняться так же, как N \, W /равному E \и т. Д. Или, по крайней мере, производить числа, которые «достаточно близки», но все же различны. Если мы посмотрим на значения ASCII, мы получим таблицу, подобную приведенной ниже:

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

Выполнение быстрого перебора в столбце суммирования (полученного путем суммирования кодовых точек ASCII входных данных) показывает, что если мы возьмем суммы по модулю 8, мы получим следующее 2 2 | 6 1 | 3 4 | 5 7. Это подтверждается в строке "xNESSWNW", как Eв индексе 2, Nв 6и1 , и так далее.

Итак, нам просто нужно сложить входные данные (неявно приведение charкint32 к пути), взять их %8и использовать для индексации в нашей строке.

Тестовые случаи

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
источник
2

Пакет, 111 байт

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

Принимает, например, W/как параметр командной строки из двух символов строки. То \и /делают зацикливание неловко; это заняло бы 124 байта.

Нил
источник
ИДК, я считаю 96 байт. Вы сняли \rс него?
Конор О'Брайен,
@ ConorO'Brien Я пишу свои командные файлы с помощью блокнота, так что нет.
Нил
2

Октава, 30 байт

Использовал тот же порядок аргументов, что и у Джонатана Аллана.

Принимает ввод в виде двухсимвольной строки 'W\'.

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

Попробуйте онлайн .

Стьюи Гриффин
источник
Ницца! Вы можете портировать на MATL: 'NESSWNW 'is)(см. Все контрольные примеры ). iесть input, sесть sumи )индексация, которая является модульной. Я добавил пробел в строку, чтобы по модулю было 8
Луис Мендо
Спасибо :) Я чувствую, что это обманывает, если я добавлю это как отдельный ответ, так как я сам не написал это. Я могу добавить это к этому ответу, хотя, если вы не хотите отвечать на него самостоятельно :)
Stewie Griffin
Я понимаю, что, вероятно, сделал бы то же самое :-) Я не хочу изменять свой ответ, так как это совершенно другой подход, который я не придумал. Не уверен, что добавление его в ваш ответ имеет смысл, поскольку в ответе будут два разных языка
Луис Мендо
Впрочем, это был бы мой первый ответ в MATL: я вижу, что он длиннее вашего ответа в MATL, поэтому я не думаю, что добавлю его ...
Стьюи Гриффин,
2

C, 44, 35, 34 байта

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

Требуется два символа как две переменные. Требуется как нижний, так и верхний регистр. Это использует много битовых манипуляций. Фрагмент a&a/2приводит к значению, которое имеет уникальные значения для младших двух битов, &3обрезает все старшие биты. Это используется как индекс в строке "NWES" для \зеркала. К счастью, младшие два бита символов ASCII \и /00 и 11 соответственно, что идеально подходит для XOR с указанным выше индексом, чтобы получить правильное направление для /зеркала.

Г. Слипен
источник
2
Ницца! Вы пропустили очевидный -1 байт, хотя: return"NWES"[...](пропустите пробел).
Тим Час
Спасибо Тим, мне не пришло в голову, что это будет действительно C :)
Г. Слипен
1

CJam , 17 байт

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

Ввод разделен пробелом.

Попробуйте онлайн!(Как набор тестов с разделением строк).

Это решение, которое я нашел, прежде чем отправлять вызов. Не такой короткий, как циклическое индексирование Джонатана, но я подумал, что этот подход довольно интересный (и новый).

объяснение

Цель состоит в том, чтобы использовать транслитерацию (то есть, используя сопоставление символов), чтобы заменить входной символ выходным символом. Для этого нам нужно выбрать правильную карту в зависимости от того, является ли зеркало /или нет \. Мы отобразим из SWENсписка другой, который мы выберем условно. Если входной список есть SWEN, две выходные карты должны быть следующими:

in  SWEN
/   ENSW
\   WSNE

Обратите внимание, что они отсортированы в обратном порядке (именно поэтому мы выбрали, казалось бы, случайный SWENпорядок в качестве входного набора). Мы могли бы сгенерировать их, отсортировав входной список и изменив результат, если он есть \, но есть лучший способ:

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

СЭД 48 (42 + 1 за -r) 43

Сохранено 5 благодаря Мартину Эндеру ♦ 

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

Принимает ввод в виде двухсимвольной строки.

Райли
источник
0

Mathematica, 98 байт

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

Анонимная функция. Принимает две строки в качестве входных данных и возвращает строку в качестве выходных.

LegionMammal978
источник
0

C, 81 байт

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

использование

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

Выход:

N/      : W  
N\      : E  
E/      : S  
E\      : N  
S/      : E  
S\      : W  
W/      : N  
W\      : S
Джакомо Гарабелло
источник
Работает только для жестко закодированных значений, поскольку использует сравнения указателей.
Сами Кухмонен
0

TI-Basic, 40 байтов

Жесткие коды входов. Скучно, но самый короткий путь.

sub("NEWS",1+int(inString("E/W\N\S/N/S\E\W/",Ans)/4),1
Timtech
источник