Попадет ли луч?

31

Лазер излучает прямой луч в одном из четырех ортогональных направлений, обозначенных значком <>^v. Определите, попадет ли он в цель Oпо прямоугольной сетке.

Каждый из них поразит (True):

.....
...O.
.....
...^.
.....

>O.
...

v....
O....

...........
...........
O.........<
...........

Это будет пропустить (Ложь):

......
......
.^..O.

......
.....>
O.....
......
......


.O.
...
.v.

.....<.
..O....

Вход: прямоугольная сетка .размером не менее 2х2, с ровно одной целью Oи одним лазером <>^v. Строки могут быть списком строк, двумерным массивом или вложенным списком символов, или одной строкой, разделенной новой строкой, с необязательным завершающим символом новой строки.

Вывод : постоянное истинное значение, если лазерный луч попадает в цель, и постоянное ложное значение, если оно отсутствует.

Я рассмотрю заявки, в которых не используются регулярные выражения (или встроенное сопоставление строк на основе шаблонов), в качестве отдельной категории. Если вы поставите (no regex)после названия языка, ваш ответ появится отдельно в списке лидеров.

Показать фрагмент кода

code-golf  ascii-art 
— XNOR
источник
8
— VisualMelon
6
Я надеялся, что вы включите зеркала с /и \ . Может быть, для другого вопроса ...
— Vsz
2
@Mego ... что делает эту задачу намного проще и позволяет применять совершенно разные подходы.
— Мартин Эндер
2
@ Мего, я не согласен; Согласно этой логике, вызов «Здравствуй, мир!» является дубликатом десятков других задач одновременно. В любом случае, спасибо, что уведомили меня о мощи, которую я теперь имею для того, чтобы закрывать / заново открывать кодовые задачи по гольфу, я не знал об этом.
— aditsu
5
@Mego Хотя этот вопрос является частным случаем другого, я не считаю, что это обман, потому что ответы используют совершенно разные подходы. По этому вопросу все они вычисляют путь, по которому идет луч. Порталы могут перемещать путь из любого места в любое место, которое, по-видимому, не позволяет использовать ярлыки, а рефлекторы сложны в обращении. Ответы здесь вместо этого в основном проверяют или совпадают с некоторым свойством входной строки. Конечно, вы можете скопировать ответ с трассировкой пути из другой задачи и удалить лишние биты, но этот метод излишний и дает излишне долгое решение.
— xnor

Ответы:

27

Улитки , 19 байт

\>|\<l|\^u|\vd).,\O

Спецификация для этого может быть реализована в буквальном смысле, насколько это возможно, без необходимости думать.

— feersum
источник
6
Можете ли вы объяснить, как это работает?
— Фонд Моники Иск
5
@QPaysTaxes До тех пор, пока feersum не придет к этому, надеюсь, это поможет: Snails - это язык сопоставления двухмерных паттернов. udlrустановите направление улитки вверх / вниз / влево / вправо. |работает так же, как и в регулярных регулярных выражениях, и )не требует соответствующих открытых скобок. Таким образом, код довольно точно переводится как «Найти один из них v<>^и установить направление соответствующим образом, а затем попытаться найти букву О в этом направлении».
— FryAmTheEggman
Да, что сказал Эггман. Единственное, что ,походит на *регулярное выражение.
— feersum
13

Retina, 56 52 42 38 31 30 байт

Сохранено 1 байт благодаря @ MartinBüttner

O.*<|>.*O|[vO](.*¶)[^O]*[O^]\1

Злоупотребляет свойствами прямоугольников. Требует ввода, чтобы иметь завершающий перевод строки.

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

объяснение

Это работает в трех частях:

  • согласование >
  • согласование <
  • Соответствие ^и vэто потому, что логика ^и vна самом деле одинаковы, только символы.

Пользователи <

Это просто:

O.*<

Это соответствует O, опционально сопровождаемый символами без перевода строки, затем<

Пользователи >

Это почти то же самое, что и предыдущий способ, но только наоборот. Сначала >сопоставляется, а затемO

Проверка ^иv

Это было трудно для гольфа, и реклама всегда была действительной. Сначала мы сопоставляем, является ли это vили O:

[vO]

Если это ^, первый встреченный символ должен быть O. Итак, это соответствует первому символу, чтобы соответствовать. Далее мы посчитаем количество .s, следующих за ним до новой строки:

(.*\n)

Далее это можно разбить на две части, я расскажу о первой:

Итак, сначала мы сопоставим до следующего O, используя:

[^O]*O

Это необязательно соответствует всем не Oсимволам, пока не Oвстретится, если это успешно, то это продолжается ... если нет, то происходит следующее ...

Теперь он пытается найти ^использование:

[^^]*\^

^это специальный символ в регулярном выражении, поэтому его необходимо экранировать. [^^]соответствует всем символам за исключением того ^, что это работает так же, как указано выше, если это успешно, то происходит следующее ...

Итак, теперь одно из вышеперечисленного успешно совпало, \1проверяет и видит, была ли группа захвата из предыдущей (.*\n), эта группа захвата хранила количество .s, которые были после vили Oпосле, поэтому теперь \1просто проверяет, есть ли количество точек в одно и тоже.

— Downgoat
источник
Вы можете сохранить байт, используя вместо этого \n(Retina может обрабатывать исходный код в ISO 8859-1.)
— Мартин Эндер,
@ MartinBüttner думал, что только \ n в замен, спасибо за совет!
— Downgoat
нет, это работает в любом месте исходного кода. После разбиения файла на строки первое, что делает Retina, - это заменяет везде перед выполнением дальнейшего анализа.
— Мартин Эндер
9

Java (без регулярных выражений), 413 412 246 242 212 211 209 198 байт

Соревноваться в соревнованиях по гольфу с использованием Java меньше смысла, чем принимать участие в гонках Формулы 1 на велосипеде, но я не всегда делаю мысли, которые имеют какой-то смысл.

Вот мое чрезвычайно длинное Java-решение Golfed версия

boolean l(char[][]w){int[]t={},l={};for(int y=0;y<w.length;y++)for(int x=0;x<w[0].length;x++){if(w[y][x]=='O')t=new int[]{x,y};if(w[y][x]=='<')l=new int[]{x,y,1};if(w[y][x]=='>')l=new int[]{x,y,2};if(w[y][x]=='v')l=new int[]{x,y,3};if(w[y][x]=='^')l=new int[]{x,y,4};};return(l[2]==1&&l[1]==t[1]&&l[0]>t[0])||(l[2]==2&&l[1]==t[1]&&l[0]<t[0])||(l[2]==3&&l[0]==t[0]&&l[1]<t[1])||(l[2]==4&&l[0]==t[0]&&l[1]>t[1]);}

и разгул

boolean l(char[][] w) {
    int[] t = {}, l = {};
    for (int y = 0; y < w.length; y++)
        for (int x = 0; x < w[0].length; x++) {
            if (w[y][x] == 'O')
                t = new int[] { x, y };
            if (w[y][x] == '<')
                l = new int[] { x, y, 1 };
            if (w[y][x] == '>')
                l = new int[] { x, y, 2 };
            if (w[y][x] == 'v')
                l = new int[] { x, y, 3 };
            if (w[y][x] == '^')
                l = new int[] { x, y, 4 };
        }
    ;
    return (l[2] == 1 && l[1] == t[1] && l[0] > t[0])
            || (l[2] == 2 && l[1] == t[1] && l[0] < t[0])
            || (l[2] == 3 && l[0] == t[0] && l[1] < t[1])
            || (l[2] == 4 && l[0] == t[0] && l[1] > t[1]);
}

Кажется, что вся моя концепция была неправильной, вот мое более короткое решение

boolean z(char[][]w){int x=0,y=0,i=0,a=w.length,b=w[0].length;for(;w[y][x]!=79;)if(++y==a){y=0;x++;}for(;i<(a<b?b:a);)if(i<b&w[y][i]==(i<x?62:60)|i<a&w[i][x]==(i++<y?'v':94))return 1<2;return 1>2;}

и негольфированная версия

oolean z(char[][] w) {
        int x = 0, y = 0, i = 0, a = w.length, b = w[0].length;
        for (; w[y][x] != 79;)
            if (++y == a) {
                y = 0;
                x++;
            }
        for (; i < (a < b ? b : a);)
            if (i < b & w[y][i] == (i < x ? 62 : 60) | i < a
                    & w[i][x] == (i++ < y ? 'v' : 94))
                return 1 < 2;
        return 1 > 2;
    }

РЕДАКТИРОВАТЬ Я переписал код для поиска 'O', теперь он содержит один цикл намного короче, и я также использовал предложение @Frozn для замены некоторых символов их значениями ascii.

В результате, еще 30 байтов кусает пыль.

Еще одно предложение от @Frozn, и мы на пару байтов ближе к решению Python

Другой переписать отбросить один цикл и объединить два оператора if

— user902383
источник
1
+1 Вы можете убрать пробел между returnи, (чтобы сохранить байт. Пробел не нужен, если возвращаемое значение находится в скобках (или в кавычках для строк). Исходный код из Java-кода игры в гольф.
— Кевин Круйссен
@KevinCruijssen не сильно экономит, но спасибо :)
— user902383
Каждый маленький (или я должен сказать, байт) помогает мне угадать. ;) Кроме того, я не думаю, что Java когда-либо выиграет соревнование по коду-гольфу. Мне все еще нравится решать задачи в Java-коде, особенно потому, что я сейчас работаю с Java на работе.
— Кевин Круйссен
Вы можете заменить символы их ASCII - значения: 'O' = 79, '>' = 62, '<' = 60, '^' = 94. Для «v» это 118, но это не сокращает код.
— Frozn
@ Фрозн, как сказал Кевин, в каждом байте.
— user902383
7

MATL (без регулярных выражений), 26 25 24 22 байта

'>v<^'XJymfX!tZpYswJm)

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

Модифицированная версия для всех тестовых случаев

объяснение

        % Implicitly grab input
'>v<^'  % String literal indicating the direction chars
XJ      % Store in the J clipboard
y       % Copy the input from the bottom of the stack
m       % Check to see which of the direction chars is in the input. The
        % result is a 1 x 4 logical array with a 1 for the found direction char
f       % Get the 1-based index into '>v<^' of this character
X!      % Rotate the input board 90 degrees N times where N is the index. This
        % Way we rotate the board so that, regardless of the direction char,
        % the direction char should always be BELOW the target in the same column
t       % Duplicate
Zp      % Determine if any elements are prime ('O' is the only prime)
Ys      % Compute the cumulative sum of each column
w       % Flip the top two stack elements
J       % Grab '>v<^' from clipboard J
m       % Create a logical matrix the size of the input where it is 1 where
        % the direction char is and 0 otherwise
)       % Use this to index into the output of the cumulative sum. If the 
        % direction char is below 'O' in a column, this will yield a 1 and 0 otherwise
        % Implicitly display the result
— Suever
источник
@ LuisMendo Теперь, чтобы выяснить, как избавиться отJ
— Suever
Я не знаю, MATL, так что это может быть глупый вопрос, но почему 0 премьер?
— Нил
3
@Neil Это письмо 'O', а не число 0. ASCII код для письма 'O'это79
— Луис Mendo
Тьфу, наверное, меня бы все равно обманули, если бы ты искал нечетные числа вместо этого.
— Нил
5

CJam (без регулярных выражений), 25

Более ранние версии были неправильными, это нужно сделать сейчас:

q~_z]{'.-HbI%}f%[HF].&~+,

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

Объяснение:

q~         read and evaluate the input (given as an array of strings)
_z         copy and transpose
]          put the original grid and transposed grid in an array
{…}f%      map the block to each grid (applying it to each string in each grid)
  '.-      remove all dots (obtaining a string of 0 to 2 chars)
  Hb       convert to base H=17, e.g. ">O" -> 62*17+79=1133
  I%       calculate modulo I=18
[HF]       make an array [17 15]
.&         set-intersect the first array (mapped grid) with 17 and 2nd one with 15
~+         dump and concatenate the results
,          get the array length

Я попробовал несколько математических формул для разграничения между «хорошими» и «плохими» строками, и для каждого типа формул я попытался вставить различные числа. Я закончил с HbI%вышеизложенным.

«хорошими» строками для исходной сетки являются «> O» и «O <», и они дают результат 17
«хорошими» строками для транспонированной сетки являются «vO» и «O ^», и они дают результат 15
«плохой» Строки для обеих сеток: «>», «<», «^», «v», «O», «», «O>», «Ov», «<O», «^ O», и они дают результаты 8, 6, 4, 10, 7, 0, 1, 3, 1, 3

— aditsu
источник
3

Python 3 (без регулярных выражений), 184 байта.

Ура для взлома!

def f(a,o=0,d={},q=''):
 for r in a:
  i=0
  for c in r:d[c]=o,i;i+=1;q=(c,q)[c in'O.']
  o+=1
 z,y=d['O'];e,j=d[q];return eval("z%se and y%sj"%(('><'[q<'v'],'=='),('==',q))[q in'><'])
— Морган Трепп
источник
3

TSQL (sqlserver 2012) (без регулярных выражений), 358 байт

DECLARE @ varchar(1000)=
'......'+ CHAR(13)+CHAR(10)+
'......'+ CHAR(13)+CHAR(10)+
'...0..'+ CHAR(13)+CHAR(10)+
'...^..'+ CHAR(13)+CHAR(10)
;

WITH C as(SELECT
number n,SUBSTRING(@,number,1)a,1+min(IIF(SUBSTRING(@,number,1)=char(13),number,99))over()m
FROM master..spt_values
WHERE'P'=type and
SUBSTRING(@,number,1)in('>','<','^','v','0',char(13)))SELECT
IIF(c.n%c.m=d.n%c.m and c.a+d.a in('0^','v0')or
c.n/c.m=d.n/c.m and c.a+d.a in('>0','0<'),1,0)FROM c,c d
WHERE c.n<d.n and char(13)not in(c.a,d.a)

Пришлось использовать funky linechange в объявлении, чтобы принудительно выполнить онлайн-версию (присвоение значений входным переменным в любом случае не влияет на вычисление длины)

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

— t-clausen.dk
источник
2

JavaScript (ES6), 78 байт

s=>s.match(`>.*O|O.*<|(?=v)([^]{${l=s.search`\n`+1}})+O|(?=O)([^]{${l}})+\\^`)

Регулярное выражение конечно. Оказалось, что в принципе похоже на ответ Ruby.

— Нил
источник
2

Рубин, 71 55 54 байта

Решение Regex, что означает, что его, вероятно, легко победят Retina или Perl.

Возвращает порядковый номер (правда), если есть совпадение.

Теперь с трюком, похожим на ответ @Downgoat Retina, совмещая лучи вниз и вверх одновременно.

->m{m=~/>\.*O|O\.*<|(?=[vO])(.{#{??+m=~/\n/}})+[O^]/m}
— Значение чернил
источник
2

JavaScript (ES6) (без регулярных выражений), 126 байт

s=>([n,o,l,r,u,d]=[..."\nO<>^"].map(c=>1+s.indexOf(c)),l>o&l-o<n&l%n>o%n||r&&r<o&o-r<n&r%n<o%n||u>o&u%n==o%n||d&&d<o&d%n==o%n)

Где \nпредставляет буквальный символ новой строки.

— Нил
источник
2

Clojure (без регулярных выражений), 293 байта

(defn z[f](let[v(sort(keep-indexed(fn[i v](if(some #{v}[\v\>\<\^\O])[(if(= v\O)\& v)i]))f))l(+(.indexOf f"\n")1)d((nth v 1)0)q((nth v 1)1)p((nth v 0)1)r(=(quot p l)(quot q l))i(> q p)](cond(= d\^)(and i(=(mod(- q p)l)0))(= d\v)(and(not i)(=(mod(- p q)l)0))(= d\>)(and(not i)r):else(and i r))))

Не чувствует себя прекрасно. Простое решение, поиск индекса соответствующих символов и вычисление, если они находятся на одной строке.

Вы можете попробовать это здесь https://ideone.com/m4f2ra

— cliffroot
источник
2

Python (без регулярных выражений), 105 байт

def f(s):t=s.strip('.\n');return not['\n'in t,len(t)%(s.find('\n')+1)!=1,1]['>O<vO^'.find(t[0]+t[-1])//3]

возвращает True или False

Сначала полоски "." и '\ n' с концов, чтобы интересующие символы, '0 <> v ^', были первым и последним символами.

'>O<vO^'.find(t[0]+t[-1])//3- проверяет, являются ли символы потенциально допустимым расположением. Значение 0 для «> O» или «O <», 1 для «vO» или «O ^» и «-1» для всего остального.

'\n'in t- проверяет, находятся ли символы в разных строках,
len(t)%(s.find('\n')+1)!=1- проверяет, находятся ли они в разных столбцах, и
1- используется по умолчанию

В notинвертирует результат выбирается из списка, так что returnвыражение эквивалентно:

t[0]+t[-1] in '>0<' and '\n' not in t or t[0]+t[-1] in 'vO^' and len(t)%(s.find('\n')+1)==1
— RootTwo
источник
2

Юлия (без регулярных выражений), 98

a->(c=rotr90(a,findlast("i1Q/",sum(a-46)));
    f(n)=find(any(c.!='.',n));b=c[f(2),f(1)];
    (b'*b)[1]==97)

Функция, работающая с массивом символов, нормализующаяся с помощью поворота, удаляющая строки и столбцы, содержащие только точки, путем индексации диапазона и, наконец, проверяющая местоположение «O», принимая во внимание, является ли остаток b вектором столбца или строки с использованием умножения матриц.

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

— mschauer
источник
1

Python 2 (без регулярных выражений), 268 байт

import numpy
def q(i):
 s=numpy.asmatrix(i)
 for n in s:
  n=n.tolist()[0]
  try:
   a=n.index("0")
   if n.index(">")<a or n.index("<")>a:return 1
  except:0
 for n in range(len(i)):
  c=[x[0] for x in s[:,n].tolist()]
  try:
   a=c.index("0")
   if c.index("v")<a or c.index("^")>a:return 1
  except:0
 return 0

Значения Truthy и Falsy, возвращаемые функцией, равны 1 и 0 соответственно.

У меня еще не было возможности поиграть в гольф. Честно говоря, я не слишком надеюсь на это ...

Любые предложения будут ценны!

— Даниил
источник
1

C # (без регулярных выражений), 282 байта

bool F(char[,]b){int k=0,l=1,m=1,n=0,o=0;for(int x=0;x<b.GetLength(0);x++)for(int y=0;y<b.GetLength(1);y++){char i=b[x,y];if(i=='O'){k=x;l=y;}if(new[]{'<','>','^','v'}.Contains(i)){m=x;n=y;o=i;}}return(o==60&&k==m&&l<n)||(o==62&&k==m&&l>n)||(o==94&&l==n&&k<m)||(o==118&&l==n&&k>m);}

Работает как версия Java, но переносится и уменьшается

Расширенный (Объяснение включено):

bool F(char[,] b)
{
    // declare variables for goal x, goal y, laser x, laser y, and laser direction respectively (laser direction is char code for directions)
    int k = 0, l = 0, m = 0, n = 0, o = 0;
    // go through each cell
    for (int x = 0; x < b.GetLength(0); x++)
    {
        for (int y = 0; y < b.GetLength(1); y++)
        {
            // get cell contents
            char i = b[x, y];
            // set goal position if goal
            if (i == 'O')
            {
                k = x;
                l = y;
            }
            // set laser position and direction if laser
            if (new[]{ '<', '>', '^', 'v' }.Contains(i))
            {
                m = x;
                n = y;
                o = i;
            }
        }
    }
    // check everything is on the same line and in right direction
    return (o == 60 && k == m && l < n) ||
           (o == 62 && k == m && l > n) ||
           (o == 94 && l == n && k < m) ||
           (o == 118 && l == n && k > m);
}
— RedLaser
источник
0

C (ANSI) (без регулярных выражений), 237 байт

#define l b[1][i]
main(i,b,c,d,x,y,z,p)char **b;{for(y=z=i=0,x=1;z<2&&(l==10?x=0,++y:1);i++,x++)if(l>46){if(l!=79)p=l;if(!z++)c=x,d=y;}i--;x--;z=(c==x)*((p=='v')*(l==79)+(p==94)*(l==p))+(d==y)*((p==60)*(l==p)+(p==62)*(l==79));return z;}

Expanded:

#define l b[1][i]
main(i,b,c,d,x,y,z,p)char **b;{
    for(y=z=i=0,x=1;z<2&&(l==10?x=0,++y:1);i++,x++)
        if(l>46){if(l!=79)p=l;if(!z++)c=x,d=y;}
    i--;x--;
    z=(c==x)*((p=='v')*(l==79)+(p==94)*(l==p))+(d==y)*((p==60)*(l==p)+(p==62)*(l==79));
    printf("%i\n",z);
    return z;
}

Я думаю, что я использовал совершенно другой подход по сравнению с реализациями Java или C #. Я получил координаты «O» и стрелки ((c, d) и (x, y)), а затем сравнил их, чтобы увидеть, указала ли стрелка в правильном направлении.

Возвращает 0, если ложь, и 1, если правда

— dj0wns
источник
0

Grime v0.1 , 31 байт

n`\>.*a|a.*\<|\v/./*/a|a/./*/\^

Не очень интересное решение. Отпечатки 1для правдивых и ложных экземпляров 0. Попробуйте онлайн!

объяснение

Мы просто ищем во входном прямоугольнике шаблон минимального размера (n × 1 или 1 × n), который содержит лазер и цель в правильном порядке. n`Флаг делает интерпретатор печать количества матчей, из которых всегда будет в основном один. Остальная часть строки состоит из четырех шаблонов, разделенных |символами -ch, что означает логическое ИЛИ: прямоугольник сопоставляется, если он соответствует одному из шаблонов. Шаблоны работают следующим образом:

\>.*a    Literal ">", horizontal row of any chars, one alphabetic char
a.*\<    One alphabetic char, horizontal row of any chars, literal "<"
\v/./*/a Literal "v", on top of vertical column of any chars, on top of one alphabetic char
a/./*/\^ One alphabetic char, on top of vertical column of any chars, on top of literal "^"
— Zgarb
источник
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.