Ieri mi sono chiesto se potevo scrivere un programma per passare attraverso una determinata ricerca di parole e produrre le risposte. In realtà è stato sorprendentemente facile. Ora mi chiedo quanto piccolo possiamo ottenere.

Regole

• Il tuo primo input è una stringa o una raccolta di n righe, ognuna delle quali è lunga n caratteri
• Il tuo secondo input è un elenco di parole in qualsiasi formato da trovare nel puzzle
• Tutte le parole nell'elenco di ricerca sono garantite nel puzzle
• Le parole possono essere orientate in una delle quattro direzioni cardinali, così come in diagonale sia in avanti che all'indietro
• Nel puzzle saranno presenti solo caratteri AZ maiuscoli
• Il codice deve trovare ogni parola nella stringa di ricerca e generare la posizione delle coordinate della lettera iniziale, dove 0,0 è il carattere in alto a sinistra.
• Nel caso in cui trovi più di un'istanza della stessa parola, puoi gestirla come preferisci. Output più volte, o solo una volta, dipende da te

Esempi / casi di test

Dato il seguente consiglio:

ABCD
EFGH
IJKL
MNOP

E la seguente stringa di ricerca:

ABCD,CGKO,POMN,NJF,AFKP,CFI,LGB,MJGD

Il tuo programma dovrebbe generare quanto segue, in qualsiasi ordine:

ABCD at 0,0
CGKO at 0,2
PONM at 3,3
NJF at 3,1
AFKP at 0,0
CFI at 0,2
LGB at 2,3
MJGD at 3,0

Come sempre, la risposta più breve vince

JavaScript (Node.js) , 154 152 150 141 byte

• grazie ad Arnauld per la riduzione di 2 byte

restituisce una matrice di posizioni (prima era una stringa con nuove righe)

(b,w)=>w.map(s=>[...b].map((_,p)=>[1,-1,r=b.search`
`,-r,~r,++r,-~r,~r].map(d=>[...s].every((c,i)=>c==b[p+d*i])?s+=" at "+[p/r|0,p%r]:0))&&s)

Provalo online!

Python 2 , 213 byte

lambda a,W:[(w,i,j)for w in W for i in R(L(a))for j in R(L(a[0]))for U in R(9)if U-4and g(i,j,U/3-1,U%3-1,a).find(w)==0]
g=lambda i,j,u,v,a,s='':L(a)>i>=0<=j<L(a[0])and g(i+u,j+v,u,v,a,s+a[i][j])or s
L=len;R=range

Provalo online!

gprende una posizione di partenza i,je una direzioneu,v e tramite ricorsione estrae la stringa che inizia in quella posizione in quella direzione.

fquindi visita ogni posizione i,je direzione di partenza U/3-1,U%3-1e controlla ogni parola wper vedere se la stringa risultante inizia con w.

Python 3 , 149 147 byte

def g(b,w):h=b.find('\n')+1;return[f'{y} at {i//h},{i%h}'for y in w for i in range(len(b))for d in(1,h+1,h,h-1,-1,~h,-h,1-h)if y==b[i::d][:len(y)]]

Provalo online!

Versione Ungolfed

def g(b,w):
    h = b.find('\n') + 1                              # width of a row plus the '\n'
    a = []
    for y in w:                                       # iterate over the words
        for i in range(len(b)):                       #   iterate over the game board
            for d in(1,h+1,h,h-1,-1,~h,-h,1-h):       #     for each possible direction
                if y==b[i::d][:len(y)]:               #       see if the word matches
                    a.append(f'{y} at {i//h},{i%h}')
    return a

L'idea principale è quella di b[i::d]selezionare una fetta dal tabellone. La sezione inizia come posizione ie si estende nella direzione d. Ad esempio, d = h+1corrisponde alla diagonale sud-est, mentre d = ~h, che è la stessa -h-1, corrisponde alla diagonale nord-ovest. [:len(y)] taglia la sezione alla stessa lunghezza della parola cercata.