Viết hàm có hai tham số: số nguyên dương n và danh sách các từ.

Cho một khối các đơn vị n -by- n -by- n , gán một chữ cái ngẫu nhiên (AZ) cho mỗi đơn vị bề mặt. (Đối với khối lập phương 3x3x3, sẽ có 9 đơn vị bề mặt trên mỗi mặt.)

Sau đó xác định xem một con kiến ​​có thể đi dọc theo bề mặt (với khả năng bắt chéo mặt) để đánh vần từng từ được cung cấp hay không. Giả sử rằng để đánh vần một từ, các chữ cái phải lên / xuống hoặc trái / phải liền kề, nhưng không nhất thiết phải nằm trên cùng một mặt. [ Chỉnh sửa, cho rõ ràng: Con kiến ​​có thể đảo ngược đường dẫn của nó và sử dụng các chữ cái nhiều lần. Mỗi đơn vị bề mặt được tính là một ký tự, do đó, để đánh vần một từ có các chữ cái lặp đi lặp lại (ví dụ "thấy"), con kiến ​​sẽ phải truy cập ba đơn vị liền kề.]

Hàm sẽ xuất ra hai điều:

1) Mỗi ​​chữ cái trên mỗi mặt, theo cách mà cấu trúc liên kết có thể được suy ra. Chẳng hạn, đối với khối 2x2x2, một đầu ra chấp nhận được sẽ trông như sau:

   QW
   ER
TY OP UI
DF JK XC
   AS
   GH
   LZ
   VB

2) Mỗi ​​từ, cùng với một boolean đại diện cho việc con kiến ​​có thể đánh vần từ đó bằng cách đi dọc theo bề mặt của khối lập phương. Ví dụ:

1 ask
0 practical
1 pure
0 full

Thử thách tiền thưởng (sẽ không tính đến điểm số, chỉ để giải trí): Thay vì n chỉ đại diện cho kích thước của khối lập phương, hãy n cũng đại diện cho chiều của hình dạng. Vì vậy, một n 2 sẽ mang lại một hình vuông 2x2; một n 3 sẽ mang lại một khối 3x3x3; và một n là 4 sẽ mang lại một tesseract 4 x 4 x 4.

Ruby, 272 byte

Hai dòng mới không cần thiết được thêm vào mã ở hai bên của hàm lồng nhau gđể cải thiện khả năng đọc. Những điều này được loại trừ khỏi điểm số. Các ký tự f=gán hàm ẩn danh cho một biến cũng được loại trừ.

Định dạng đầu ra là 0hoặc 1theo câu hỏi thay vì nguồn gốc của Ruby truevà false. Một dòng mới (chứ không phải là một khoảng trắng) được sử dụng để phân tách boolean và từ. Tôi hiểu rằng đây là một cách giải thích chấp nhận được các yêu cầu đầu ra, nhưng nếu không, tác động lên số byte sẽ không đáng kể.

f=->n,l{c=''
x=[p=6*n,1,-p,-1]
(m=3*p*n).times{|i|c<<(5+i/n%6-i/n/p&6==6?65+rand(26):i%p==p-1?10:46)}
q=m+3*n
puts c

g=->w,i,d{w==''?$r=1:c[i]<?A?g[w,(i+x[d])%q,d^1]:w[0]==c[i]&&4.times{|j|g[w[1..-1],(i+x[j])%q,j^1]}}

l.each{|w|$r=0
m.times{|i|c[i]>?@&&g[w,i,0]}
puts $r,w}}

Đầu ra

Sau khoảng 50 cuộc gọi như thế này:

f[4,['PPCG','CODE','GOLF','ANT','CAN','CUBE','WORD','WALK','SPELL']]

Cuối cùng tôi đã nhận được kết quả đầu ra với 2 lần truy cập. ANTở phía dưới bên phải đi lên và ANđược chia sẻ bởi CAN, với Cvòng bao quanh trên cùng bên trái.

....KCAAXRHT...........
....ALRZXRKL...........
....NDDLCMCT...........
....ETQZHXQF...........
........FYYUSRZX.......
........CFNPAUVX.......
........ZTJVHZVQ.......
........AUWKGVMC.......
............XWKSDWVZ...
............DPLUVTZF...
............DMFJINRJ...
............ZRXJIAFT...
0
PPCG
0
CODE
0
GOLF
1
ANT
1
CAN
0
CUBE
0
WORD
0
WALK
0
SPELL

Giải trình

Sự mở ra cụ thể của khối được chọn, được chọn một phần vì dễ vẽ, nhưng chủ yếu là để dễ tìm kiếm.

Các ký tự không phải là bảng chữ cái (các dấu chấm cộng với dòng mới ở cuối mỗi dòng) là một phần quan trọng của trường nơi con kiến ​​có thể được tìm thấy đang đi bộ.

Tìm kiếm được thực hiện bởi hàm đệ quy g, được lồng trong hàm f. Nếu từ được truyền là một chuỗi trống, tìm kiếm hoàn tất và $rđược đặt thành 1. Nếu con kiến ​​nằm trên ô vuông chữ cái tương ứng với chữ cái đầu tiên của từ đó, việc tìm kiếm được tiếp tục theo cả bốn hướng: chức năng được gọi lại với từ được rút ngắn bằng cách loại bỏ chữ cái đầu tiên của nó. Trong trường hợp này, tham số hướng được bỏ qua. Việc di chuyển được thực hiện bằng cách gọi đệ quy với chỉ số ô được thay đổi bởi các giá trị trong x.Kết quả của phép cộng được lấy modulo kích thước của lưới cộng với một nửa dòng bổ sung. Điều này có nghĩa là dòng dưới cùng kết thúc tròn lên trên cùng và ngược lại, với độ lệch ngang chính xác.

Nếu con kiến ​​nằm trên một hình vuông không có chữ cái, cô phải ngoằn ngoèo trong một chuyển động cầu thang cho đến khi cô tìm thấy một hình vuông chữ cái. Cô sẽ zizag theo hướng đông nam hoặc tây bắc. Điều này được mô phỏng bằng các cuộc gọi đệ quy với dtham số được XOR với 1 lần mỗi lần để theo dõi chuyển động của cô ấy. Cho đến khi cô đạt đến ô vuông tiếp theo, không rút ngắn từ đầu vào. Thuận tiện, điều này có thể được thực hiện bằng cách đệ quy tương tự như được sử dụng khi chúng ta đang tìm kiếm trong khu vực với các chữ cái. Sự khác biệt là, đệ quy chỉ có một nhánh khi con kiến ​​nằm trong khu vực khoảng trắng, trái ngược với 4 trong khu vực chữ cái.

Mã nhận xét

->n,l{                                   #n=square size, l=list of words to search
  c=''                                   #empty grid
  x=[p=6*n,1,-p,-1]                      #offsets for south, east, north, west. p is also number of characters per line
  (m=3*p*n).times{|i|                    #m=total cells in grid. for each cell
    c<<(5+i/n%6-i/n/p&6==6?              #apppend to c (according to the formula)
      65+rand(26):                       #either a random letter
      i%p==p-1?10:46)                    #or a "whitespace character" (newline, ASCII 10 or period, ASCII 46)
  }
  q=m+3*n                                #offset for vertical wraparound = grid size plus half a row.                           
  puts c                                 #print grid

  g=->w,i,d{                             #search function. w=word to search for, i=start index in grid, d=direction
    w==''?                               #if length zero, already found,
      $r=1:                              #so set flag to 1. Else
      c[i]<?A?                           #if grid cell is not a letter
        g[w,(i+x[d])%q,d^1]:             #recursively call from the cell in front, with the direction reflected in NW-SE axis
        w[0]==c[i]&&                     #else if the letter on the grid cell matches the start of the word
          4.times{|j|                    #for each direction (iterate 4 times, each time a different direction is "in front")
            g[w[1..-1],(i+x[j])%q,j^1]}  #recursively call from the cell in front. Chop first letter off word. 
   }                                       #Direction parameter is XORed (reflected in NW-SE axis) in case ant hits whitespace and has to zigzag.

   l.each{|w|                            #for each word in the list
     $r=0                                #set global variable $r to zero to act as a flag
     m.times{|i|c[i]>?@&&g[w,i,0]}       #call g from all cells in the grid that contain a letter 
     puts $r,w}                          #output flag value and word
}