例如,对于元素a,b,c,d,有5种可能的方法来获取相邻元素并将它们简化为单个元素,其中一次必须组合两个元素(下面用括号表示):
(((ab)c)d), ((a(bc))d), ((ab)(cd)), (a((bc)d)) and (a(b(cd)))
第一个示例相乘a*b,然后将该乘积乘以,然后将该乘积c乘以d.第二个示例首先相乘b*c,然后将该乘积乘以,然后将该乘积a乘以d.
2n个元素的任何有效的括号表达式也会一定ñ (和n )与,从左至右,有至少许多人总是财产(作为).
我知道对于n个数字,方式的数量是第(n-1)个加泰罗尼亚数字.但是,如何准确地生成所有结果分组？
谢谢
(顺便说一句:这个问题有超过160个等效公式,都是基于加泰罗尼亚数字列举的不同组合对象.有关这些问题的最新列表,请参阅Richard Stanley的加泰罗尼亚语附录.)
这是场景:
E:\<directories>\fsharp-tapl\arith从fsx文件向F#Interactive发送命令
> System.Environment.CurrentDirectory;;
val it : string = "C:\Users\Eric\AppData\Local\Temp"
我没想到Temp目录,但它有意义.
> #r @"arith.exe"
Examples.fsx(7,1): error FS0082: Could not resolve this reference.
Could not locate the assembly "arith.exe".
Check to make sure the assembly exists on disk.
If this reference is required by your code, you may get compilation errors.
(Code=MSB3245)
Examples.fsx(7,1): error FS0084: Assembly reference 'arith.exe' was not found
or is invalid
#r命令错误显示F#Interactive当前不知道arith.exe的位置.
> #I @"bin\Debug"
--> Added 'E:\<directories>\fsharp-tapl\arith\bin\Debug'
to library …在线整数序列百科全书支持搜索包含您的查询作为子序列的序列,例如.搜索subseq:212,364,420,428将返回8*n+4序列.(http://oeis.org/search?q=subseq:212,364,420,428)
这个惊人的功能显然是由Russ Cox实现的http://oeis.org/wiki/User:Russ_Cox/OEIS_Server_Features实现的,但是没有用它实现的算法来指定.
我想知道它是如何完成的.对于搜索引擎来说,每次搜索显然要经过近一百万个序列是不切实际的.只保留一个索引(这是同一个Russ Cox对谷歌代码正则表达式搜索的方式)的第一个数字和暴力强迫其余的也不起作用,因为数字0几乎在所有序列中.实际上,一些查询0 1匹配总数据库的高百分比,因此算法需要对所需输出大小敏感的运行时间.
有谁碰巧知道这个功能是如何实现的？
新的F#开发人员,长期以来的C#开发人员.作为学习F#的练习,我正在通过Eric Lippert关于图形着色的系列工作,从C#转换为F#.我目前正在做第二部分.
最初的C#在博文中 - 这是迄今为止的F#翻译 - 但是它没有编译:
type BitSet = struct
val bits : int
private new(b) = { bits = b }
static member Empty = BitSet(0)
member this.Contains (item:int) = (this.bits &&& (1<<< item)) <> 0
member this.Add (item:int) = BitSet(this.bits ||| (1 <<< item))
member this.Remove (item:int) = BitSet(this.bits &&& ~~~(1<<<item))
member this.Bits = seq {
for item in 0..31 do
if this.Contains(item) then
yield item
}
end
这会产生非常神秘的错误"错误FS0406:byref-typed变量'this'以无效方式使用.Byrefs不能被闭包捕获或传递给内部函数"来自Bits:seq <int>的定义.
奇怪的是,将关键字"struct"更改为"class"会产生有效的代码.从C#的角度来看,这似乎是胡说八道,但我确信它背后有一个合理的原因.现在的问题是-如何应我写的位功能？为理解这一点,我需要理解的基本F#原则是什么？
我想了解阴影和嵌套函数的机制是如何工作的.例如:
let func y =
let dup y = y + y
let z = dup y
let dup y =
let dup z =
let y = y * z
y
let z = y
y
dup z + z;;
val func : int -> int
> func 3;;
val it : int = 12
有人可以解释这里发生了什么吗
在ML系列语言中,人们倾向于选择模式匹配来if/else构建.在F#中,在模式匹配中使用防护装置if/else在很多情况下很容易替换.
例如,delete1可以在不使用if/else(参见delete2)的情况下重写一个简单的函数:
let rec delete1 (a, xs) =
match xs with
| [] -> []
| x::xs' -> if x = a then xs' else x::delete1(a, xs')
let rec delete2 (a, xs) =
match xs with
| [] -> []
| x::xs' when x = a -> xs'
| x::xs' -> x::delete2(a, xs')
另一个例子是求解二次函数:
type Solution =
| NoRoot
| OneRoot of float
| TwoRoots of float * float
let …我知道F#中的变量默认是不可变的.但是,例如在F#interactive中:
> let x = 4;;
val x : int = 4
> let x = 5;;
val x : int = 5
> x;;
val it : int = 5
>
所以,我将4分配给x,然后将5分配给x并且它正在改变.这是对的吗？它应该给出一些错误或警告吗？或者我只是不明白它是如何工作的？
一般来说,foldl避免赞成foldl'或foldr.引用真实世界Haskell:
由于foldl的thunking行为,在实际程序中避免这种功能是明智的:即使它没有完全失败,也会不必要地低效.相反,导入Data.List并使用foldl'.
然而,一些Prelude函数是根据它来定义的(例如(\\)和unionBy).为什么是这样？是不是对这些功能引入了太多的严格要求？
我一直在谷歌搜索多年,仍然找不到答案.根据我的理解,如果调用者在try/catch和/或try/finally块中包装了调用,那么在.NET 4.5上运行的F#3.0将不会对递归方法使用尾递归.如果有一个try/catch或者try/finally几个级别的堆栈会是什么情况？
我花了一半时间试图弄清楚如何使用EitherT作为处理代码中错误的方法.
我已经定义了这样的变压器堆栈.
-- Stuff Monad
data StuffConfig = StuffConfig {
appId :: T.Text,
appSecret :: T.Text
}
data StuffState = StuffState {
stateToken :: Maybe Token,
stateTime :: POSIXTime
}
newtype Stuff a = Stuff {
runStuff :: (ReaderT StuffConfig (StateT StuffState (EitherT T.Text IO))) a
} deriving (Monad, Functor, Applicative,
MonadIO,
MonadReader StuffConfig,
MonadState StuffState
)
askStuff :: StuffConfig -> Stuff a -> IO (Either T.Text a)
askStuff config a = do
t <- getPOSIXTime
runEitherT (evalStateT (runReaderT (runStuff …