List 如何在函数中创建scala中的元组列表？

我试图在一个递归函数中创建一个充满元组的列表，这样列表在迭代时会变得更大。我只是不知道如何在scala中实现这一点

def tryToClaimPosition(player: Int, horizontal: Int , vertical: Int , list: List[(Int, Int)]): Unit = {
if (vertical == gridsize - 1) {
  println(list);
}
if (horizontal < gridsize - 1) {
  if (gameBoard(horizontal)(vertical) == player) {
    val tuple = (horizontal,vertical)
    val list2 = list :: tuple
    tryToClaimPosition(player, horizontal + 1, vertical, list2)
  else {
    tryToClaimPosition(player, horizontal + 1, vertical, list)
  }
}

def trytoclamposition（玩家：Int，水平：Int，垂直：Int，列表：list[（Int，Int）]）：单位={
如果（垂直==网格大小-1）{
println（列表）；
}
if（水平<网格大小-1）{
if（游戏板（水平）（垂直）=玩家）{
val tuple=（水平、垂直）
val list2=list:：tuple
trytoclasting（播放器，水平+1，垂直，列表2）
否则{
trytoclasting（玩家，水平+1，垂直，列表）
}
}

---

正如您在上面的代码片段中看到的，我有一个元组列表，我有一个元组，但我无法添加它。

您的代码有许多明显的逻辑和语法错误。与您的问题最相关的是，

List:：tuple

不会编译，因为

：

方法的右侧必须是

列表

---

使用

：：

在

列表中添加而不是附加
您的代码有许多明显的逻辑和语法错误。与您的问题最相关的是，
列表：：元组
不会编译，因为
：
方法的右侧必须是
列表

使用
：：
在
列表
前加，而不是追加。我将使用不可变列表，这将是一个累加器。这将是一种更实用的方式。该函数将没有副作用，并将返回结果
列表
：

def tryToClaimPosition(player: Int, horizontal: Int , vertical: Int , list: List[(Int, Int)]): List[(Int, Int)] = {
  if (vertical == gridsize - 1) {
    list.reverse
  }
  if (horizontal < gridsize - 1) {
    if (gameBoard(horizontal)(vertical) == player) {
      val tuple = (horizontal, vertical)
      tryToClaimPosition(player,horizontal + 1, vertical, tuple::list)
    else {
      tryToClaimPosition(player,horizontal + 1, vertical, list)
    }
  } else Nil
}

def trytoclasting（玩家：Int，水平：Int，垂直：Int，列表：list[（Int，Int）]）：列表[（Int，Int）]={
如果（垂直==网格大小-1）{
倒数
}
if（水平<网格大小-1）{
if（游戏板（水平）（垂直）=玩家）{
val tuple=（水平、垂直）
TryToClamposition（播放器，水平+1，垂直，元组：：列表）
否则{
trytoclasting（玩家，水平+1，垂直，列表）
}
}否则零
}

请注意，我已将元组预先添加到列表中，因为它需要固定的时间（追加与
列表的大小成比例）。这就是我返回
List.reverse
，以便保持原始顺序的原因

我还询问了当
horizontal>gridsize-1
时的情况。您的程序不执行任何操作，因此我假设不应返回任何内容，因此
else
子句中的
Nil
是必需的，因此函数始终返回一个值。
我将使用不可变列表，这将是一个累加器。这将以一种更实用的方式。该函数将不会产生任何副作用，并将返回一个生成的
列表
：

def tryToClaimPosition(player: Int, horizontal: Int , vertical: Int , list: List[(Int, Int)]): List[(Int, Int)] = {
  if (vertical == gridsize - 1) {
    list.reverse
  }
  if (horizontal < gridsize - 1) {
    if (gameBoard(horizontal)(vertical) == player) {
      val tuple = (horizontal, vertical)
      tryToClaimPosition(player,horizontal + 1, vertical, tuple::list)
    else {
      tryToClaimPosition(player,horizontal + 1, vertical, list)
    }
  } else Nil
}

def trytoclasting（玩家：Int，水平：Int，垂直：Int，列表：list[（Int，Int）]）：列表[（Int，Int）]={
如果（垂直==网格大小-1）{
倒数
}
if（水平<网格大小-1）{
if（游戏板（水平）（垂直）=玩家）{
val tuple=（水平、垂直）
TryToClamposition（播放器，水平+1，垂直，元组：：列表）
否则{
trytoclasting（玩家，水平+1，垂直，列表）
}
}否则零
}

请注意，我已将元组预先添加到列表中，因为它需要固定的时间（追加与
列表的大小成比例）。这就是我返回
List.reverse
，以便保持原始顺序的原因

我还询问了当
horizontal>gridsize-1
时的情况。您的程序什么也不做，所以我假设，不应该返回任何东西，因此
else
子句中的
Nil
是必需的。这样，函数总是会返回一个值。
当
horizontal>gridsize-1
时，应该发生什么当
水平>网格大小-1
时发生？