Escreva um programa ou função que extraia uma palavra de uma pesquisa de palavras usando suas coordenadas de início e fim.

A entrada

Seu programa ou função deve aceitar três parâmetros: a coordenada inicial , a coordenada final e uma pesquisa de palavras a partir da qual extrair a palavra.

• A coordenada inicial pode ser obtida em qualquer formato.

  • Será sempre um número inteiro

  • O canto inferior esquerdo da grade é (0, 0)

  • Você não receberá coordenadas que vão além dos limites da grade

  • Você não receberá coordenadas que não sejam verticais, horizontais ou perfeitamente diagonais uma com a outra, como (7, 0) e (0, 6).

• A coordenada final será obtida no mesmo formato que a coordenada inicial

• A pesquisa de palavras será uma string ou o equivalente mais próximo do seu idioma

  • Será uma grade de caracteres separados por um único espaço , com cada linha em uma nova linha . Pode ter qualquer altura ou largura - que pode ser diferente -, mas sempre será um retângulo . Por exemplo:

    A G O A T C A T
    E A T M E N O W
    W O R D S E A R
    A K L L K J H G
    N P L F G H F D
    A S P L K J H G
    O P I L F G H J
    T F A S E J K L
    

    J H P B L D J L T
    F J L N F N P W H
    W P R D T F J R Q
    J L L L L J H H W
    N P L F H H F D S
    J T P L L J H H K
    P P J L F H H J N
    L F J T F J L L O
    

A saída

Você deve produzir uma string ou o equivalente mais próximo do seu idioma. Como nenhuma pesquisa de palavras na vida real pede para encontrar uma única letra, você não pode produzir nada se as coordenadas forem as mesmas.

Exemplos e casos de teste

Primeira Grade Acima:
(0, 4) e (4, 0) -> "MAÇÃ"

(4, 0) e (0, 4) -> "ELPPA"

(1, 7) e (4, 7) -> "CABRA"

(0, 5) e (7, 5) -> "WORDSEAR"

(0, 6) e (5, 6) -> "EATMEN"

(0, 6) e (0, 7) -> "EA"

(7, 0) e (0, 7) -> "LHJGLRAA"

----------

Segunda Grade Acima:
(1, 0) e (8, 7) -> "FJLHJJWT"


(1, 4) e (4, 4) -> "LLLL"

(1, 4) e (1, 4) -> "L" ou ""

JavaScript (ES6) 108

(x,y,t,u,g)=>eval("for(g=g.split`\n`.reverse(),r=g[y][2*x];x-t|y-u;)r+=g[y+=u<y?-1:u>y][2*(x+=t<x?-1:t>x)]")

Menos golfe

(x,y,t,u,g)=>{
    g=g.split`\n`.reverse();
    for(r = g[y][2*x]; x-t | y-u; )
        r+=g[y += u<y ? -1 : u>y][2*( x += t<x ? -1 : t>x)];
    return r
}   

Python 3.5 usando Numpy, 251 bytes:

def r(t,y,z):import numpy;l=numpy.array([[*i.split()]for i in z.split('\n')]);A,B,C,D=t[0],y[0],t[1],y[1];p=[1,-1];a=p[A>B];b=p[C>D];n=range(A,B+a,a);m=range(C,D+b,b);w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])];return w

• Recebe entrada no seguinte formato:

  print(''.join(r((start1,start2),(end1,end2),'''grid''')))
  

• Saídas no formato de uma string (por exemplo APPLE), desde que a função seja chamada usando o formato acima. Caso contrário, uma lista contendo cada letra (por exemplo ['A','P','P','L','E']) é retornada.

Golf mais ao longo do tempo, onde e quando eu puder.

Experimente Online! (Ideone) (Aqui, a entrada é feita de forma que a grade seja cercada por aspas duplas ( "") e a entrada em uma linha, com \ns entre cada linha da grade. Em seguida, os pontos são fornecidos em uma forma simples de tupla, com o início na segunda linha e no final na terceira.)

Código ungolfed junto com a explicação

def r(t,y,z):
    import numpy
    l=numpy.array([[*i.split()]for i in z.split('\n')])
    A,B,C,D=t[0],y[0],t[1],y[1]
    p=[1,-1]
    a=p[A>B]
    b=p[C>D]
    n=range(A,B+a,a)
    m=range(C,D+b,b)
    w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])]
    return w

Para os fins desta explicação, suponha que este programa foi executado com as entradas ((0,4),(4,0))e a primeira grade da pergunta. Aqui, vou percorrer as 2 partes principais do código:

• l=numpy.array([[*i.split()]for i in z.split('\n')])

  Aqui lestá uma matriz numpy contendo cada linha da entrada em uma "lista" separada. Por exemplo, a primeira grade da pergunta, que é:

  A G O A T C A T
  E A T M E N O W
  W O R D S E A R
  A K L L K J H G
  N P L F G H F D
  A S P L K J H G
  O P I L F G H J
  T F A S E J K L
  

  retorna esta matriz numpy:

  [['A' 'G' 'O' 'A' 'T' 'C' 'A' 'T']
   ['E' 'A' 'T' 'M' 'E' 'N' 'O' 'W']
   ['W' 'O' 'R' 'D' 'S' 'E' 'A' 'R']
   ['A' 'K' 'L' 'L' 'K' 'J' 'H' 'G']
   ['N' 'P' 'L' 'F' 'G' 'H' 'F' 'D']
   ['A' 'S' 'P' 'L' 'K' 'J' 'H' 'G']
   ['O' 'P' 'I' 'L' 'F' 'G' 'H' 'J']
   ['T' 'F' 'A' 'S' 'E' 'J' 'K' 'L']]
  

• w=[l[:,i][::-1][p]for i,p in zip([[A]*len(m),n][A!=B],[[C]*len(n),m][C!=D])]

  Esta é a lista principal da função na qual todas as letras correspondentes a cada ponto na grade são encontradas. Aqui, icorresponde a cada número inteiro em n, que é um objeto de intervalo que contém todos os números do intervalo start1=>end1+1em incrementos de +1se start1<end1ou -1se o oposto é verdadeiro. No entanto, iapenas corresponde a isso, desde que start1não seja igual end1. Caso contrário, start1é retornado quantas vezes o comprimento de m, onde mé um objeto de intervalo que contém cada número inteiro no intervalo start2=>end2+1com as mesmas condições que ne pcorresponde a cada número inteiro em m. Dito isto, vamos percorrer este passo a passo:

  • l[:,i]basicamente retorna um vetor de linha para cada coluna i, na matriz l,. por exemplo, l[:,0]retornaria:

    ['A' 'E' 'W' 'A' 'N' 'A' 'O' 'T']
    

    l[:,1] retornaria:

    ['G' 'A' 'O' 'K' 'P' 'S' 'P' 'F']
    

    e assim por diante. Você pode ler mais sobre diferentes maneiras de indexar numpy, incluindo este método, aqui .

  • Depois disso, a função reverte cada matriz retornada, usando l[:,i][::-1], uma vez que cada matriz é indexada da esquerda para a direita, mas como o ponto 0,0na grade no canto inferior esquerdo da grade, a reversão de cada matriz retornaria os valores do índice como se estivessem sendo procurados da direita para a esquerda. Por exemplo, l[:,0][::-1]retornaria:

    ['T' 'O' 'A' 'N' 'A' 'W' 'E' 'A']
    

  • Depois disso, a função indexa através dessa matriz invertida o valor do índice correspondente a p, que é sua letra, e o adiciona à lista que está sendo criada. Por exemplo, l[:,0][::-1][4]que corresponde ao ponto (0,4), retornaria A.

  • Esse processo continua repetindo e adicionando novos valores à lista até que os objetos do intervalo sejam esgotados.

Depois de tudo isso, a saída, que é lista w, é finalmente retornada. Nesse caso, isso seria APPLEse chamado com print(''.join(r((0,4),(4,0),'''The Grid''')))ou ['A','P','P','L','E']se for chamado sem ''.join(). De qualquer forma, ele retorna a resposta correta e estamos prontos!