scala - 在 Scala 中生成惰性 "spiral"

Question

任务:
对于二维数组中的给定位置，生成位于半径范围内的周围位置列表。

例如:

input: (1, 1)
radius: 1
output: ( (0, 0), (1, 0), (2, 0), 
          (0, 1),         (2, 1),
          (0, 2), (1, 2), (2, 2) ).

我写了类似的东西

def getPositions(x:Int, y:Int, r:Int) = {
  for(radius <- 1 to r) yield {
    List(
      for (dx <- -radius to radius) yield Pair(x + dx, y - radius),
      for (dx <- -radius to radius) yield Pair(x + dx, y + radius),
      for (dy <- -radius to radius) yield Pair(x + radius, y + dy),
      for (dy <- -radius to radius) yield Pair(x - radius, y + dy)
    )
  }
}

在这段代码中，getPositions 返回的不是点序列，而是点序列的 Tuple4 序列。
如何“连接”代码中列出的 4 个生成器？或者我的任务有更简洁的解决方案吗？ (我对 Scala 很陌生)。

附言
它实际上是为我的星际争霸机器人准备的。

Answer 1

您需要展平列表(两次)，因此可以这样做:

def getPositions(x:Int, y:Int, r:Int) = {
  for(radius <- 1 to r) yield {
    List(
      for (dx <- -radius to radius) yield Pair(x + dx, y - radius),
      for (dx <- -radius to radius) yield Pair(x + dx, y + radius),
      for (dy <- -radius to radius) yield Pair(x + radius, y + dy),
      for (dy <- -radius to radius) yield Pair(x - radius, y + dy)
    ).flatten
  }
}.flatten

不过，这不是一个“懒惰”的螺旋。

编辑

那个很懒:

def P(i:Int, j:Int) = { print("eval"); Pair(i,j) }

def lazyPositions(x:Int, y:Int, r:Int) = {
  (1 to r).toStream.flatMap{ radius =>

    (-radius to radius).toStream.map(dx => P(x + dx, y - radius)) #:::
    (-radius to radius).toStream.map(dx => P(x + dx, y + radius)) #:::
    (-radius to radius).toStream.map(dy => P(x + radius, y + dy)) #:::
    (-radius to radius).toStream.map(dy => P(x - radius, y + dy))
  }
}


print(lazyPositions(1,1,1).take(3).toList) # prints exactly three times ‘eval’.

我用过 def P方法来表现真正的懒惰。每次，您都会创建一个 Pair ，它被调用。在懒惰的解决方案中，您只需要按需。