给定一个Scala序列。。。
val sequence: Seq = List( 3, 1, 4, 1, 5, 9, 2, 6, 5 )
比如说,我想找到所有符合特定标准的子序列,例如奇数串,并用对该子序列进行某种运算的结果来替换这些子序列,比如它的长度,从而产生一个新的序列:
val sequence2: Seq = List( 2, 4, 3, 2, 6, 1 )
(是的,这是一个相当做作的例子,但它很简洁。)
到目前为止,我能做的最好的事情就是这个丑陋的命令式破解:
val sequence: Seq[Int] = List( 3, 1, 4, 1, 5, 9, 2, 6, 5 )
var sequence2 = List[Int]() // this is going to be our result
var subsequence = List[Int]()
for (s <- sequence) {
if (s % 2 == 0) {
if (!subsequence.isEmpty) {
sequence2 = sequence2 :+ subsequence.length
subsequence = List[Int]()
}
sequence2 = sequence2 :+ s
} else {
subsequence = subsequence :+ s
}
}
if (!subsequence.isEmpty) {
sequence2 = sequence2 :+ subsequence.length
}
有没有一种优雅(/实用)的方法可以做到这一点?
使用multiSpan根据给定标准将列表扩展为子列表,考虑上述问题的解决方案,
sequence.multiSpan( _ % 2 == 0 ).flatMap {
case h :: xs if h % 2 != 0 => List( (h::xs).length)
case h :: Nil => List(h)
case h :: xs => List(h, xs.length) }
注意
sequence.multiSpan( _ % 2 == 0 )
List(List(3, 1), List(4, 1, 5, 9), List(2), List(6, 5))
因此,我们通过考虑三种情况来flatMap
这些嵌套列表:条件是否成立,因此我们应用函数;是否为单例列表(条件成立);或者第一个元素是否保持并且其余元素是否需要应用函数。
您要查找的是fold
:
sequence.foldLeft(List(0)) { (soFar, next) =>
if(next % 2 == 0) soFar :+ next :+ 0 else soFar.init :+ (soFar.last + 1)
}.filter(_ != 0)
或者以不同的风格:
(List(0) /: sequence) {
case(soFar, next) if next % 2 == 0 => soFar :+ next :+ 0
case(soFar, _) => soFar.init :+ (soFar.last + 1)
}.filter(_ != 0)
或者使用foldRight
,这有时更具性能:
(sequence : List(0)) {
case(next, soFar) if next % 2 == 0 => 0 :: next :: soFar
case(_, hd::tl) => (hd + 1)::tl
}.filter(_ != 0).reverse
您可以在此处阅读有关fold
、foldLeft
、foldRight
和其他有用函数的更多信息。
我原来以为你在问一个序列的所有子序列。这在类似的情况下可能有用,所以我将把它留在这里。您可以同时使用inits
和tails
来获取所有子序列,然后使用filter
和map
来实现您的目的:
val sequence = List( 3, 1, 4, 1, 5, 9, 2, 6, 5 )
val subsequences = sequence.tails.flatMap(_.inits).toList.distinct
subsequences.filter(_.forall(_ % 2 == 1)).map(_.length)
以下是我对递归实现的尝试
def subSequenceApply(list: List[Int], predicate: (Int)=> Boolean, func: (List[Int]) => Int):List[Int] = list match {
case Nil => Nil
case h :: t if !predicate(h) => h :: subSequenceApply(t, predicate, func)
case _ =>
val (matchSeq,nonMatch) = list.span(predicate)
func(matchSeq) :: subSequenceApply(nonMatch, predicate, func)
}
在你的例子中给定的顺序。你可以将其作为运行
subSequenceApply(sequence, _ % 2 != 0, _.length)