Tulis program atau fungsi yang mengekstrak kata dari pencarian kata menggunakan koordinat awal dan akhir.

Input

Program atau fungsi Anda harus menerima tiga parameter: koordinat awal , koordinat akhir , dan pencarian kata untuk mengekstrak kata tersebut.

• The start berkoordinasi dapat diambil dalam format apapun.

  • Itu akan selalu menjadi bilangan bulat

  • Kiri bawah grid adalah (0, 0)

  • Anda tidak akan diberikan koordinat yang melampaui batas kisi

  • Anda tidak akan diberikan koordinat yang tidak vertikal, horizontal, atau diagonal sempurna satu sama lain, seperti (7, 0) dan (0, 6).

• The end koordinat akan diambil dalam format yang sama seperti awal koordinat

• The WordSearch akan menjadi tali , atau bahasa Anda paling dekat setara

  • Ini akan menjadi kisi karakter yang dipisahkan oleh satu ruang , dengan setiap baris pada baris baru . Ini dapat memiliki tinggi atau lebar - yang dapat berbeda - tetapi akan selalu menjadi persegi panjang . Sebagai contoh:

    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
    

Hasil

Anda harus menampilkan string , atau setara bahasa terdekat Anda. Karena tidak ada pencarian kata-kata dalam kehidupan nyata yang pernah meminta untuk menemukan satu huruf, Anda mungkin tidak menghasilkan apa-apa jika koordinatnya sama.

Contoh dan Uji Kasus

Kotak Pertama Di Atas:
(0, 4) dan (4, 0) -> "APPLE"

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

(1, 7) dan (4, 7) -> "GOAT"

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

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

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

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

----------

Grid Kedua Di Atas:
(1, 0) dan (8, 7) -> "FJLHJJWT"


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

(1, 4) dan (1, 4) -> "L" atau ""

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

Kurang 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 menggunakan Numpy, 251 byte:

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

• Mengambil input dalam format berikut:

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

• Output dalam format string (mis. APPLE) Selama fungsinya disebut menggunakan format di atas. Kalau tidak, daftar yang berisi setiap huruf (misalnya ['A','P','P','L','E']) dikembalikan.

Akan golf lebih dari waktu ke waktu di mana dan kapan saya bisa.

Cobalah secara Online! (Ideone) (Di sini, input diambil sehingga grid dikelilingi dengan tanda kutip ganda ( "") dan input pada satu baris, dengan \ns di antara setiap baris grid. Kemudian, poin disediakan dalam bentuk tuple sederhana, dengan permulaan pada baris kedua, dan akhir pada baris ketiga.)

Kode yang tidak digabungkan dengan Penjelasan

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

Untuk keperluan penjelasan ini, anggaplah program ini dijalankan dengan input ((0,4),(4,0))dan kisi pertama dari pertanyaan. Di sini, saya akan membahas 2 bagian utama dari kode:

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

  Di sini, ladalah array numpy yang berisi setiap baris input dalam "daftar" yang terpisah. Misalnya, kisi pertama dalam pertanyaan, yaitu:

  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
  

  mengembalikan array numpy ini:

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

  Ini adalah daftar utama dari fungsi di mana semua huruf yang sesuai dengan setiap titik pada grid ditemukan. Di sini, iberkorespondensi dengan setiap bilangan bulat di n, yang merupakan objek rentang yang berisi setiap angka dalam rentang start1=>end1+1dalam peningkatan +1jika start1<end1atau -1jika kebalikannya benar. Namun, ihanya sesuai dengan ini selama start1tidak sama end1. Jika tidak, start1dikembalikan sebanyak kali dari panjang m, di mana mobjek rentang berisi setiap bilangan bulat dalam kisaran start2=>end2+1dengan kondisi yang sama seperti n, dan psesuai dengan setiap bilangan bulat di m. Yang sedang berkata, mari kita sekarang berjalan melalui langkah demi langkah:

  • l[:,i]pada dasarnya mengembalikan vektor baris untuk setiap kolom i,, dalam array l,. misalnya, l[:,0]akan kembali:

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

    l[:,1] akan kembali:

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

    seterusnya dan seterusnya. Anda dapat membaca lebih lanjut tentang berbagai cara pengindeksan dalam numpy, termasuk metode ini, di sini .

  • Kemudian, setelah itu, fungsi membalikkan setiap array yang dikembalikan, menggunakan l[:,i][::-1], karena setiap array diindeks dari kiri ke kanan, tetapi karena titik 0,0di grid masuk di sudut kiri bawah grid, membalikkan setiap array akan mengembalikan nilai indeks seolah-olah mereka sedang dicari dari kanan ke kiri. Misalnya, l[:,0][::-1]akan kembali:

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

  • Setelah ini, fungsi kemudian indeks melalui array terbalik untuk nilai indeks yang sesuai dengan p, yang merupakan surat Anda, dan kemudian menambahkannya ke daftar yang sedang dibuat. Misalnya, l[:,0][::-1][4]yang sesuai dengan titik (0,4), akan kembali A.

  • Proses ini terus berulang dan menambahkan nilai-nilai baru ke daftar sampai objek rentang habis.

Setelah semua itu, output, yang daftar w, akhirnya dikembalikan. Dalam hal ini, itu akan menjadi APPLEjika dipanggil dengan print(''.join(r((0,4),(4,0),'''The Grid''')))atau ['A','P','P','L','E']jika itu disebut tanpa ''.join(). Either way, itu mengembalikan jawaban yang benar, dan kita selesai!