Question

我开始勾勒出一个递归算法的结构，该算法将在Settlers of Catan风格的游戏板中构建一个六角形瓷砖交叉点的邻接列表。然而，这不是我需要解决的直接问题。

我可以在代码示例下方粘贴的输出中找到我遇到的问题。输出的第一行和最后一行中的某些值似乎是字符串，没有明显的原因。

我希望一位经验丰富的Elixir开发人员能够认识到输出损坏的原因，并能够解释它为什么会发生以及该怎么做。

  def recurse_outer() do                                                                                                                             
    list = [Enum.into(0..5, []),                                                                                                                     
            Enum.into(6..23, []),                                                                                                                    
            Enum.into(24..53, [])                                                                                                                    
           ]                                                                                                                                         
    Enum.map(list, &recurse_inner(&1))                                                                                                               
  end                                                                                                                                                

  defp recurse_inner(list, index \\ 0, result \\ [])                                                                                                 
  defp recurse_inner([head | tail] = list, index, result) do                                                                                         
    next =                                                                                                                                           
      case tail do                                                                                                                                   
        [next | tail] -> next                                                                                                                        
        [] -> :no_next                                                                                                                               
      end                                                                                                                                            

    adjacencies = [head, next]                                                                                                                       

    recurse_inner(tail, index + 1, [adjacencies | result])                                                                                           
  end                                                                                                                                                
  defp recurse_inner([], _, result), do:                                                                                                             
    Enum.reverse(result)

输出：

iex(159)> Board.recurse_outer
[[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, :no_next]],
 [[6, 7], '\a\b', '\b\t', '\t\n', '\n\v', '\v\f', '\f\r', [13, 14], [14, 15],
  [15, 16], [16, 17], [17, 18], [18, 19], [19, 20], [20, 21], [21, 22],
  [22, 23], [23, :no_next]],
 [[24, 25], [25, 26], [26, 27], [27, 28], [28, 29], [29, 30], [30, 31],
  [31, 32], ' !', '!"', '"#', '#$', '$%', '%&', '&\'', '\'(', '()', ')*', '*+',
  '+,', ',-', '-.', './', '/0', '01', '12', '23', '34', '45', [53, :no_next]]]

令人惊讶的递归Elixir算法输出

0 个答案: