Haskell版本(1.03s):
module Main where
import qualified Data.Text as T
import qualified Data.Text.IO as TIO
import Control.Monad
import Control.Applicative ((<$>))
import Data.Vector.Unboxed (Vector,(!))
import qualified Data.Vector.Unboxed as V
solve :: Vector Int -> Int
solve ar =
V.foldl' go 0 ar' where
ar' = V.zip ar (V.postscanr' max 0 ar)
go sr (p,m) = sr + m - p
main = do
t <- fmap (read . T.unpack) TIO.getLine -- With Data.Text, the example finishes 15% faster.
T.unlines . map (T.pack …我正在玩Atom,我真的很喜欢如何选择一个表达式并按下Shift+9以插入(并)在其外部.这对Haskell很方便,我希望F#也一样.这有什么捷径吗？
type CudaInnerExpr<'t> = CudaInnerExpr of expr: string with
member t.Expr = t |> fun (CudaInnerExpr expr) -> expr
type CudaScalar<'t> = CudaScalar of name: string with
member t.Name = t |> fun (CudaScalar name) -> name
type CudaAr1D<'t> = CudaAr1D of CudaScalar<int> * name: string with
member t.Name = t |> fun (CudaAr1D (_, name)) -> name
type CudaAr2D<'t> = CudaAr2D of CudaScalar<int> * CudaScalar<int> * name: string with
member t.Name = t |> fun (CudaAr2D (_, _, name)) -> …type Expr =
| Lit of int
| Add of Expr * Expr
let rec intr = function
| Lit _ as x -> x
| Add(Lit a,Lit b) -> Lit <| a + b
| Add(a,b) -> intr <| Add(intr a, intr b)
let rec intr_cps x ret =
match x with
| Lit _ as x -> ret x
| Add(Lit a,Lit b) -> Lit (a + b) |> ret
| Add(a,b) ->
intr_cps a <| fun a …我正在做一些简单的练习来感受一下这门语言。
is_list([]).
is_list([_|_]).
my_flatten([],[]).
my_flatten([X|Xs],RR) :-
my_flatten(Xs,R),
(is_list(X), !, append(X,R,RR); RR = [X | R]).
这是一个使用 cut 的版本，用于将列表展平一级的谓词。
my_flatten([],[]).
my_flatten([X|Xs],RR) :-
my_flatten(Xs,R),
if_(is_list(X), append(X,R,RR), RR = [X | R]).
这是我想写的方式，但它不起作用。也不is_list(X) = true作为if_条件。我打算在if_这里如何使用？
type Mul = Mul with member inline __.Op(a: ^a,b: ^a) = a*b
type Div = Div with member inline __.Op(a: ^a,b: ^a) = a/b
type Add = Add with member inline __.Op(a: ^a,b: ^a) = a+b
type Sub = Sub with member inline __.Op(a: ^a,b: ^a) = a-b
let inline op x a b =
(^a: (member Op: ^b * ^b -> ^b) x,a,b)
let inline tup2 a b c d = op Mul a b, op Mul c d …let a = ref 0
let f (x: byref<int>) = x
f a // type error
System.Int32.TryParse("123",a) // works
f a作为一个类型错误令我感到困惑,因为a可以传递给byref<int>类型的.NET库方法.为什么？
编辑:我想我真的很难解释这个问题.该类型的System.Int32.TryParse是string * byref<int> -> bool,但它的工作原理.那么为什么我不能a进入类型的函数x:byref<int> -> int？这就是我要问的全部.
我可能刚刚错过了它们，但我似乎无法在 Pharo 中找到任何提及不可变数据结构的内容。来自函数式语言，我发现不可变 map 和 set 在各种场合都很有用。尽管 Pharo 对使用变异有特别的偏见，但如果还没有人开始实施它们，我会感到惊讶。
type TotalSizeToken = TotalSizeToken with
static member TotalSize(_: TotalSizeToken, (a,b,c,d,e)): int = a*b*c*d*e
static member TotalSize(_: TotalSizeToken, (a,b,c,d)): int = a*b*c*d
static member TotalSize(_: TotalSizeToken, (a,b,c)): int = a*b*c
static member TotalSize(_: TotalSizeToken, (a,b)): int = a*b
static member TotalSize(_: TotalSizeToken, x: int): int = x
let inline size_to_total_size x =
((^s) : (static member TotalSize: TotalSizeToken * ^s -> int) TotalSizeToken, x)
let t = size_to_total_size (1,5) // Error: Expecting a type supporting the operator TotalSize, but given a …{-# LANGUAGE GADTs #-}
module Main where
data CudaExpr x where
C :: x -> CudaExpr x
Add :: Num x => CudaExpr x -> CudaExpr x -> CudaExpr x
Sub :: Num x => CudaExpr x -> CudaExpr x -> CudaExpr x
Mul :: Num x => CudaExpr x -> CudaExpr x -> CudaExpr x
Div :: (Num x, Fractional x) => CudaExpr x -> CudaExpr x -> CudaExpr x
Eq :: (Eq x) => CudaExpr x -> CudaExpr …