小编per*_*i4n的帖子

我正在学习斯卡拉,作为一名优秀的学生,我试图遵守我发现的所有规则.

一条规则是:不可靠性!

所以我试图使用不可变数据结构和val来编写所有代码,有时候这很难.

但今天我想到了自己:唯一重要的是对象/类应该没有可变状态.我不是被迫以不可变的样式编写所有方法,因为这些方法不会相互影响.

我的问题:我是否正确或有任何问题/缺点我看不到？

编辑:

aishwarya的代码示例:

def logLikelihood(seq: Iterator[T]): Double = {
  val sequence = seq.toList
  val stateSequence = (0 to order).toList.padTo(sequence.length,order)
  val seqPos = sequence.zipWithIndex

  def probOfSymbAtPos(symb: T, pos: Int) : Double = {
    val state = states(stateSequence(pos))
    M.log(state( seqPos.map( _._1 ).slice(0, pos).takeRight(order), symb))
  }

  val probs = seqPos.map( i => probOfSymbAtPos(i._1,i._2) )

  probs.sum
}  

说明:这是一种计算变量阶齐次马尔可夫模型的对数似然的方法.state的apply方法获取所有先前的符号和即将到来的符号,并返回这样做的概率.

正如您所看到的:整个方法只是增加了一些使用变量更容易的概率.

我想将scala的值类应用于我的一个项目,因为它们使我能够丰富某些原始类型而没有很大的开销(我希望)并保持类型安全.

object Position {

  implicit class Pos( val i: Int ) extends AnyVal with Ordered[Pos] {

    def +( p: Pos ): Pos = i + p.i

    def -( p: Pos ): Pos = if ( i - p.i < 0 ) 0 else i - p.i

    def compare( p: Pos ): Int = i - p.i

  }
}

我的问题:每当我使用它们时,继承Ordered强制Pos对象的分配(从而引入很大的开销)吗？如果是这样的话:有没有办法绕过这个？

我正在寻找scala方式来给出所有排列而不重复.我知道这个网站上已有一些帖子,但它们似乎有一个稍微不同的问题.

我正在寻找重复的所有排列.例如:

combine(List('A','C','G'))

应该产量:

List(List('A'.'A','A'),List('A'.'A','C'),List('A'.'A','G'),List('A'.'C','A'),
List('A'.'C',''C), ... List('G'.'G','G')

如果我的问题已经解决但我无法找到,我很抱歉.

提前致谢.

编辑:

我自己的方法(不编译):

def combine(size: Int = sym.length) : List[List[T]] = {
  size match {
    case 0 => List()
    case 1 => sym.toList.map(List(_))
    case _ => for (el <- sym) yield el :: combine(size-1)
  }
}

sym是一个类的数组成员,它包含要组合的所有符号.

我尝试使用 EMR 工件存储库将emrfs-hadoop- assembly及其依赖项打包到我的应用程序中。

我找到的资源告诉我必须使用的 Maven 存储库的 URL，但没有告诉我该存储库中的实际工件。EMR 版本中包含的组件版本是公开可用的，但我必须猜测所有非标准依赖项（例如 hadoop-common）的artifactId和groupId 。该存储库适用于后缀为 的依赖项amzn，但我仍然无法下载相关的 jar。

谁能提供有关如何使用这个 Maven 存储库的信息？

编辑：

我查看了我想通过 Maven/Gradle 获取的 jar 的pom.xml并获取了artifactId和groupId，但构建工具无法解析这些内容。

我给了一组大小为L,并希望生成大小为k的每个已排序子集.如果您的解决方案是scala但是我可以自己翻译,那将会很棒.

应该产生L = 6和k = 3的示例运行.

1,2,3
1,2,4
1,2,5
1,2,6
1,3,4
1,3,5
1,3,6
1,4,5
1,4,6
1,5,6
2,3,4
2,3,5
2,3,6
2,4,5
2,4,6
2,5,6
3,4,5
3,4,6
3,5,6
4,5,6

我的scala尝试类似于:

object Util {
  def main(args : Array[String]) : Unit = {
    starts(6,3,1)
  }

  def starts(L: Int, num: Int, level: Int) : List[List[Int]] = {
    if( num == 0 ) {
      return List()
    }else{
      (level to (L-num+1)).map( o => o :: starts(L,num-1,level+1))
    }
  }
}

我希望你能帮助我.

我只想用grep和-f FILE选项.这应该使grep使用FILE的每一行作为模式并搜索它.

跑:

grep -f patternfile searchfile

我使用的模式文件大400MB.我要搜索的文件是7GB.3分钟后,该过程最终得到70GB RAM并且没有反应.

这是正常的吗？难道我做错了什么？grep没有能力是如此大规模？

谢谢你的想法.

我正在寻找一种方法来编写一个函数,该函数应用提供的函数并将参数和函数结果包装在元组中.如:

applyZip :: (a -> b) -> a -> (a,b)
applyZip f x = (x, f x)

是否有更惯用的方法在Haskell中编写它,最好是使用库代码？

编辑:我真的对其他解决方法感兴趣.如果您发现自己遇到同样的问题,那么使用描述性名称自行实现该功能可能更为可取.

可能重复:
在Scala中,如何折叠List并返回中间结果？

我正在寻找一种以下列方式累积SortedTree元素的功能方法:

我想要一个列表,其中包含SortedTree中所有元素的所有前体(包括元素本身)的总和.

对于Exmaple:

SortedTree包含(0.4,0.3,0.2,0.1,0.05)

我想要的清单:(0,4.7.7,0.9,1,1.05)

有什么建议？