Schreiben Sie ein Programm oder eine Funktion, die ein Wort aus einer Wortsuche anhand seiner Start- und Endkoordinaten extrahiert.

Die Eingabe

Ihr Programm oder Funktion sollte drei Parameter übernehmen: die Start - Koordinate , das Ende zu koordinieren , und ein Wortsuch , aus denen das Wort zu extrahieren.

• Die Startkoordinate kann in einem beliebigen Format verwendet werden.

  • Es wird immer eine ganze Zahl sein

  • Unten links im Raster ist (0, 0)

  • Sie erhalten keine Koordinaten, die außerhalb der Grenzen des Gitters liegen

  • Sie erhalten keine Koordinaten, die nicht vertikal, horizontal oder perfekt diagonal zueinander sind, wie z. B. (7, 0) und (0, 6).

• Die Endkoordinate wird im gleichen Format wie die Startkoordinate verwendet

• Die Wortsuche ist eine Zeichenfolge oder das nächste Äquivalent Ihrer Sprache

  • Es handelt sich um ein Zeichenraster, das durch ein einzelnes Leerzeichen getrennt ist , wobei jede Zeile in einer neuen Zeile steht . Es kann jede Höhe oder Breite haben - was unterschiedlich sein kann - aber es wird immer ein Rechteck sein . Zum Beispiel:

    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
    

Die Ausgabe

Sie sollten eine Zeichenfolge oder das nächstgelegene Äquivalent Ihrer Sprache ausgeben . Da keine Wortsuche im wirklichen Leben jemals nach einem einzigen Buchstaben fragt, können Sie nichts ausgeben, wenn die Koordinaten gleich sind.

Beispiele und Testfälle

Erstes Gitter oben:
(0, 4) und (4, 0) -> "APPLE"

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

(1, 7) und (4, 7) -> "ZIEGE"

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

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

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

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

----------

Zweites Gitter oben:
(1, 0) und (8, 7) -> "FJLHJJWT"


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

(1, 4) und (1, 4) -> "L" oder ""

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

Weniger Golf gespielt

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

• Nimmt Eingaben im folgenden Format vor:

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

• Ausgaben im Format einer Zeichenfolge (z. B. APPLE), solange die Funktion im obigen Format aufgerufen wird. Andernfalls wird eine Liste mit jedem Buchstaben (z ['A','P','P','L','E']. B. ) zurückgegeben.

Wird im Laufe der Zeit mehr Golf spielen, wo und wann ich kann.

Probieren Sie es online aus! (Ideone) (Hier wird die Eingabe so vorgenommen, dass das Raster von doppelten Anführungszeichen ( "") umgeben ist, und in einer Zeile mit \ns zwischen jeder Zeile des Rasters eingegeben . Anschließend werden die Punkte in einer einfachen Tupelform mit dem Start bereitgestellt in der zweiten Zeile und das Ende in der dritten.)

Ungolfed Code zusammen mit Erklärung

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

Für die Zwecke dieser Erklärung wird angenommen, dass dieses Programm mit den Eingaben ((0,4),(4,0))und dem ersten Raster der Frage ausgeführt wurde. Hier werde ich die 2 Hauptteile des Codes durchgehen:

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

  Hier list ein Numpy-Array, das jede Zeile der Eingabe in einer separaten "Liste" enthält. Zum Beispiel das erste Raster in der Frage:

  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
  

  gibt dieses numpy-Array zurück:

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

  Dies ist die Hauptliste der Funktion, in der alle Buchstaben gefunden werden, die jedem Punkt im Raster entsprechen. Entspricht hier ientweder jeder Ganzzahl in n, bei der es sich um ein Bereichsobjekt handelt, das jede Zahl im Bereich start1=>end1+1in Schritten von +1if enthält start1<end1oder -1wenn das Gegenteil der Fall ist. Entspricht idies jedoch nur, solange start1es nicht gleich ist end1. Andernfalls start1wird so oft wie die Länge von zurückgegeben m, wobei mein Bereichsobjekt jede Ganzzahl im Bereich start2=>end2+1mit den gleichen Bedingungen wie enthält nund pjeder Ganzzahl in entspricht m. Lassen Sie uns nun Schritt für Schritt durch diesen Schritt gehen:

  • l[:,i]Grundsätzlich wird für jede Spalte iim Array ein Zeilenvektor zurückgegeben l. würde zum Beispiel l[:,0]zurückkehren:

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

    l[:,1] würde zurückkehren:

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

    und so weiter und so fort. Weitere Informationen zu verschiedenen Indizierungsmethoden in Numpy, einschließlich dieser Methode, finden Sie hier .

  • Danach kehrt die Funktion jedes zurückgegebene Array um, indem verwendet wird l[:,i][::-1], da jedes Array von links nach rechts indiziert ist. Da jedoch der Punkt 0,0auf dem Gitter in der unteren linken Ecke des Gitters liegt, würde das Umkehren jedes Arrays die Indexwerte zurückgeben als würden sie von rechts nach links gesucht. Zum Beispiel l[:,0][::-1]würde zurückkehren:

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

  • Danach indiziert die Funktion durch dieses umgekehrte Array nach dem Indexwert p, der Ihrem Buchstaben entspricht, und fügt diesen der zu erstellenden Liste hinzu. Zum Beispiel würde, l[:,0][::-1][4]was Punkt entspricht (0,4), zurückkehren A.

  • Dieser Vorgang wiederholt sich und fügt der Liste neue Werte hinzu, bis die Bereichsobjekte erschöpft sind.

Nach all dem wird die Ausgabe, die Liste wist, schließlich zurückgegeben. In diesem Fall wäre das, APPLEwenn mit print(''.join(r((0,4),(4,0),'''The Grid''')))oder ['A','P','P','L','E']ohne aufgerufen wird ''.join(). In jedem Fall wird die richtige Antwort zurückgegeben, und wir sind fertig!