Escriba un programa o función que extraiga una palabra de una búsqueda de palabras utilizando sus coordenadas de inicio y fin.

La entrada

Su programa o función debe aceptar tres parámetros: la coordenada inicial , la coordenada final y una búsqueda de palabras de la cual extraer la palabra.

• La coordenada de inicio se puede tomar en cualquier formato.

  • Siempre será un número entero

  • La parte inferior izquierda de la cuadrícula es (0, 0)

  • No se le proporcionarán coordenadas que salgan de los límites de la cuadrícula.

  • No se le proporcionarán coordenadas que no sean verticales, horizontales o perfectamente diagonales entre sí, como (7, 0) y (0, 6).

• La coordenada final se tomará en el mismo formato que la coordenada inicial

• La búsqueda de palabras será una cadena , o el equivalente más cercano de su idioma

  • Será una cuadrícula de caracteres separados por un solo espacio , con cada fila en una nueva línea . Puede tener cualquier altura o anchura, que puede ser diferente, pero siempre será un rectángulo . Por ejemplo:

    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
    

La salida

Debe generar una cadena o el equivalente más cercano de su idioma. Como ninguna búsqueda de palabras en la vida real pide encontrar una sola letra, es posible que no muestre nada si las coordenadas son las mismas.

Ejemplos y casos de prueba

Primera cuadrícula arriba:
(0, 4) y (4, 0) -> "MANZANA"

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

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

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

(0, 6) y (5, 6) -> "COMER"

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

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

----------

Segunda cuadrícula arriba:
(1, 0) y (8, 7) -> "FJLHJJWT"


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

(1, 4) y (1, 4) -> "L" o ""

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 golf

(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

• Toma entrada en el siguiente formato:

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

• Salidas en el formato de una cadena (p APPLE. Ej. ) Siempre que se llame a la función utilizando el formato anterior. De lo contrario, ['A','P','P','L','E']se devuelve una lista que contiene cada letra (por ejemplo ).

Jugaré más golf con el tiempo donde y cuando pueda.

¡Pruébelo en línea! (Ideone) (Aquí, la entrada se toma de tal manera que la cuadrícula se rodea con comillas dobles ( "") y la entrada en una línea, con \ns entre cada línea de la cuadrícula. Luego, los puntos se proporcionan en forma de tupla simple, con el inicio en la segunda línea y el final en la tercera).

Código no reflejado junto con la explicación

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

A los fines de esta explicación, suponga que este programa se ejecutó con las entradas ((0,4),(4,0))y la primera cuadrícula de la pregunta. Aquí, revisaré las 2 partes principales del código:

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

  Aquí, lhay una matriz numpy que contiene cada línea de la entrada en una "lista" separada. Por ejemplo, la primera cuadrícula de la pregunta, que es:

  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
  

  devuelve 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 es la lista principal de la función en la que se encuentran todas las letras correspondientes a cada punto de la cuadrícula. Aquí, icorresponde a cada número entero en n, que es un objeto de rango que contiene cada número en el rango start1=>end1+1en incrementos de +1si start1<end1o -1si lo contrario es cierto. Sin embargo, isolo corresponde a esto siempre que start1no sea igual end1. De start1lo contrario, se devuelve tantas veces como la longitud de m, donde mes un objeto de rango que contiene cada número entero en el rango start2=>end2+1con las mismas condiciones que n, y pcorresponde a cada número entero en m. Dicho esto, pasemos ahora por este paso a paso:

  • l[:,i]básicamente devuelve un vector fila para cada columna, ien la matriz, l. por ejemplo, l[:,0]devolvería:

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

    l[:,1] volvería:

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

    Y así sucesivamente. Puede leer más sobre las diferentes formas de indexación en numpy, incluido este método, aquí .

  • Luego, después de eso, la función invierte cada matriz devuelta, usando l[:,i][::-1], ya que cada matriz está indexada de izquierda a derecha, pero dado que el punto 0,0en la cuadrícula en la esquina inferior izquierda de la cuadrícula, invertir cada matriz devolvería los valores de índice como si los estuvieran buscando de derecha a izquierda. Por ejemplo, l[:,0][::-1]devolvería:

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

  • Después de esto, la función indexa a través de esa matriz invertida para el valor de índice correspondiente a p, que es su letra, y luego agrega eso a la lista que se está creando. Por ejemplo, l[:,0][::-1][4]que corresponde al punto (0,4), volvería A.

  • Este proceso continúa repitiéndose y agregando nuevos valores a la lista hasta que se agoten los objetos de rango.

Después de todo eso, la salida, que es la lista w, finalmente se devuelve. En este caso, eso sería APPLEsi se llama con print(''.join(r((0,4),(4,0),'''The Grid''')))o ['A','P','P','L','E']si se llama sin ''.join(). De cualquier manera, devuelve la respuesta correcta, ¡y hemos terminado!