Đưa ra một văn bản hình chữ nhật dưới dạng câu đố tìm kiếm từ và chuỗi tìm kiếm, xác định xem văn bản có chứa chuỗi tìm kiếm không. Chuỗi tìm kiếm có thể xuất hiện:

• theo chiều ngang, chiều dọc hoặc đường chéo
• tiến hoặc lùi

Bạn có thể viết một hàm hoặc một chương trình và lấy hai chuỗi làm đầu vào thông qua đối số hàm, ARGV hoặc STDIN. Đầu ra phải là kết quả trung thực hoặc sai lệch có thể được trả về từ hàm hoặc được ghi vào STDOUT.

Giả sử rằng văn bản sẽ chứa các ký tự ASCII có thể in tùy ý (mã hex 20 đến 7E) và các ký tự ngắt dòng. Thư là trường hợp nhạy cảm. Bạn có thể giả sử rằng văn bản đầu vào là hình chữ nhật, tức là tất cả các dòng có cùng độ dài. Bạn có thể xem liệu đầu vào có kết thúc bằng một dòng mới hay không (nếu nó quan trọng đối với việc gửi của bạn).

Đây là mã golf, câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

Ví dụ

Sử dụng lưới này từ bài viết của Wikipedia về tìm kiếm từ làm đầu vào đầu tiên:

WVERTICALL
ROOAFFLSAB
ACRILIATOA
NDODKONWDC
DRKESOODDK
OEEPZEGLIW
MSIIHOAERA
ALRKRRIRER
KODIDEDRCD
HELWSLEUTH

các chuỗi tìm kiếm sau đây sẽ mang lại kết quả trung thực hoặc sai lệch tương ứng:

Truthy: RANDOM, VERTICAL, HORIZONTAL, WORDSEARCH, WIKIPEDIA, TAIL
Falsy:  WordSearch, CODEGOLF, UNICORN

Ngoài ra, sử dụng văn bản đầu vào này

Lorem ipsum dolor sit amet consectetu
r adipisicing elit sed do eiusmod tem
por incididunt ut labore et dolore ma
gna aliqua. Ut enim ad minim veniam, 
quis nostrud exercitation ullamco lab
oris nisi ut aliquip ex ea commodo co
nsequat. Duis aute irure dolor in rep
rehenderit in voluptate velit esse ci
llum dolore eu fugiat nulla pariatur.

Chúng tôi nhận được các kết quả tìm kiếm sau (sử dụng dấu ngoặc kép ngay bây giờ, vì có một số khoảng trắng trong một số chuỗi tìm kiếm):

Truthy: "Lorem", "mine", "uma bop", "tuetdod", "snol,a", "texas", "pii.d  v", "vexta"
Falsy:  "lorem", "wordsearch", "pii.d v", "mute"

CJam, 46 37 byte

qN%{_zW%__,N**2$2$+,)/z\}4*]:+N*eas#)

Đọc lưới từ STDIN và từ dưới dạng đối số dòng lệnh. In các số nguyên dương cho các kết quả trùng khớp và 0 cho các kết quả không khớp.

Với chi phí của hai byte bổ sung, cả hai chuỗi (word, linefeed, lưới) có thể được đọc từ STDIN:

qN%(\{_zW%__,N**2$2$+,)/z\}4*](\:+N*\#)

Bạn có thể thử phiên bản trực tuyến này với trình thông dịch CJam .

Chạy ví dụ

$ for W in Lorem mine uma\ bop tuetdod snol,a texas pii.d\ \ v vexta WordSearch CODEGOLF UNICORN; do echo -e "$(cjam wordsearch.cjam "$W" < grid)\t$W"; done
1       Lorem
3085    mine
2055    uma bop
5142    tuetdod
3878    snol,a
1426    texas
5371    pii.d  v
2536    vexta
0       WordSearch
0       CODEGOLF
0       UNICORN

Lý lịch

Giả sử đầu vào là lưới sau:

ABCD
EFGH
IJKL

Tách tại các nguồn cấp dữ liệu, chúng tôi có được mảng sau:

A := [
         "ABCD"
         "EFGH"
         "IJKL"
     ]

Điều đó bao gồm các từ Đông (các từ đi từ trái sang phải).

Bây giờ, chúng tôi tham gia các yếu tố của Aviệc sử dụng một chuỗi các nguồn cấp dữ liệu len(A)làm dấu phân cách:

"ABCD⏎⏎⏎EFGH⏎⏎⏎IJKL"

Sau đó, chúng tôi cắt chuỗi kết quả theo từng đoạn dài len(A) + len(A[0]) + 1:

[
    "ABCD⏎⏎⏎E"
    "FGH⏎⏎⏎IJ"
    "KL"
]

Nếu chúng tôi "nén" mảng (chuyển hàng và cột), chúng tôi có được:

[
    "AFK"
    "BGL"
    "CH"
    "D⏎"
    "⏎⏎"
    "⏎⏎"
    "I⏎"
    "EJ"
]

Điều đó bao gồm các từ Đông Nam.

Nếu chúng tôi nén A và đảo ngược thứ tự của các hàng kết quả, chúng tôi có được:

[
    "DHL"
    "CGK"
    "BFJ"
    "AEI"
]

Điều đó bao gồm Nam và - sau khi lặp lại quá trình cho các đường chéo - từ Tây Nam.

Nén và đảo ngược một lần nữa, chúng tôi có được:

[
    "LKJI"
    "HGFE"
    "DCBA"
]

Điều đó bao gồm West và - sau khi lặp lại quá trình cho các đường chéo - các từ Tây Bắc.

Nén và đảo ngược một lần nữa, chúng tôi có được:

[
    "IEA"
    "JFB"
    "KGC"
    "LHD"
]

Điều đó bao gồm Bắc và - sau khi lặp lại quá trình cho các đường chéo - các từ Đông Bắc.

Làm thế nào nó hoạt động

Mã này được giải thích trong phần trước, với hai điểm khác biệt nhỏ:

• Nó giật và đảo ngược một lần ngay từ đầu.
• Nó tính toán len(A) + len(A[0])như len(A + zip(A)).

Cuối cùng, nó tham gia tất cả các hàng của tất cả các mảng được tạo bằng cách sử dụng nguồn cấp dữ liệu làm dấu phân cách và tìm kiếm từ trong chuỗi kết quả.

qN%                                   " A := split(input(),'\n')                          ";
   {                    }4*           " Do 4 times:                                       ";
    _zW%                              "   B := reverse(zip(A))                            ";
        __,N**                        "   C := B.join(len(B) * '\n')                      ";
              2$2$+,)/z               "   D := zip(C.chunks(len(A + B) + 1))              ";
                       \              "   A := B                                          ";
                           ]          " Collect all values of A and D in an array R.      ";
                            :+        " R := flatten(R)                                   ";
                              N*      " R := R.join('\n')                                 ";
                                eas   " I := flatten(ARGV)                                ";
                                   #) " print R.index(I) + 1                              ";

Java: 183 211 321

boolean s(char[]w,char[]s){int j,z,a=s.length,i=a*9,f=1,q=0;for(;s[q++]>10;);for(;i-->0;)for(j=w.length,z=i/9;i%9!=4&j-->0&z>=0&z<a&&s[z]==w[j];z+=q*(i/3%3)+i%3-q-1)f*=j;return f==0;}

Một lực lượng vũ phu cơ bản. Tôi đoán không còn nhiều điều để nói nữa. Đầu vào là kim đầu tiên và haystack thứ hai. Giả sử lưới là chấm dứt dòng mới .

Một phiên bản dễ đọc hơn một chút với trường hợp thử nghiệm được hiển thị:

public class WordSearch {
    static String grid = "WVERTICALL\nROOAFFLSAB\nACRILIATOA\nNDODKONWDC\nDRKESOODDK\nOEEPZEGLIW\nMSIIHOAERA\nALRKRRIRER\nKODIDEDRCD\nHELWSLEUTH";
    static String search = "RANDOM";

    public static void main(String[] args) {
        System.out.println(new WordSearch().s(search.toCharArray(),grid.toCharArray()));
    }

    boolean s(char[]w,char[]s){
        int j,z,a=s.length,i=a*9,f=1,q=0;
        for(;s[q++]>10;);
        for(;i-->0;)
            for(j=w.length,z=i/9;
                i%9!=4&j-->0&z>=0&z<a&&s[z]==w[j];
                z+=q*(i/3%3)+i%3-q-1)
                f*=j;
        return f==0;
    }
}

JavaScript (E6) 111 116

Brute Force tìm kiếm mọi nhân vật theo mọi hướng - chơi golf hết mức có thể

F=(b,w)=>
  [1,-1,r=b.search('\n'),-r,++r,-r,++r,-r].some(d=>
    [...b].some((_,p)=>
      [...w].every(c=>c==b[p+=d],p-=d)
    )
  )

Kiểm tra trong bảng điều khiển FireFox / Fireorms

;["RANDOM", "VERTICAL", "HORIZONTAL", "WORDSEARCH", "WIKIPEDIA", "TAIL",
"WordSearch", "CODEGOLF", "UNICORN"]
.forEach(w=>console.log('\n'+ w +' -> '+
  F("WVERTICALL\nROOAFFLSAB\nACRILIATOA\nNDODKONWDC\nDRKESOODDK\nOEEPZEGLIW\nMSIIHOAERA\nALRKRRIRER\nKODIDEDRCD\nHELWSLEUTH",w)))

Đầu ra

RANDOM -> true
VERTICAL -> true
HORIZONTAL -> true
WORDSEARCH -> true
WIKIPEDIA -> true
TAIL -> true
WordSearch -> false
CODEGOLF -> false
UNICORN -> false

Con trăn, 175

Không có nhiều cảm hứng, nhưng ở đây đi:

def s(h,n):
 l=h.find('\n')+2;h+='\n'*l;L=i=len(h)
 while i>0:
  i-=1
  for d in[-l,1-l,2-l,-1,1,l-2,l-1,l]:
    j=i;m=len(n)
    for c in n:m-=c==h[j%L];j+=d
    if m<1:i=-1
 return-i

Đối số đầu tiên là haystack, thứ hai là kim.

Bash + coreutils, 214 169 byte

r()(tee >(rev) $@)
t()(eval paste -d'"\0"' `sed 's/.*/<(fold -1<<<"&")/'`)
d()(while IFS= read l;do echo "$a$l";a+=_;done|t)
r<<<"$2"|r >(d) >(r|t) >(r|d)|r|grep -q "$1"

Sử dụng 3 hàm biến đổi r, tvà dđể đảo ngược, chuyển vị và dịch chuyển chéo, trong tất cả các kết hợp cần thiết.

Cập nhật - rchức năng hiện tạo ra đầu ra đảo ngược và không đảo ngược để tăng thêm tính golf

Nhập thông qua đối số dòng lệnh - chuỗi tìm kiếm, theo sau là khối tìm kiếm hình chữ nhật (dòng mới được phân tách).

Đầu ra là một mã trạng thái thoát vỏ chính xác - 0 có nghĩa là TRUE và 1 có nghĩa là SAI.

Đầu ra:

$ for w in "Lorem" "mine" "uma bop" "tuetdod" "snol,a" "texas" "pii.d  v" "vexta" ; do ./ws.sh "$w" "Lorem ipsum dolor sit amet consectetu
r adipisicing elit sed do eiusmod tem
por incididunt ut labore et dolore ma
gna aliqua. Ut enim ad minim veniam, 
quis nostrud exercitation ullamco lab
oris nisi ut aliquip ex ea commodo co
nsequat. Duis aute irure dolor in rep
rehenderit in voluptate velit esse ci
llum dolore eu fugiat nulla pariatur."; echo $?; done
0
0
0
0
0
0
0
0
$ for w in WordSearch CODEGOLF UNICORN ; do ./ws.sh "$w" "Lorem ipsum dolor sit amet consectetu
r adipisicing elit sed do eiusmod tem
por incididunt ut labore et dolore ma
gna aliqua. Ut enim ad minim veniam, 
quis nostrud exercitation ullamco lab
oris nisi ut aliquip ex ea commodo co
nsequat. Duis aute irure dolor in rep
rehenderit in voluptate velit esse ci
llum dolore eu fugiat nulla pariatur."; echo $?; done
1
1
1
$ 

C, 163

f(char*h,char*n){int i,j,d,p,y=0,l=strlen(h),w=strchr(h,10)-h+1;for(i=l*9;i--;y+=d&&!n[j]){p=i/9;d=i%9/3*w-w+i%3-1;for(j=0;p>=0&p<l&h[p]==n[j];j++)p+=d;}return y;}

Không sắp xếp lại lưới, tôi chỉ đơn giản thử mọi chữ cái bắt đầu theo mọi hướng, và đi dọc cho đến khi tôi chạy ra khỏi lưới hoặc tìm thấy một sự không phù hợp.

Tôi lợi dụng thực tế là một chuỗi C kết thúc bằng một byte số không. Vì không có byte nào trong lưới, LUÔN LUÔN sẽ không khớp. Nhưng nếu sự không phù hợp xảy ra ở byte 0, chúng ta biết rằng chúng ta đã tìm thấy phần cuối của chuỗi cần tìm và ghi lại nó dưới dạng khớp.

Ungolfed trong một chương trình thử nghiệm

char h[]="WVERTICALL\nROOAFFLSAB\nACRILIATOA\nNDODKONWDC\nDRKESOODDK\nOEEPZEGLIW\nMSIIHOAERA\nALRKRRIRER\nKODIDEDRCD\nHELWSLEUTH\n";

f(char*h,char*n){                                   //haystack,needle
  int i,j,d,p,y=0,l=strlen(h),w=strchr(h,10)-h+1;   //l=length of whole grid. w=width of row, including terminal newline ASCII 10
  for(i=l*9;i--;){                                  //for each start letter and direction
    p=i/9;                                          //pointer to start letter
    d=i%9/3*w-w+i%3-1;                              //9 possible values of direction vector {-w,0,w}+{-1,0,1}
    for(j=0;p>=0&p<l&h[p]==n[j];j++)p+=d;           //walk p in the direction defined by d until we walk off the top or bottom of the grid or a mismatch is fount
    y+=d&&!n[j];                                    //if we got all the way to the terminal 0, record it as a hit. If d=0, don't record as this is an invalid direction.
  }
  return y;   
}

main(int c, char**v){
  printf("%d",f(h,v[1]));  
}

Đầu ra

Lưu ý rằng hàm sẽ trả về tổng số lần mắc của chuỗi được tìm kiếm trong lưới. Do đó, ODnó trả về 6. Nếu không tìm thấy sự cố nào, nó trả về 0, đó là giá trị giả mạo duy nhất trong C. Thay đổi để y|=d*!n[j]lưu một ký tự nhưng mất chức năng này.

$ ./a UNICORN
0

$ ./a CODEGOLF
0

$ ./a WordSearch
0

$ ./a RANDOM
1

$ ./a WORDSEARCH
1

$ ./a VERTICAL
1

$ ./a HORIZONTAL
1

$ ./a WIKIPEDIA
1

$ ./a TAIL
1

$ ./a OD
6

C # - 218 197 186 byte

Hàm C # có 2 chuỗi, từ đầu tiên để tìm kiếm, lưới sau có nguồn cấp dữ liệu ( \n) giữa các dòng. Bây giờ mọi thứ đang trở nên tuyệt vọng ... thực tế là tuyệt vọng rằng chỉnh sửa trước đây của tôi không hoạt động!

Mã đánh gôn:

bool F(string D,string S){int l=S.Length,i=l*13,r,p;for(S+="\n";i-->l*5;i=r<0?r:i)for(r=D.Length,p=i%l;p>-1&p<l&r-->0&&D[r]==S[p];p+=(S.IndexOf('\n')+1)*(i/l%9/3-1)+i/l%3-1);return i<0;}

Ít chơi golf hơn với mã kiểm tra:

class P
{
    static void Main()
    {
        System.Console.WriteLine(new P().F(System.Console.ReadLine(),System.Console.In.ReadToEnd())?"Truthy":"Falsy"); // because why not
    }

    bool F(string D,string S)
    {
        int l=S.Length,i=l*13,r,p;

        for(S+="\n";i-->l*5;i=r<0?r:i) // for each cell/direction
            for(r=D.Length,p=i%l;p>-1&p<l&r-->0&&D[r]==S[p];p+=(S.IndexOf('\n')+1)*(i/l%9/3-1)+i/l%3-1); // test against string (backwards)

        return i<0;
    }
}

Haskell - 173

Thay vì tìm kiếm trực tiếp trên lưới, tôi chuyển đổi lưới theo nhiều cách khác nhau và khớp từ với từng hàng của lưới mới.

Ví dụ,

G1    G2    G3       G4   G5

abcd  aA1   abcd     a..  ..1
ABCD  bB2   .ABCD    bA.  .A2
1234  cC3   ..1234   cB1  aB3
      dD4            dC2  bC4
                      D3  cD
                       4  d

Tìm kiếm từ trong mỗi hàng G1, G2, G4 và G5, sau đó chúng tôi đã hoàn tất. Lưu ý rằng G3 không được sử dụng, tôi đăng nó ở đây chỉ để minh họa.

Một ý tưởng tương tự được áp dụng để tìm kiếm tiến và lùi: chỉ cần tìm từ gốc và từ đảo ngược.

Vì vậy, bây giờ chúng tôi đã tìm kiếm 8 hướng. Đây là mã, có tính chính xác được xác minh bởi một tập lệnh khác .

import Data.List
v=reverse
t=transpose
y=any
d r=zipWith(++)(scanr(\_->('\n':))[]r)r
g r w=y(y$y((==w).take(length w)).tails)[r,t r,t.d$r,t.d.v$r]
f r w=y(g(lines r))[w,v w]

Hàm flà những gì chúng ta muốn và đối số của nó rlà chuỗi hình chữ nhật, wlà từ để tìm kiếm.

Python 2 - 246 259 275 308 298 297 294 313 322

w,s=input()
r=range
d='\n'
I=''.join
w=w.split(d)
t,u=len(w),len(w[0])
v=d.join([I(x)for x in zip(*w)]+[d]+[I([w[i+j][i]for i in r(min(u,t-j))])+d+I([w[i][i+j]for i in r(min(t,u-j))])for j in r(max(t,u))]+[d]+w)
print s in v or s[::-1]in v

Cảm ơn Will đã giúp đỡ trong việc xử lý việc in và xác định tham gia.

Cảm ơn đường sắt ngầm đã nhắc nhở tôi đến không gian chơi golf đúng cách; p

Đã sửa lỗi cho các kết quả khớp xấu nhờ sử dụng ',' làm dấu phân cách.

Rõ ràng cách tốt nhất để chơi golf là thêm hàng tấn cuộn ngang.

Đầu vào như khoảng trắng nổ xuống dòng phân dòng trong dấu ngoặc kép: "WVERTICALL \ nROOAFFLSAB \ nACRILIATOA \ nNDODKONWDC \ nDRKESOODDK \ nOEEPZEGLIW \ nMSIIHOAERA \ nALRKRRIRER \ nKODIDEDRCD \ nHELWSLEUTH", "ngẫu nhiên"

APL (Dyalog Classic) , 44 byte

1∊⍞⍷↑{⍉0,⍵,↑(0,⊢)\↓0,⍵}¨{⍉⌽⍵}\4⍴⊂↑a⊆⍨a≠⊃⌽a←⎕

Hãy thử trực tuyến!

J , 60 53 byte

<@[e.[:,[:(;|.)@>[:<\\.@>[:(<"1,</.)@>@(;|.@|:)[;.2@]

Hãy thử trực tuyến!

Yêu cầu đầu vào đầu tiên không chứa dòng mới.

Giải trình:

linkrotate=: ;|.@|:     NB. link with itself rotated 90° ccw
infixes   =: <\\.       NB. list of boxes containing the infixes
lines     =: <"1 , </.  NB. horizontal and diagonal lines, boxed
linkrev   =: ;|.        NB. link with itself reversed
appearin  =: <@[ e. [: , [: linkrev@> [: infixes@> [: lines@>@linkrotate [;.2@]

Hãy thử trực tuyến!

Móc là hữu ích.

Thạch , 16 byte

^{Đã giải quyết một thách thức liên quan (có thể là trùng lặp) với 15 trong số 16 byte này làm cốt lõi của mã ...}

ỴZU$3С;ŒD$€Ẏw€Ẹ

Một liên kết dyadic chấp nhận một danh sách các ký tự ở bên trái và một danh sách các ký tự ở bên phải trả về 1 nếu tìm thấy và 0 nếu không.

Hãy thử trực tuyến!

Làm sao?

ZU$3С;ŒD$€Ẏw€Ẹ - Link: words, grid
   3С          - repeat three times and collect the results (inc input):
  $             -   last two links as a monad:
Z               -     transpose
 U              -     upend     (together these rotate by a quarter)
          €     - for €ach:
         $      -   last two links as a monad:
       ŒD       -     get forward-diagonals
      ;         -     concatenate
           Ẏ    - tighten (to get all the runs across the grid) 
             €  - for €ach run:
            w   -   sublist-index (0 if not found)
              Ẹ - any truthy? (i.e. was the word found?)