Recursion 矩阵上的Elixir环

我有一个元素列表，我正在使用

Enum.chunk\u every

方法将其转换为列表列表

代码如下所示：

matrix = Enum.chunk_every(list_1d, num_cols)
Now I want to loop over the matrix and access the neighbors

简单地说，如果我有一个列表[1,2,3,4,5,6,1,2,3]，它被转换成3X3矩阵，如：

[1,2,3]，[4,5,6]，[1,2,3]]

现在我如何循环这个矩阵？如果我想访问元素的邻居呢？例如，5的邻域是2、4、6和2

---

<>我可以看到递归是一种方法，但是这将如何工作？

< P>有很多方法来解决这个问题，我认为你应该首先考虑你的用例（矩阵的大小、矩阵的数量、访问次数……）并相应地修改你的数据结构。 不过，这里有一个简单的实现（在Erlang shell中，我让您适应elixir）：

1>L=[[1,2,3]，[4,5,6]，[1,2,3]]。
[[1,2,3],[4,5,6],[1,2,3]]
2> 获得=乐趣（I，J，L）->
尝试
V=列表：第n（I，列表：第n（J，L）），
{好的，V}
抓住
_：u->{错误，超出_界限}
结束
结束。
#乐趣
3> 得到（1，2，L）。
{好的，4}
4> 得到（2，3，L）。
{好的，2}
5> 得到（2，4，L）。
{错误，超出\u界限}
6> 邻居=乐趣（I，J，L）->
[V |{I1，J1}近邻（1,2，L）。
[1,5,1]
9>

---

备注：我喜欢列表理解，你可能更喜欢使用列表：在这种情况下，这个代码是不有效的，因为它解析4次列表来获取邻居。唯一的优点是它是“直的”。所以它应该是容易阅读的。

< P>有很多方法来解决这个问题，我认为你应该首先考虑你的用例是什么。（矩阵大小、矩阵数量、访问次数…）并相应地调整数据结构

不过，这里有一个简单的实现（在Erlang shell中，我让您适应elixir）：

1>L=[[1,2,3]，[4,5,6]，[1,2,3]]。
[[1,2,3],[4,5,6],[1,2,3]]
2> 获得=乐趣（I，J，L）->
尝试
V=列表：第n（I，列表：第n（J，L）），
{好的，V}
抓住
_：u->{错误，超出_界限}
结束
结束。
#乐趣
3> 得到（1，2，L）。
{好的，4}
4> 得到（2，3，L）。
{好的，2}
5> 得到（2，4，L）。
{错误，超出\u界限}
6> 邻居=乐趣（I，J，L）->
[V |{I1，J1}近邻（1,2，L）。
[1,5,1]
9>

---

备注：我喜欢列表理解，在这种情况下，您可能更喜欢使用lists:map。此代码效率不高，因为它对列表进行4次解析以获得邻居。唯一的优点是它是“直接的”。因此，它应该很容易阅读。

您是否有多个两级深度列表？递归适用于任意深度的列表。此外，请澄清为什么5的邻居是2、4、5和2？如果您想要有效地随机访问2D矩阵，您需要（a）使其不可变（使用元组）或（b）使用每个矩阵元素的一个过程自己构建邻域结构，这对于稀疏矩阵来说是值得的。@denis.peplin我可以有一个100x100矩阵。所谓邻域，我的意思是如果元素是

（I，j）

，那么它的邻域是

（I+1，j）

，

（I-1，j）

（I，j-1）（I，j+1）我给出的示例稍有错误。我的意思是5的邻居是2（I-1，j）、4（I，j-1）、6（I，j+1）和2（I+1，j）。这对你有帮助吗？@GavinBrelstaff我不想随机访问。我想访问邻居。我还研究了元组，因为访问时间会更少。我该怎么做？看看这篇文章，它最终使用了一个tic-tac-toe游戏的地图。你有多个两级深列表吗？递归对列表很有效任意深度。另外，请澄清为什么5的邻居是2,4,5和2？如果你想有效地随机访问2D矩阵，你需要（a）使其不可变（使用元组）或者（b）使用每个矩阵元素的一个过程自己构建邻域结构，这对于稀疏矩阵来说是值得的。@denis.peplin我可以有一个100x100矩阵。所谓邻域，我的意思是如果元素是

（I，j）

，那么它的邻域是

（I+1，j）

，

（I-1，j）

（I，j-1）（I，j+1）我给出的示例稍有错误。我的意思是5的邻居是2（I-1，j）、4（I，j-1）、6（I，j+1）和2（I+1，j）。这对你有帮助吗？@GavinBrelstaff我不想要随机访问。我想要访问邻居。我还查看了元组，因为访问时间将非常少。我该怎么做？看看这篇文章，它最终使用了一个tic tac toe游戏的地图

1> L = [[1,2,3], [4,5,6], [1,2,3]].
[[1,2,3],[4,5,6],[1,2,3]]
2> Get = fun(I,J,L) -> 
            try
               V = lists:nth(I,lists:nth(J,L)),
               {ok,V}
            catch
               _:_ -> {error,out_of_bound}
            end
          end.
#Fun<erl_eval.18.99386804>
3> Get(1,2,L).
{ok,4}
4> Get(2,3,L).
{ok,2}
5> Get(2,4,L).     
{error,out_of_bound}
6> Neighbor = fun(I,J,L) ->
                [ V || {I1,J1} <- [{I,J-1},{I-1,J},{I+1,J},{I,J+1}],
                       {ok,V} <- [Get(I1,J1,L)]
                ]
              end.                 
#Fun<erl_eval.18.99386804>
7> Neighbor(2,2,L).                                                                                            
[2,4,6,2]
8> Neighbor(1,2,L).
[1,5,1]
9>