- html - 出于某种原因,IE8 对我的 Sass 文件中继承的 html5 CSS 不友好?
- JMeter 在响应断言中使用 span 标签的问题
- html - 在 :hover and :active? 上具有不同效果的 CSS 动画
- html - 相对于居中的 html 内容固定的 CSS 重复背景?
以下代码来自 Pathikrit's Dynamic Programming存储库。
我对它的美丽和独特性感到困惑。
def subsetSum(s: List[Int], t: Int) = {
type DP = Memo[(List[Int], Int), (Int, Int), Seq[Seq[Int]]]
implicit def encode(key: (List[Int], Int)) = (key._1.length, key._2)
lazy val f: DP = Memo {
case (Nil, 0) => Seq(Nil)
case (Nil, _) => Nil
case (a :: as, x) => (f(as, x - a) map {_ :+ a}) ++ f(as, x)
}
f(s, t)
}
Memo
在另一个文件中实现:
case class Memo[I <% K, K, O](f: I => O) extends (I => O) {
import collection.mutable.{Map => Dict}
val cache = Dict.empty[K, O]
override def apply(x: I) = cache getOrElseUpdate (x, f(x))
}
type K
声明为 (Int, Int)
在子集总和中? int
有什么用在 (Int, Int)
分别代表? (List[Int], Int)
隐式转换为
(Int, Int)
?
implicit def foo(x:(List[Int],Int)) = (x._1.toInt,x._2)
. (甚至在它导入的
Implicits.scala
文件中也不行。
implicit def encode(key: (List[Int], Int)) = (key._1.length, key._2)
最佳答案
我是 above code 的作者.
/**
* Generic way to create memoized functions (even recursive and multiple-arg ones)
*
* @param f the function to memoize
* @tparam I input to f
* @tparam K the keys we should use in cache instead of I
* @tparam O output of f
*/
case class Memo[I <% K, K, O](f: I => O) extends (I => O) {
import collection.mutable.{Map => Dict}
type Input = I
type Key = K
type Output = O
val cache = Dict.empty[K, O]
override def apply(x: I) = cache getOrElseUpdate (x, f(x))
}
object Memo {
/**
* Type of a simple memoized function e.g. when I = K
*/
type ==>[I, O] = Memo[I, I, O]
}
Memo[I <% K, K, O]
:
I: input
K: key to lookup in cache
O: output
I <% K
表示
K
可以
viewable (即隐式转换)来自
I
.
I
应该是
K
例如如果您正在写信
fibonacci
这是
Int => Int
类型的函数,可以通过
Int
缓存本身。
I
)来内存或缓存,而是希望根据输入(
K
)进行内存或缓存,例如在编写
subsetSum
时输入类型为
(List[Int], Int)
的算法,您不想使用
List[Int]
作为缓存中的键,但您想要使用
List[Int].size
作为缓存中键的一部分。
/**
* Subset sum algorithm - can we achieve sum t using elements from s?
* O(s.map(abs).sum * s.length)
*
* @param s set of integers
* @param t target
* @return true iff there exists a subset of s that sums to t
*/
def isSubsetSumAchievable(s: List[Int], t: Int): Boolean = {
type I = (List[Int], Int) // input type
type K = (Int, Int) // cache key i.e. (list.size, int)
type O = Boolean // output type
type DP = Memo[I, K, O]
// encode the input as a key in the cache i.e. make K implicitly convertible from I
implicit def encode(input: DP#Input): DP#Key = (input._1.length, input._2)
lazy val f: DP = Memo {
case (Nil, x) => x == 0 // an empty sequence can only achieve a sum of zero
case (a :: as, x) => f(as, x - a) || f(as, x) // try with/without a.head
}
f(s, t)
}
type DP = Memo[(List[Int], Int), (Int, Int), Boolean]
I = K
时),您可以简单地执行以下操作:
type ==>[I, O] = Memo[I, I, O]
并像这样使用它到
calculate the binomial coeff递归内存:
/**
* http://mathworld.wolfram.com/Combination.html
* @return memoized function to calculate C(n,r)
*/
val c: (Int, Int) ==> BigInt = Memo {
case (_, 0) => 1
case (n, r) if r > n/2 => c(n, n - r)
case (n, r) => c(n - 1, r - 1) + c(n - 1, r)
}
(Seq, Seq)
的两个参数进行编码至
(Seq.length, Seq.length)
:
/**
* Calculate edit distance between 2 sequences
* O(s1.length * s2.length)
*
* @return Minimum cost to convert s1 into s2 using delete, insert and replace operations
*/
def editDistance[A](s1: Seq[A], s2: Seq[A]) = {
type DP = Memo[(Seq[A], Seq[A]), (Int, Int), Int]
implicit def encode(key: DP#Input): DP#Key = (key._1.length, key._2.length)
lazy val f: DP = Memo {
case (a, Nil) => a.length
case (Nil, b) => b.length
case (a :: as, b :: bs) if a == b => f(as, bs)
case (a, b) => 1 + (f(a, b.tail) min f(a.tail, b) min f(a.tail, b.tail))
}
f(s1, s2)
}
lazy val fib: Int ==> BigInt = Memo {
case 0 => 0
case 1 => 1
case n if n > 1 => fib(n-1) + fib(n-2)
}
println(fib(100))
关于Scala 内存 : How does this Scala memo work?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/25129721/
我有一些 Scala 代码,它用两个不同版本的类型参数化函数做了一些漂亮的事情。我已经从我的应用程序中简化了很多,但最后我的代码充满了形式 w(f[Int],f[Double]) 的调用。哪里w()是
如果我在同一目录中有两个单独的未编译的 scala 文件: // hello.scala object hello { def world() = println("hello world") }
val schema = df.schema val x = df.flatMap(r => (0 until schema.length).map { idx => ((idx, r.g
环境: Play 2.3.0/Scala 2.11.1/IntelliJ 13.1 我使用 Typesafe Activator 1.2.1 用 Scala 2.11.1 创建一个新项目。项目创建好后
我只是想知道如何使用我自己的类扩展 Scala 控制台和“脚本”运行程序,以便我可以通过使用实际的 Scala 语言与其通信来实际使用我的代码?我应将 jar 放在哪里,以便无需临时配置即可从每个 S
我已经根据 README.md 文件安装了 ensime,但是,我在低级 ensime-server 缓冲区中出现以下错误: 信息: fatal error :scala.tools.nsc.Miss
我正在阅读《Scala 编程》一书。在书中,它说“一个函数文字被编译成一个类,当在运行时实例化时它是一个函数值”。并且它提到“函数值是对象,因此您可以根据需要将它们存储在变量中”。 所以我尝试检查函数
我有 hello world scala native 应用程序,想对此应用程序运行小型 scala 测试我使用通常的测试命令,但它抛出异常: NativeMain.scala object Nati
有few resources在网络上,在编写与代码模式匹配的 Scala 编译器插件方面很有指导意义,但这些对生成代码(构建符号树)没有帮助。我应该从哪里开始弄清楚如何做到这一点? (如果有比手动构建
我是 Scala 的新手。但是,我用 创建了一个中等大小的程序。斯卡拉 2.9.0 .现在我想使用一个仅适用于 的开源库斯卡拉 2.7.7 . 是吗可能 在我的 Scala 2.9.0 程序中使用这个
有没有办法在 Scala 2.11 中使用 scala-pickling? 我在 sonatype 存储库中尝试了唯一的 scala-pickling_2.11 工件,但它似乎不起作用。我收到消息:
这与命令行编译器选项无关。如何以编程方式获取代码内的 Scala 版本? 或者,Eclipse Scala 插件 v2 在哪里存储 scalac 的路径? 最佳答案 这无需访问 scala-compi
我正在阅读《Scala 编程》一书,并在第 6 章中的类 Rational 实现中遇到了一些问题。 这是我的 Rational 类的初始版本(基于本书) class Rational(numerato
我是 Scala 新手,我正在尝试开发一个使用自定义库的小项目。我在库内创建了一个mysql连接池。这是我的库的build.sbt organization := "com.learn" name :
我正在尝试运行一些 Scala 代码,只是暂时打印出“Hello”,但我希望在 SBT 项目中编译 Scala 代码之前运行 Scala 代码。我发现在 build.sbt 中有以下工作。 compi
Here链接到 maven Scala 插件使用。但没有提到它使用的究竟是什么 Scala 版本。我创建了具有以下配置的 Maven Scala 项目: org.scala-tools
我对 Scala 还很陌生,请多多包涵。我有一堆包裹在一个大数组中的 future 。 future 已经完成了查看几 TB 数据的辛勤工作,在我的应用程序结束时,我想总结上述 future 的所有结
我有一个 scala 宏,它依赖于通过包含其位置的静态字符串指定的任意 xml 文件。 def myMacro(path: String) = macro myMacroImpl def myMacr
这是我的功能: def sumOfSquaresOfOdd(in: Seq[Int]): Int = { in.filter(_%2==1).map(_*_).reduce(_+_) } 为什么我
这个问题在这里已经有了答案: Calculating the difference between two Java date instances (45 个答案) 关闭 5 年前。 所以我有一个这
我是一名优秀的程序员,十分优秀!