Um laser dispara um feixe reto em uma das quatro direções ortogonais, indicadas por <>^v. Determine se ele atingirá o alvo Oem uma grade retangular.

Cada um deles será exibido (True):

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

>O.
...

v....
O....

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

Eles sentirão falta (Falso):

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

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


.O.
...
.v.

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

Entrada: uma grade retangular de ., pelo menos, 2x2, com exatamente um alvo Oe um laser <>^v. As linhas podem ser uma lista de cadeias, uma matriz 2D ou uma lista aninhada de caracteres ou uma única cadeia separada por nova linha com uma nova linha à direita opcional.

Saída : um valor de verdade consistente, se o raio laser atingir o alvo, e um valor de falsidade consistente, se errar.

Considerarei os envios que não usam expressões regulares (ou correspondência de sequência interna baseada em padrões) como uma categoria separada. Se você colocar (no regex)o nome do idioma, sua resposta aparecerá separadamente no placar.

var QUESTION_ID=80196,OVERRIDE_USER=20260;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/80196/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Caracóis , 19 bytes

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

As especificações para este podem ser implementadas o mais literalmente possível, sem necessidade de pensar.

Retina, 56 52 42 38 31 30 bytes

Guardado 1 byte graças a @ MartinBüttner

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

Abusa das propriedades dos retângulos. Requer entrada para ter uma nova linha à direita.

Experimente online

Explicação

Isso funciona em três partes:

• Coincidindo >
• Coincidindo <
• Correspondência ^e visso ocorre porque a lógica para ^e vé realmente a mesma, apenas os caracteres.

Validando <

Isto é simples:

O.*<

Corresponde a um O, opcionalmente seguido por caracteres que não são de nova linha, depois um<

Validando >

É o mesmo da maneira anterior, exceto o contrário. Primeiro a >é correspondido, então oO

Validando ^ev

Foi difícil jogar golfe e a publicidade da entrada sempre era válida. Primeiro, combinamos se é vou um O:

[vO]

Se for um ^, o primeiro caractere encontrado deve ser a O. Portanto, isso corresponde ao primeiro caractere a ser correspondido. Em seguida, contamos a quantidade de .s que segue até a nova linha:

(.*\n)

Em seguida, isso pode ser dividido em duas partes, abordarei a primeira:

Então, primeiro, correspondemos até o seguinte O, usando:

[^O]*O

Opcionalmente, isso corresponde a todos os Ocaracteres não até que um Oseja encontrado, se for bem-sucedido, continuará ... se não, o seguinte acontece ...

Agora, ele tenta encontrar o ^uso:

[^^]*\^

^é um caractere especial no regex, portanto, ele precisa ser escapado. [^^]corresponde a todos os caracteres ^, exceto , isso funciona da mesma forma que acima, se for bem-sucedido, acontece o seguinte ...

Portanto, agora, uma das opções acima correspondeu com êxito, \1verifica e verifica se o grupo de captura anterior (.*\n), esse grupo de captura armazenou a quantidade de .s que havia após o antes vou o Oanterior; agora, \1apenas verifica se a quantidade de pontos no mesmo.

Java (sem regex), 413 412 246 242 212 211 209 198 bytes

Competir em desafios de golfe usando java tem menos sentido do que participar da corrida de Fórmula 1 em bicicleta, mas nem sempre estou pensando o que faz algum sentido.

Aqui está minha solução java extremamente longa Versão 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]);}

e ungolfed

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]);
}

Parece que todo o meu conceito estava errado, aqui está a minha solução mais curta

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;}

e versão não destruída

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;
    }

EDITAR Eu reescrevi o código para procurar 'O', agora ele contém um loop único e é muito mais curto, e também usei a sugestão @Frozn para substituir alguns caracteres por seus valores ascii.

Como resultado, outros 30 bytes mordem a poeira.

Outra sugestão do @Frozn, e estamos alguns bytes mais próximos da solução Python

Outra reescrita solta um loop e combina duas instruções if

MATL (sem regex), 26 25 24 22 bytes

'>v<^'XJymfX!tZpYswJm)

Experimente Online!

Versão modificada para todos os casos de teste

Explicação

        % 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

CJam (sem regex), 25

Versões anteriores estavam erradas, isso terá que ser feito por enquanto:

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

Experimente online

Explicação:

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

Tentei algumas fórmulas matemáticas para distinguir entre "boas" e "más" e, para cada tipo de fórmula, tentei inserir vários números. Acabei com o HbI%acima exposto.

cadeias "boas" para a grade original são "> O" e "O <" e fornecem o resultado 17
cadeias "boas" para a grade transposta são "vO" e "O ^" e dão o resultado 15 como
"ruins" seqüências de caracteres para ambas as grades são: ">", "<", "^", "v", "O", "", "O>", "Ov", "<O", "^ O" e fornecem os resultados 8, 6, 4, 10, 7, 0, 1, 3, 1, 3

Python 3 (sem regex), 184 bytes.

Viva para hackers de avaliação!

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'><'])

TSQL (sqlserver 2012) (sem regex), 358 bytes

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)

Teve que usar funky linechange na declaração para forçar a versão online a executá-la (atribuir valores às variáveis ​​de entrada não afeta o cálculo do comprimento)

Experimente online!

Pitão, 43 bytes

KxJ"^<v>"[email protected]}\Ohc_W>K1hf}@JKTCW!%K2.z@JK

Demonstração ao vivo.

JavaScript (ES6), 78 bytes

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

Regexp, é claro. Acabou sendo semelhante em princípio à resposta Ruby.

Ruby, 71 55 54 bytes

Solução Regex, o que significa que provavelmente será facilmente derrotado por Retina ou Perl.

Retorna um número de índice (verdade) se houver uma correspondência.

Agora, com um truque semelhante à resposta do @Downgoat Retina, correspondendo às vigas para baixo e para cima ao mesmo tempo.

->m{m=~/>\.*O|O\.*<|(?=[vO])(.{#{??+m=~/\n/}})+[O^]/m}

JavaScript (ES6) (sem regex), 126 bytes

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)

Onde \nrepresenta o caractere literal de nova linha.

Clojure (sem regex), 293 bytes

(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))))

Não parece ótimo. Solução simples, localizando o índice dos caracteres correspondentes e calculando se eles estão na mesma linha.

Você pode experimentá-lo aqui https://ideone.com/m4f2ra

Python (sem regex), 105 bytes

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]

retorna Verdadeiro ou Falso

Primeiro, retira '.' e '\ n' das extremidades, para que os caracteres de interesse, '0 <> v ^', sejam o primeiro e o último caracteres.

'>O<vO^'.find(t[0]+t[-1])//3- verifica se os caracteres são um arranjo potencialmente válido. Avalia como 0 para '> O' ou 'O <', para 1 para 'vO' ou 'O ^' e para -1 para qualquer outra coisa.

'\n'in t- verifica se os caracteres estão em linhas diferentes,
len(t)%(s.find('\n')+1)!=1- verifica se estão em colunas diferentes, e
1 - é o padrão

O notinverte o resultado selecionado da lista, portanto a returnexpressão é equivalente a:

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

Julia (sem regex), 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)

Função operando em uma matriz de caracteres, normalizando por rotação, removendo linhas e colunas contendo apenas pontos pela indexação de intervalo e, finalmente, verificando a localização de 'O' levando em consideração se o restante b é um vetor de coluna ou linha usando multiplicação de matrizes.

Experimente online

Python 2 (sem regex), 268 bytes

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

Os valores de Truthy e Falsy retornados pela função são 1 e 0, respectivamente.

Ainda não tive a chance de jogar golfe. Sinceramente, não tenho muita esperança deste ...

Todas as sugestões serão muito apreciadas!

C # (sem regex), 282 bytes

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

Funciona como a versão java, mas transpilada e reduzida

Expandido (explicação incluída):

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

C (ANSI) (sem regex), 237 bytes

#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;}

Expandido:

#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;
}

Acho que tomei uma abordagem decentemente diferente aqui em comparação com as implementações Java ou C #. Peguei coordenadas do 'O' e da flecha ((c, d) e (x, y)) e as comparei para ver se a flecha estava apontando na direção correta.

Retorna 0 se falso e 1 se verdadeiro

Grime v0.1 , 31 bytes

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

Não é uma solução muito interessante. Imprime 1para instâncias 0verdadeiras e falsas. Experimente online!

Explicação

Simplesmente procuramos no retângulo de entrada um padrão de tamanho mínimo (n × 1 ou 1 × n) que contenha o laser e o alvo na ordem correta. A n`bandeira faz com que o intérprete imprima o número de correspondências, das quais sempre haverá no máximo uma. O restante da linha consiste em quatro padrões separados por| -characters, o que significa um OR lógico: um retângulo é correspondido se corresponder a um dos padrões. Os padrões funcionam da seguinte maneira:

\>.*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 "^"