为了解决一些问题,我需要计算pascal三角形的变体,其定义如下:
f(1,1) = 1,
f(n,k) = f(n-1,k-1) + f(n-1,k) + 1 for 1 <= k < n,
f(n,0) = 0,
f(n,n) = 2*f(n-1,n-1) + 1.
对于给定的n,我想有效地得到第n行(f(n,1)... f(n,n)).另一个限制:f(n,k)如果> = 2 ^ 32则应为-1.
我的实施:
next :: [Int64] -> [Int64]
next list@(x:_) = x+1 : takeWhile (/= -1) (nextRec list)
nextRec (a:rest@(b:_)) = boundAdd a b : nextRec rest
nextRec [a] = [boundAdd a a]
boundAdd x y
| x < 0 || y < 0 = -1
| x + y + …我是mef的初学者,所以我有一个问题:)我有以下内容:
[PartCreationPolicy(CreationPolicy.Shared)]
[Export(typeof(SharedExport))]
public class SharedExport : INPCBase
{
[ImportMany(typeof(INonShared),RequiredCreationPolicy = CreationPolicy.NonShared)]
private IEnumerable<Lazy<INonShared,Dictionary<string,object>>> fac;
...
public void Open()
{
foreach (var lazy in fac)
{
this.Muster.Add(lazy.Value);
}
}
导入的所有类都标记为非共享.
[PartCreationPolicy(CreationPolicy.NonShared)]
[Export(typeof(INonShared))]
[ExportMetadata("Muster","030")]
public sealed class NonShared1 : INPCBase, INonShared
{
public NonShared1()
{
Debug.WriteLine("ctor NonShared1" + this.GetHashCode().ToString());
}
#region Implementation of INonShared
public string Displayname
{
get { return "Muster 030 "+ this.GetHashCode().ToString();
}
}
#endregion
}
现在我的问题:当Open()执行时,是否应该始终创建一个新的NonShared1实例？我总是一样的.
module Main where
import Control.Parallel(par,pseq)
import Text.Printf
import Control.Exception
import System.CPUTime
import Data.List
import IO
import Data.Char
import Control.DeepSeq
time :: IO t -> IO t
time a = do
start <- getCPUTime
v <- a
end <- getCPUTime
let diff = (fromIntegral (end - start)) / (10^12)
printf "Computation time: %0.3f sec\n" (diff :: Double)
return v
learquivo :: FilePath -> IO ([[Int]])
learquivo s = do
content <- readFile s
return (read content)
main :: IO ()
main …我正在解析一个长行的文件,其标记是以空格分隔的.在处理大部分行之前,我想检查第n个(小n)令牌是否有一些值.我会跳过大部分线路,所以真的没有必要拆分大部分非常长的线路.有没有快速的方法在Perl中进行懒惰分割,还是需要自己动手？
我有一个简单的程序(这是CCC 2012上的第二个问题),它取一个数字列表,并确定是否有任何严格增加/减少/不变的序列正在进行.例如:
1 2 3 4 7 8 => Increasing
5 1 -2 -100 => Decreasing
9 9 9 9 9 9 => Constant
1 2 3 4 5 0 => Nothing
当我对此进行编码时,我对Haskell的智能程度感到震惊.出于某种原因,当我以交互方式输入数字到stdin时,在我完成之前就给了我答案!我认为这是一个错误,但后来我愚蠢地意识到,Haskell的懒惰(我想？)正在采取独自去决定,之后我进入1,2,3,0,不管以后有什么来了,结果将是Nothing,所以它高兴地输出那个.
不幸的是,当我改变时
let readings = map (read :: (Read a, Num a) => String -> a) $ lines input
至
let readings = parse $ lines input
与parse被读取数字输入一个更安全的方法,实现为
maybeRead :: (Read a) => String …parsing haskell functional-programming input lazy-evaluation
我有一个函数fromRange,它接受一个过滤函数和一个区间,并返回一个集合,其中包含满足过滤函数的区间中的所有元素.
我使用list comprehension实现它:
fromRange :: (Integer->Bool) -> (Integer,Integer) -> [Integer]
fromRange f (x,y) = [i | i<-[x..y], f i]
但是大清单需要很长时间,所以我找到了懒惰的评估概念,但我不知道如何实现它,任何帮助？
我正在尝试在Clojure中编写一个简洁,懒惰的Pascal三角形,旋转使得行/列跟随三角形的对角线.也就是说,我想生成以下lazy-seq的lazy-seq:
((1 1 1 1 ...)
(1 2 3 4 ...)
(1 3 6 10 ...)
...
)
我写的代码是:
(def pascal
(cons (repeat 1)
(lazy-seq
(map #(map + %1 %2)
(map #(cons 0 %) (rest pascal)))
pascal
)))
这样每一行都是通过将自身的右移版本添加到前一行来形成的.问题是它永远不会越过第一行,因为那时(map #(cons 0 %) (rest pascal)))是空的.
=> (take 5 (map #(take 5 %) pascal))
((1 1 1 1 1))
什么是解决这个问题的合理方法？我对Clojure中的编程很新,并且考虑到它涉及的问题的方式非常不同,所以我非常感谢任何有这方面经验的人的建议.
我正在尝试执行懒惰的评估.
我创建了一个lazy list类型和相应的map功能.
type 'a zlist = 'a node_t lazy_t
and 'a node_t = Empty | Node of 'a * 'a zlist
let rec zlist_of_list l = lazy (
match l with
| [] -> Empty
| hd::tl -> Printf.printf "transforming %d\n" hd;Node (hd, zlist_of_list tl)
)
let rec list_of_zlist zl =
match Lazy.force zl with
| Empty -> []
| Node (hd, tl) -> hd::(list_of_zlist tl)
let rec map_z f zl = lazy (
match …当我在cghi中尝试以下代码时:
take 1 $ take 1 $ repeat [1..]
我期待结果1而不是[[1,2,3,4,5,6,7,8,9,10,...在我的终端上打印.
为什么懒惰的评价不起作用,因为我希望在这种情况下？
在Haskell中,我试图理解严格的概念.我明白那个
const x y = x
第一个参数是严格的,但第二个参数不是.但是
ifFun pred cons alt = if pred then cons else alt
严格？第一个论点是严格的.我理解cons和alt的评估取决于pred的值.这是否意味着函数对这些参数不严格？