質問
タスク: 2D配列内の指定された位置の半径に位置周囲の位置のリストを生成します。
例えば、
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戻り値はない点のsequanceが、点のsequancesのTuple4のsequance。 どのように私は、「CONCATENATE」4つの発電機は、コードに記載されていることができますか?それとも、私の仕事のためのより簡潔な解決策はありますか? (私はスカラ座にかなり新しいです)。
P.S。 それは私のスタークラフトボットのために実際にいます。
解決
あなたは、リストを(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)
).flatten
}
}.flatten
これはしかし、「怠惰」スパイラルではありません。
編集
その1は怠け者です。
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
を作成したい、それが呼び出されます。怠惰なソリューションでは、あなただけの需要にこれをしたいと思います。
他のヒント
これを試してみてください
object Spiral
{
def
getPositions(x: Int, y: Int, r: Int): Seq[(Int, Int)] = {
for { radius <- 1 to r
dx <- -radius to radius
dy <- -radius to radius
if dx != 0 || dy != 0
} yield
(x + dx, y + dy)
}
def
main(args: Array[String]): Unit = {
printf("getPositions(1, 1, 1): %s%n", getPositions(0, 0, 1).mkString("{ ", ", ", " }"))
}
}
出力:
getPositions(1, 1, 1): { (-1,-1), (-1,0), (-1,1), (0,-1), (0,1), (1,-1), (1,0), (1,1) }
あなたが直接あなたの範囲を形成することができ、それらが作られているとして使用flatMap
と++
が一緒にリストに参加すると、あなたはまた、円形の方向に行くのが好きかもしれません。
def getPositions(x: Int, y: Int, r: Int) = {
(1 to r) flatMap (radius => {
val dx = -radius to radius
val dy = -(radius-1) to (radius-1)
dx.map(i => (x+i, y+radius)) ++ dy.map(i => (x+radius, y-i)) ++
dx.map(i => (x-i, y-radius)) ++ dy.map(i => (x-radius, y+i))
})
}
あなたは本当に結果が怠惰になりたい場合は、あなたが怠惰なコンポーネントと同じことを行う必要があります:
def getPositions(x: Int, y: Int, r: Int) = {
Stream.range(1,r+1) flatMap (radius => {
val dx = Stream.range(-radius,radius+1)
val dy = Stream.range(-(radius+1),radius)
dx.map(i => (x+i, y+radius)) ++ dy.map(i => (x+radius, y-i)) ++
dx.map(i => (x-i, y-radius)) ++ dy.map(i => (x-radius, y+i))
})
}
編集:固定DX対DYタイポ
ここでは、この問題に対するいくつかのソリューションです。まず、あなたは、オーダーのためだけの位置を気にしないならば、これが行います。
def getPositions(x:Int, y:Int, r:Int) = for {
yr <- y - r to y + r
xr <- x - r to x + r
if xr != x || yr != y
} yield (xr, yr)
それはあなたが指定したまったく同じ出力が得られます。しかし、あなたはPythonのスタイルの発電をしたいので、これは、より適切であろう。
def getPositions(x:Int, y:Int, r:Int) = Iterator.range(y - r, y + r + 1) flatMap {
yr => Iterator.range(x - r, x + r + 1) map {
xr => (xr, yr)
}
} filter (_ != (x, y))
それはあなたがIterator
を使用して繰り返し処理できるnext
を返します。 hasNext
を使用して終了を確認します。
あなたはそのようなIterator
またはList
またはスタッフとのStream
を交換し、完全に生成されたコレクションを得ることができます。
さて、聞かせてのは、あなたが中央にらせん状の出発をしたいと仮定し、一度に一つの位置を移動させます。私たちはこのようなものでそれを行うことができます:
def getPositions(x:Int, y:Int, r:Int) = new Iterator[(Int, Int)] {
private var currentX = x
private var currentY = y
private var currentR = 1
private var incX = 0
private var incY = 1
def next = {
currentX += incX
currentY += incY
val UpperLeft = (x - currentR, y + currentR)
val UpperRight = (x + currentR, y + currentR)
val LowerLeft = (x - currentR, y - currentR)
val LowerRight = (x + currentR, y - currentR)
val PrevSpiral = (x, y + currentR)
val NextSpiral = (x - 1, y + currentR)
(currentX, currentY) match {
case NextSpiral => incX = 1; incY = 1; currentR += 1
case PrevSpiral => incX = 1; incY = 0
case UpperLeft => incX = 1; incY = 0
case UpperRight => incX = 0; incY = -1
case LowerRight => incX = -1; incY = 0
case LowerLeft => incX = 0; incY = 1
case _ =>
}
if (currentR > r)
throw new NoSuchElementException("next on empty iterator")
(currentX, currentY)
}
def hasNext = currentR <= r
}
ここでエッジの周りを歩くストリームだ。
入力(3,3)と仮定すると、2
与えます{(1,1), (2,1), (3,1), (4,1), (5,1),
(1,2), (5,2),
(1,3), (5,3),
(1,4), (5,4),
(1,5), (2,5), (3,5), (4,5), (5,5)}
あなたは以下を使用することができます:
def border(p: (Int,Int), r: Int) = {
val X1 = p._1 - r
val X2 = p._1 + r
val Y1 = p._2 - r
val Y2 = p._2 + r
def stream(currentPoint: (Int,Int)): Stream[(Int,Int)] = {
val nextPoint = currentPoint match {
case (X1, Y1) => (X1+1, Y1)
case (X2, Y2) => (X2-1, Y2)
case (X1, Y2) => (X1, Y2-1)
case (X2, Y1) => (X2, Y1+1)
case (x, Y1) => (x+1, Y1)
case (x, Y2) => (x-1, Y2)
case (X1, y) => (X1, y-1)
case (X2, y) => (X2, y+1)
}
Stream.cons(nextPoint, if (nextPoint == (X1,Y1)) Stream.empty else stream(nextPoint))
}
stream((X1,Y1))
}
使用方法:
scala> val b = border((3,3),2)
b: Stream[(Int, Int)] = Stream((2,1), ?)
scala> b.toList
res24: List[(Int, Int)] = List((2,1), (3,1), (4,1), (5,1), (5,2), (5,3), (5,4), (5,5), (4,5), (3,5), (2,5), (1,5), (1,4), (1,3), (1,2), (1,1))