在scala中创建重复的真/假列表

我想生成一个包含真/假值的Seq/列表，我可以通过一些输入压缩这些值，这样就相当于检查for循环索引是否为奇数/偶数

还有比这更好的方法吗

input.zip((1 to n).map(_ % 2 == 0))

或

---

我会想到类似于

（对，错）。重复（n/2）

更为明显

我想不出任何更简单的方法（这远不是简单的）：

注意奇数

n

但是，根据您的需求，您可能希望有一些懒惰的东西：

…而且它永远不会结束（请尝试：

oddEven（true）foreach println

）。现在，您可以随心所欲：

oddEven(true).take(10).toList

---

我想不出任何更简单的方法（这一点也不简单）：

注意奇数

n

但是，根据您的需求，您可能希望有一些懒惰的东西：

…而且它永远不会结束（请尝试：

oddEven（true）foreach println

）。现在，您可以随心所欲：

oddEven(true).take(10).toList

---

如果需要大小为n的交替真/假列表：

List.iterate(false, n)(!_)

那么你可以做：

val input = List("a", "b", "c", "d")
input.zip(List.iterate(false, input.length)(!_))
//List[(java.lang.String, Boolean)] = List((a,false), (b,true), (c,false), (d,true))

---

如果需要大小为n的交替真/假列表：

List.iterate(false, n)(!_)

那么你可以做：

val input = List("a", "b", "c", "d")
input.zip(List.iterate(false, input.length)(!_))
//List[(java.lang.String, Boolean)] = List((a,false), (b,true), (c,false), (d,true))

使用：

或者，如果您在多个地方使用此模式：

def falseTrueStream = Stream.iterate(false)(!_)

input.zip(falseTrueStream)

这有一个明显的优点，即不需要指定假-真列表的大小

编辑：

当然，

def false-truestream

每次使用时都会创建

true

/

false

对象流，因此，将其设置为

val

将导致对象保留在内存中（如果

val

位于

对象上，则程序结束）

如果你有点邪恶，想过早地优化它，你可以自己构建
流
对象

object TrueFalseStream extends Stream[Boolean] {
  val tailDefined = true

  override val isEmpty = false

  override val head = true

  override val tail = FalseTrueStream
}

object FalseTrueStream extends Stream[Boolean] {
  val tailDefined = true

  override val isEmpty = false

  override val head = false

  override val tail = TrueFalseStream
}

使用：

或者，如果您在多个地方使用此模式：

def falseTrueStream = Stream.iterate(false)(!_)

input.zip(falseTrueStream)

这有一个明显的优点，即不需要指定假-真列表的大小

编辑：

当然，
def false-truestream
每次使用时都会创建
true
/
false
对象流，因此，将其设置为
val
将导致对象保留在内存中（如果
val
位于
对象上，则程序结束）

如果你有点邪恶，想过早地优化它，你可以自己构建
流
对象

object TrueFalseStream extends Stream[Boolean] {
  val tailDefined = true

  override val isEmpty = false

  override val head = true

  override val tail = FalseTrueStream
}

object FalseTrueStream extends Stream[Boolean] {
  val tailDefined = true

  override val isEmpty = false

  override val head = false

  override val tail = TrueFalseStream
}

…以执行检查for循环索引是否为奇数/偶数的等效操作

我忽略了你的具体要求，并以不同的方式解决了你的主要问题。
您可以制作自己的控制功能，如下所示：

def for2[A,B](xs: List[A])(f: A => Unit, g: A => Unit): Unit = xs match {
    case (y :: ys) => {
      f(y)
      for2(ys)(g, f)
    }
    case _ => Unit
}

测试

> for2(List(0,1,2,3,4,5))((x) => println("E: " + x), (x) => println("O: " + x))
E: 0
O: 1
E: 2
O: 3
E: 4
O: 5

…以执行检查for循环索引是否为奇数/偶数的等效操作

我忽略了你的具体要求，并以不同的方式解决了你的主要问题。
您可以制作自己的控制功能，如下所示：

def for2[A,B](xs: List[A])(f: A => Unit, g: A => Unit): Unit = xs match {
    case (y :: ys) => {
      f(y)
      for2(ys)(g, f)
    }
    case _ => Unit
}

测试

> for2(List(0,1,2,3,4,5))((x) => println("E: " + x), (x) => println("O: " + x))
E: 0
O: 1
E: 2
O: 3
E: 4
O: 5

你想要

input.indices.map(_%2==0)

你想要

input.indices.map(_%2==0)

Haskell中有一个非常有用的函数-
cycle
，用于以下目的：

haskell> zip [1..7] $ cycle [True, False]
[(1,True),(2,False),(3,True),(4,False),(5,True),(6,False),(7,True)]

出于某种原因，Scala标准库没有它。您可以自己定义它，然后使用它

scala> def cycle[A](s: Stream[A]): Stream[A] = Stream.continually(s).flatten
cycle: [A](s: Stream[A])Stream[A]

scala> (1 to 7) zip cycle(Stream(true, false))
res13: scala.collection.immutable.IndexedSeq[(Int, Boolean)] = Vector((1,true), (2,false), (3,true), (4,false), (5,true), (6,false), (7,true))

Haskell中有一个非常有用的函数-
cycle
，用于以下目的：

haskell> zip [1..7] $ cycle [True, False]
[(1,True),(2,False),(3,True),(4,False),(5,True),(6,False),(7,True)]

出于某种原因，Scala标准库没有它。您可以自己定义它，然后使用它

scala> def cycle[A](s: Stream[A]): Stream[A] = Stream.continually(s).flatten
cycle: [A](s: Stream[A])Stream[A]

scala> (1 to 7) zip cycle(Stream(true, false))
res13: scala.collection.immutable.IndexedSeq[(Int, Boolean)] = Vector((1,true), (2,false), (3,true), (4,false), (5,true), (6,false), (7,true))

（真，假）。重复（n/2）
对我来说是个麻烦：如果
n
是奇数，你会在结尾缺少一个元素。
（真，假）。重复（n/2）
对我来说是个麻烦：如果
n
是奇数，你会在结尾缺少一个元素。很好。我不知道List有一个迭代方法，所以我打算建议使用Stream.iterate（false）（！）。拿（n）.toList开个玩笑。@Davegrifith实际上，
Stream.iterate
不是个坏主意。很好。我不知道List有一个迭代方法，所以我打算建议使用Stream.iterate（false）（！）.take（n）.toList作为一个笑话。@Davegrifith实际上，
Stream.iterate
并不是一个坏主意。请用
def falseturestream
代替
val
，否则可能会出现内存泄漏。请，
def false truestream
而不是
val
，否则您可能会出现内存泄漏。请注意，这种方法（
Stream.continuously（…）.flatten
）会产生一个具有无限潜在空间消耗的重复列表，而不是适合恒定空间的循环列表。请注意，这种方法（
Stream.continuously（…）.flatten
）生成具有无限潜在空间消耗的重复列表，而不是在恒定空间中拟合的循环列表。