编写一个带有两个参数的函数：一个正整数n和一个单词列表。

给定一个n × n × n单位的立方体，请为每个表面单位分配一个随机字母（AZ）。（对于3x3x3立方体，每个面上将有9个表面单元。）

然后确定蚂蚁是否有可能沿着表面走动（具有横穿面孔的能力）拼写所提供的每个单词。假设要拼写一个单词，字母必须在上/下或左/右相邻，但不一定在同一面上。[ 编辑，为清楚起见：蚂蚁可以反转其路径并多次使用字母。每个表面单元都算作一个字符，因此要用重复的字母拼写一个单词（例如“ see”），蚂蚁将不得不访问三个相邻的单元。

该函数应该输出两件事：

1）每个面上的每个字母，以使得可以推断拓扑。例如，对于2x2x2多维数据集，可接受的输出如下所示：

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

2）每个单词，以及一个表示布尔值的布尔值，表示蚂蚁是否有可能通过沿着立方体的表面行走来拼写单词。例如：

1 ask
0 practical
1 pure
0 full

奖金挑战（不会因素考虑比分，只是为了好玩）：代替ñ仅代表立方体的大小，让ñ也代表了形状的维度。因此，n为2将产生2x2平方；一个Ñ的3将产生3x3x3的立方体; 和Ñ的4将产生的tesseract 4x4x4x4。

Ruby，272个字节

嵌套函数的两边都向代码添加了两个不必要的换行符，g以提高可读性。这些不计入分数。f=将匿名函数分配给变量的字符也被排除。

输出格式为0或1每个问题，而不是Ruby的native true和false。换行符（而不是空格）用于分隔布尔值和单词。我的理解是，这是对输出要求的可接受的解释，但如果不是这样，对字节数的影响将很小。

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}}

输出量

经过大约50次这样的通话：

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

我终于得到了2次点击的以下输出。ANT在右下角向上，并且由AN共享CAN，而C环绕线则在左上角。

....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

说明

所选立方体的特殊展开部分是由于其易于绘制而选择的，而主要是因为其易于搜索。

非字母字符（每行末尾的点加换行符）是可能会发现蚂蚁行走的领域的重要组成部分。

搜索是由g嵌套在函数中的递归函数执行的f。如果传递的单词是一个空字符串，则搜索完成并将$r其设置为1。如果蚂蚁位于与单词的第一个字母相对应的字母方块上，则将在所有四个方向上继续搜索：再次调用该函数通过删除第一个字母来缩短单词。在这种情况下，方向参数将被忽略。移动是通过递归调用单元索引来完成的，单元索引由值更改。x.相加的结果取网格大小加上一条额外的半行为模。这意味着底线以正确的水平偏移量环绕到顶部，反之亦然。

如果蚂蚁在非字母正方形上，则她必须以梯形弯曲，直到找到字母正方形为止。她将向东南或西北方向移动。这是通过递归调用模拟的，d每次将参数与1进行XOR运算以跟踪其运动。在到达下一个字母方块之前，输入单词不会缩短。方便地，这可以通过与我们在带有字母的区域中搜索时使用的相同的递归来完成。不同之处在于，当蚂蚁在空白区域时，递归仅具有一个分支，而在字母区域中则为4。

注释代码

->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
}