我试着和我的伙伴一起玩,他解决了8m 7s中提到的问题,而对我来说,它已经消失了2000万。我不知道如何在javascript中处理无限的嵌套数组。
问题是:
// i will be an array, containing integers, strings and/or arrays like itself.
// Sum all the integers you find, anywhere in the nest of arrays.
所以
arraySum([[1,2,false],'4','5']) will return 3 (passed)
a
例如,由于下面的函数没有累加器,它仍然是尾递归的吗?
belong:: (Ord a) => a -> [a] -> Bool
belong a [] = False
belong a (h:t)
| a == h = True
| otherwise = belong a t
函数中的所有计算都是在递归调用之前处理的,这是被视为尾递归的充分条件吗?
System.Linq.Aggregate的帮助
我有以下课程
public class MainClass
{
public ClassA someProp { get; set; }
public ClassA someProp2 { get; set; }
}
public class ClassA
{
public virtual Type Types => Type.None;
}
public class ClassB:ClassA
{
public override Type Types => Type.Default;
foldl :: (a -> b -> a) -> a -> [b] -> a
foldl step zero (x:xs) = foldl step (step zero x) xs
foldl _ zero [] = zero
我不太明白为什么(a -> b -> a)返回a,以及(a -> b -> a) -> a -> b -> a返回a。我认为应该是:(a -> b -> c) -> a -> b -> c。有人能根据下面的例子向我解释一下吗?谢谢!
foldl (+)
我正在尝试写一个函数,它将返回一个列表,其中包含从起点开始的所有位置。例如,如果我写"positions “,输出结果必须是"(0,0),(-1,0),(0,0),(-1,0),(-2,0),(-2,1)”。
使用下面的函数,我只能得到结束位置。有谁可以帮我?
type Position = (Int,Int)
data Step = L | R | U | D
type Route = [Step]
positions :: Route -> Position-> [Position]
positions [] p = p:[]
positions (m:ms
我一直在用匿名函数练习,得到了以下信息:
takeWhile' :: (a -> Bool) -> [a] -> [a]
takeWhile' f xs = foldl (\x y z -> if (f x) && z then x : y else y) xs [] True
这基本上是对已经在Haskell中的takeWhile函数的重写。
对于那些不知道的人,takeWhile函数接受一个列表和一个函数,并返回一个新列表,其中的每个元素都满足该函数,直到其中一个元素给出false为止。
从我的观点来看,一切似乎都是正确的,我有3个参
我从下面的代码中得到了不一致的答案,我觉得这很奇怪。
import scala.math.pow
val p = 2
val a = Array(1,2,3)
println(a.par
.aggregate("0")((x, y) => s"$y pow $p; ", (x, y) => x + y))
for (i <- 1 to 100) {
println(a.par
.aggregate(0.0)((x, y) => pow(y, p), (x, y) => x + y) == 14)
}
a.
你好,我正在尝试通过创建以下方法来理解累加器是如何工作的:
它接收一个数字并创建一个元组:(sum [0..nr], [0..nr])。例如,给定4,它应该返回(10, [0,1,2,3,4])。
这是我的代码:
accu :: Int -> (Int, [Int])
accu 0 = (0, [0])
accu nr = go (0, []) nr where --I do not get this line, mainly the first argument
go (s,ls) 0 = (s, 0:ls)
go (s,ls)
我是Spark和Scala的新手。我对reduceByKey函数在Spark中的工作方式感到困惑。假设我们有以下代码:
val lines = sc.textFile("data.txt")
val pairs = lines.map(s => (s, 1))
val counts = pairs.reduceByKey((a, b) => a + b)
映射函数很清晰:s是键,它指向data.txt中的行,1是值。
但是,我不知道reduceByKey在内部是如何工作的?"a“是否指向关键字?或者,"a“是否指向"s"?那么a+ b
我问了一个相关的问题,。我想做一件类似的事情,但这次线程累加器通过数组的函数。我立刻想到了Array.Reduce或Array.Fold,但它们不是为我工作的:
let AddTen x =
x + 10
let MultiplyFive x =
x * 5
let SubtractTwo x =
x - 2
let functionArray = [| AddTen; MultiplyFive; SubtractTwo |]
let calculateAnswer functionArray x = functionArray |>Array.reduc
我想写一个将二进制列表转换为整数的函数f,如下所示:
f :: [Integer] -> Integer
f [] = 0
f list = (last list) * 2^(length list -1) + f (init list)
例如,在f [1,1,1,1,0,0,1,0] = 79中,第一个列表元素表示2^0,最后一个列表元素表示2^7。
我可以用高阶函数代替显式递归来编写这个函数吗?
//tools.js
function randomString() {
var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
var string_length = 8;
var randomstring = '';
for (var i=0; i<string_length; i++) {
var rnum = Math.floor(Math.random() * chars.length);
Aggregate允许您提供一个自定义函数来运行IEnumerable<T>并返回一个T。Sum允许您使用自定义函数从每个元素中提取一个int,然后将它们全部添加到一起。
但是,如果我想做这样的事情-例如:
struct S
{
public int i;
public int j;
}
int Aggregate(IEnumerable<S> data)
{
int ret = 0;
foreach(x in data)
{
ret ^ = Math.Max(x.i,x.j);
}
return ret;
}
如图中所示,我希望使用指定的函数聚合到
我有一个函数,它接受字符串列表和字符串列表,然后返回每个列表中包含传递的字符串但没有传递字符串的所有元素的列表。
myfilter([["a","b"],["c","d"],["e","a","x"]], "a") -> ["b","e","x"]
fun myfilter(list : string list list, s : string) =
case list of
[] => []
在C语言中,我会用循环来解决这个问题。为了表达这一想法,类似于:
void foo(int x){
while(x > 0){
printf("%d", x % 10);
x /= 10;
}
}
使用F#,我无法使函数返回单个值。我试过:
let reverse =
let aux =
fun x ->
x % 10
let rec aux2 =
fun x ->
if x = 0 then 0