foldr -添加两个列表的压缩元素
foldr是一种高阶函数，用于对列表进行折叠操作。它接受一个二元函数和一个初始值作为参数，并从列表的右侧开始，将函数应用于列表中的每个元素和累积值，最终返回一个单一的结果。
对于添加两个列表的压缩元素，我们可以使用foldr来实现。假设我们有两个列表list1和list2，我们想要将它们的对应元素相加并返回一个新的列表。
首先，我们定义一个二元函数add，用于将两个元素相加：
def add(x, y):
return x + y然后，我们可以使用foldr来将add函数应用于list1和list2的每个对应元素，并将结果累积到一个新的列表中：
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = foldr(add, [], zip(list1, list2))在这里，我们使用了zip函数将list1和list2的对应元素打包成一个元组的列表。然后，我们将add函数作为参数传递给foldr，并将一个空列表作为初始值。foldr会从列表的右侧开始，将add函数应用于每个元组和累积值，并将结果添加到新的列表中。
最终，result将包含5, 7, 9，即list1和list2对应元素相加的结果。
在腾讯云的产品中，没有直接与foldr函数对应的特定产品。然而，腾讯云提供了丰富的云计算服务和解决方案，可以满足各种开发需求。例如，腾讯云的云函数（Serverless Cloud Function）可以用于编写和部署无服务器函数，实现类似于foldr的功能。您可以通过以下链接了解更多关于腾讯云云函数的信息：
请注意，以上答案仅供参考，具体的实现方式和推荐产品可能因实际需求和环境而异。
相关·内容
1回答
我试图使用Map/Foldl/Foldr查找列表的长度
(define (suml lst)
(length lst))
Input : (suml '(1 2 3))
Output : 3
Input : (suml '(((((2)))) (1)))
Output: 2
如何用foldl/map/foldr修改它？
浏览 5提问于2016-10-20得票数 0
回答已采纳
1回答
我有一个迭代的foldr函数：
fun iterFold f v [] = v
| iterFold f v (x::xs) = iterFold f (f(v,x)) xs;
以及一个接受谓词和列表的函数。该函数将列表与谓词进行比较，如果只出现一次，则返回true。
fun exist3 p M = foldr( fn(x,y) => y orelse (p x)) false M
使用这两个函数，我需要编写一个返回两个列表的交集的单行函数。如有任何帮助或建议，我们将不胜感激！
浏览 1提问于2013-10-05得票数 1
2回答
我有两个功能。如果列表中的所有元素为零，则第一个元素将为true。
allZero :: [Int] -> Bool
allZero [] = False
allZero [0] = True
allZero (x:xs)
| x == 0 && allZero xs = True
|otherwise = False
如果列表中至少有一个元素为零，则第二个函数给出真。
oneZero :: [Int] -> Bool
oneZero [] = False
oneZero (x:xs)
| x == 0 = True
| otherwise =
浏览 1提问于2021-01-09得票数 2
回答已采纳
我正在学习Haskell编程，并试图了解列表是如何工作的，因此我尝试编写两个可能的length函数：
myLength :: [a] -> Integer
myLength = foldr (\x -> (+) 1) 0
myLength1 :: [a] -> Integer
myLength1 [] = 0
myLength1 (x:xs) = (+1) (myLength1 xs)
哪一个更好？
从我的观点来看，myLength1更容易理解，在列表上操作看起来也很自然。
另一方面，myLength更短，而且不使用递归；这是否意味着myLength比myLeng
浏览 8提问于2017-05-12得票数 5
回答已采纳
我看到一个解释了如何使用foldr追加两个列表。
但我不明白为什么我们要改变名单的顺序。
append xs ys = foldr (\x y -> x:y) ys xs
第一步是
[y,x] (\x y -> x:y) foldr (\x y -> x:y) ys' xs'
我说的对吗？结果会把ys放在xs前面吗？
不是应该吗
append xs ys = foldr (\x y -> x:y) xs ys
浏览 0提问于2018-06-12得票数 0
回答已采纳
2回答
简介：，这是米兰达考试的一个过去的试题，但语法非常类似于Haskell。
问题：，以下表达式的类型是什么，它是做什么的？(函数长度和交换空间的定义如下)。
(foldr (+) 0) . (foldr ((:) . length . (swap (:) [] )) [])
length [] = 0
length (x:xs) = 1 + length xs
swap f x y = f y x
注意：
请随时用haskell语法回复--很抱歉把星星作为多个类型，但是我不想把它翻译成haskell。基本上，如果一个变量有类型*而另一个变量有*，这意味着它们可以是任何类型，但它们必须都是相
浏览 0提问于2012-04-29得票数 7
回答已采纳
4回答
假设我想得到所有素数幂的排序无限列表，直到指数n。
我有一个函数来合并两个排序列表和一个给我素数的函数。
merge :: Ord t => [t] -> [t] -> [t]
merge (x:xs) (y:ys)
| (x <= y) = x : merge xs (y:ys)
| otherwise = y : merge (x:xs) ys
merge xs [] = xs
merge [] ys = ys
primes :: [Integer]
primes = sieve [2..]
where
sieve [] =
浏览 4提问于2014-04-04得票数 7
回答已采纳
2回答
我想创建一个自定义的map函数，它与sml中的预定义map函数做同样的事情，我编写了以下代码：
fun mymap f = fn L => foldr f [] L;
这基本上是一个函数f，它可以获取一个列表，并将函数f应用于该列表，因为map函数获取一个列表和函数，并返回另一个列表，现在我得到的结果是：
val mymap = fn : ('a * 'b list -> 'b list) -> 'a list -> 'b list
但是预定义的map函数具有以下输出：
val it = fn : ('a -> &#
浏览 1提问于2012-03-26得票数 0
1回答
我从上读到，由于严格性，foldl'对于长有限列表更有效。我知道这是不适合无限列表的。
因此，我只对有限长的列表进行比较。
concatMap
是使用foldr实现的，这给它带来了惰性。然而，使用它与长有限列表将建立一个长的，不缩减的链，根据文章。
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
concatMap f xs = build (\c n -> foldr (\x b -> foldr c b (f x)) n xs)
因此，我提出了以下使用foldl'的实现。
conc
浏览 0提问于2017-03-26得票数 2
回答已采纳
我读了书的旧俄文译本。我看到现在的英文版(在线)比较新，所以我也看时间了。
The
当您将两个列表放在一起时(即使您将一个单例列表附加到一个列表中，例如：[1,2,3] ++ [4])，内部，Haskell必须遍历++左侧的整个列表)。在处理不太大的列表时，这不是一个问题。，但是在一个长达5000万条条目的列表的末尾放置一些东西需要一段时间，。但是，使用:运算符(也称为cons运算符)将某物放在列表的开头是即时的。
我假设Haskell必须遍历整个列表，才能获得用于foldr、foldr1、scanr和scanr1函数的列表的最后一项。此外，我还假设Haskell在获取前一个元素时也
浏览 2提问于2016-10-11得票数 0
回答已采纳
1回答
我很难弄清楚foldr的功能。我正在做作业，我们应该建立一个函数(不需要foldr)，它压缩了两个列表的元素(f.e.'(1 2 3) (4 5 6) -> (1 4) (2 5) (3 6).
到目前为止，它运行得还不错：
(define (zip list1 list2)
(cond
[(or (empty? list1) (empty? list2)) '()]
[else (cons (list (car list1) (car list2)) (zip (cdr list1) (cdr list2)))]))
但现在我必须构建一个函数，它
浏览 5提问于2017-06-30得票数 2
回答已采纳
2回答
我想要创建一个函数，该函数接受一个列表，并使用表单[[e1],[e1,e2],[e1,e2,e3]...]创建一个具有列表理解能力的列表。
例如：
f5 ['a','b','c'] = ["a","ab","abc"]
f5 [1,2,3] = [[1],[1,2],[1,2,3]]
我的守则：
f5 xs = [a | a <- xs]
-- tests:
*Main> f5 ["a","b","c"]
["a",
浏览 4提问于2016-05-09得票数 1
回答已采纳
我来自Python，学习Haskell对我来说很难。例如，我得到了这个函数，它将合并列表。所以第一件事是合并列表，然后我想返回合并列表的总和。正确的语法是什么？
merge:: [[a]] -> [a]
merge xss = foldr (++) [] xss
return sum []
这段代码只有在我删除最后一行的情况下才能工作。但是我想返回合并列表的总和。
浏览 1提问于2017-05-08得票数 0
2回答
我在SML中遇到了两个令人困惑的问题，希望有人能帮我解决：
第一个是一个函数，它接受一个元素和一个列表，并决定该元素是否存在于列表中，下面是我尝试编写的代码：
fun member (e,L) = foldl (fn(a,b) => if (e = b) then true else false) false L;
但是我得到了布尔列表-->布尔但我需要的是一个列表-->布尔
至于第二个，它也需要一个元素和一个列表，但返回一个比传递的元素少的元素列表。我不确定这是否应该通过map或foldr/foldl来完成。有什么建议吗？
提前感谢:)
浏览 3提问于2012-03-23得票数 1
回答已采纳
2回答
请有人向我解释一下，为什么在我的concat实现中源列表的类型不起作用？
conc::[[a]]->[a]
conc xs@(x1:xs')=foldr (:) [] xs
为什么源列表应该是[a]而不是[[a]]？如果我想连接，[[1,2],[3,4]]不是[[a]]类型，不是[a]类型，元素类型是[a]类型。
我得到以下错误：
Couldn't match type `a' with `[a]'
`a' is a rigid type variable bound by
the type signature for:
浏览 0提问于2018-05-03得票数 0
回答已采纳
2回答
我有两个函数计算整数列表的长度。
lengthFoldl :: [Int] -> Int
lengthFoldl xs = (foldl (\_ y -> y+1) 0 xs)
和
lengthFold :: [a] -> Int
lengthFold xs = foldr (\_ y -> y+1) 0 xs
它们是相同的，除了一个使用折叠和一个折叠。
但是，当试图计算任何列表[1 .. n]的长度时，我从lengthFoldl得到一个错误的结果(一个太大)。
浏览 0提问于2018-06-22得票数 3
回答已采纳
我试图通过列表中的索引来实现自己的安全搜索元素。我认为，我的职能必须有这样的签名：
safe_search :: [a] -> Int -> Maybe a
safe_search xs n = foldr iteration init_val xs n
iteration = undefined
init_val = undefined
我对迭代的实现有问题。我想，它必须是这样的：
safe_search :: [a] -> Int -> Maybe a
safe_search xs n = foldr iteration init_val xs n
wher
浏览 4提问于2015-04-02得票数 1
回答已采纳
目标是:使用foldr，定义一个函数remove，它以两个字符串作为参数，并从第一个列表中的第二个列表中删除每个字母。例如，remove "first" "second" = "econd"。
如果这个函数只有一个字符和一个字符串，我会这样做：
remove a xs = foldr (\x acc -> if x /= a then x : acc else acc) [] xs
但我不知道该怎么用两根弦来做这件事。谢谢!
浏览 0提问于2018-09-12得票数 2
回答已采纳
2回答
有困难阅读(解释)这个功能米兰达代码。
g = (foldr (+) 0) . (foldr ((:) . ((#) . (:[]))) [])
我知道它能做什么
通过#获取长度来计算列表的大小
创建一个元素列表，其中包含原始输入列表的上述长度
使用foldr将新列表折叠为单个整数，每个元素上的操作为+0
但是，我对方括号感到困惑，不知道输入列表是在哪里输入的。最右边的[]构造函数是做什么的？
此外，为什么这段代码只通过函数g工作，但是如果我直接调用它，它会抛出一个错误。
浏览 0提问于2018-05-17得票数 1
回答已采纳
如何计算具有成员条件的列表的长度？
通常，以下内容用于计算列表的长度
(* Compute the length of a list *)
fun length(L) =
if null L then 0
else 1 + length (tl (L));
但是，如何通过仅在5到10之间计数来指定成员的范围呢？
如果我想在问题1中使用函数foldr，如何做到这一点？
浏览 0提问于2014-02-25得票数 0
2回答
我很难想出一种方法来利用这些函数来学习在Haskell中学习函数式编程的初学者级编码课程。我必须编写的函数如下所示，asum应该将整数[a1,a2,..,an]的列表转换为交替和a1-a2+a3-a4+.…，我不知道如何用这些函数来处理它。xor函数应该用来计算布尔列表的XOR。我需要一些帮助，以了解如何使用这些功能，它将非常感谢。我也是哈斯克尔的新手，所以任何解释都会有帮助。谢谢，我必须使用map foldr foldl。
asum :: (Num a) => [a] -> a
xor :: [Bool] -> Bool
浏览 8提问于2021-10-08得票数 0
我有两个Haskell函数，这两个函数看起来都与我非常相似。但是，第一个对无限列表失败，第二个对无限列表成功。几个小时以来，我一直试图弄清楚到底是什么原因，但都没有结果。
这两个片段都是前奏曲中“word”函数的重新实现。两者都可以很好地对抗有限的列表。
以下是不处理无限列表的版本：
myWords_FailsOnInfiniteList :: String -> [String]
myWords_FailsOnInfiniteList string = foldr step [] (dropWhile charIsSpace string)
where
step s
浏览 0提问于2009-05-12得票数 12
回答已采纳
我应该写一个函数，用这个数字包含前面每一个乘法的乘积
基本上如下：
> productFromLeftToRight [2,3,4,5]
[120,60,20,5]
我应该使用高阶函数，所以折叠之类的。我正在考虑使用foldr遍历列表中的lambda表达式。我就是这么想的：
> productFromLeftToRight nums = foldr (\x acc -> [x] * acc ++ acc) [] nums
因为它会像f(2 (f 3 (f 4 (f 5 []))))那样分解，我会认为我是对的，但是我得到了整个打印错误，我不知道如何用acc的第一个元素乘以一个数
浏览 4提问于2015-12-12得票数 2
回答已采纳
我试图使用foldl/r添加两个结构的列表，但我无法添加这两个列表。我已附上以下守则
(define-struct product-list (barcode expiry price ))
(define-struct tax-list (barcode tax))
(define (total-price products taxes)
(foldr
+ (product-list-price products) (tax-list-tax taxes)))
(define products (list
(make-product-list 1500 85)
(make-produ
浏览 1提问于2021-01-13得票数 0
回答已采纳
2回答
对于无限列表，它没有“最后”元素。那么，foldr如何使用它呢？
下面是Haskell书中的代码片段：
(&&)::Bool->Bool->Bool
True && x = x
False && _ = False
and' :: [Bool]->Bool
and' xs=foldr (Main.&&) True xs
然后在Prelude中加载这个hs文件并运行：
*Main> and' (repeat False)
False
它按预期工作，但我不明白：
(&&am
浏览 4提问于2016-02-19得票数 2
回答已采纳
作为大学作业的一部分，我得到了以下问题。由于模块非常短，我们只使用Haskell的一个子集，没有任何语法糖或惯用快捷键.我必须写：
附加xs :按顺序加入列表xs和ys__所形成的列表
append (5:8:3:[]) (4:7:[]) => 5:8:3:4:7:[]
我理解foldr如何工作的概念，但我只是从函数式编程开始。我成功地编写了以下工作解决方案(为了我们班的其他人的利益而隐藏起来.)：
附录= \xs -> \ys -> foldr (\x -> \y -> x:y) ys xs
但是，我只是不能为我的生活，解释到底是怎么回事！？我只是在解释器中摆弄
浏览 0提问于2012-11-04得票数 4
回答已采纳
1回答
当我们折叠一个包含一个或多个元素的列表时，如下所示：
foldr (+) 0 [1,2,3]
我们得到: foldr (+) 0 (1 :2:3：[])
foldr (+) 1+ (2 +(3 + 0)) // 6
现在，当列表为空时：
foldr (+) 0 []
结果: foldr (+) 0 ([])
由于(+)是二进制运算符，它需要两个参数才能完成，但在这里我们以(+) 0结束。它是如何导致部分应用函数的0和不抛出错误的。
浏览 0提问于2017-06-21得票数 0
回答已采纳
我正在学习一门课程，必须完成以下任务。我必须编写一个函数，得到两个长度相同的列表A和B，并返回一个列表，其中的每一个项目都是由两个项组成的列表--一个来自A，另一个来自B。
例如，函数获取'( 12，3)和'(4，5，6)并返回“(1，4)(2，5)(3 ))。我可以用这样的地图来做：
( lst1 lst2) (map (lambda(x ) (list X)) lst1 lst2)
但问题是要通过foldr和来实现这一点，而不需要显式递归。
有人能帮帮我吗？我不知道该怎么做.
谢谢!
浏览 2提问于2014-03-20得票数 1
回答已采纳
5回答
我正在尝试编写一个haskell函数，该函数接受两个整数列表，并生成一个包含交替从这两个列表中获取的元素的列表。
我有一个函数：
blend xs ys
举个例子：
blend [1,2,3] [4,5,6]
应该返回
[1,4,2,5,3,6]
我的逻辑是将两个列表压缩在一起，生成替换元素对，然后以某种方式将它们从元组中删除。
它将它们从元组中移除，我不知道如何实现。
浏览 6提问于2011-12-12得票数 14
回答已采纳
2回答
标准库包括一个函数
unzip :: [(a, b)] -> ([a], [b])
很明显，定义它的方法是
unzip xs = (map fst xs, map snd xs)
但是，这意味着遍历列表两次以构造结果。我想知道的是，是否只有一次遍历就能做到这一点？
附加到列表实际上是昂贵的- O(n)。但是，任何新手都知道，我们可以巧妙地利用懒惰和递归来“追加”到具有递归调用的列表中。因此，zip可以很容易地实现为
zip :: [a] -> [b] -> [(a, b)]
zip (a:as) (b:bs) = (a,b) : zip as bs
但是，只有当您返回一个列表
浏览 0提问于2013-08-17得票数 4
回答已采纳
我有以下问题要问我。
编写了一个函数form_number_back，它接受正整数列表，并使用列表中的数字按相反顺序形成十进制数。
例如，form_number_back 1、2、3、4应该返回数字4321；form_number_back返回0
使用下面的函数foldr和mult_add来完成这个mult_add d s = d + 10*s
注意: foldr和foldr1是两个不同的函数。尝试在定义中使用foldr1而不是foldr，并查看是否使用空列表获得相同的结果。解释你的结果。
我在mult_add上找不到任何东西。我原以为是函数名，但她想要form_number_back作为函
浏览 0提问于2012-06-11得票数 0
2回答
我读书的时候有个问题。
下面是我在无限列表中的想法：
foldr (:) [] [1..] = 1:2:...:**∞:[]**
我认为GHCi在评估∞:[]之前不知道它是列表。
但GHCi确实知道。
因此，我认为它可以识别foldr (:) =无穷列表本身。
Prelude> [1..10] == (take 10 $ foldr (:) [] [1..])
True
Prelude> [1..] == (foldr (:) [] [1..])
Interrupted.
但事实并非如此。
我想知道当GHCi认识到它是1.在评估∞之前：[]。
只是在评估之前的类型推断？
浏览 0提问于2018-02-12得票数 1
回答已采纳
我试图让一个函数使用foldr来处理一个具有诸如3>4、.等值的列表。如果列表中的值为真，则返回true。我已经试过这么做了：
fold :: [Bool] -> Bool
fold xs = foldr (x==True) xs
where x:xs
浏览 1提问于2014-10-16得票数 0
回答已采纳
2回答
我不理解以下问题的示例解决方案:给定一个元素列表，删除重复的元素。然后计算一个数字的唯一数字。任何一个问题都不能使用显式递归。
我的代码：
removeDuplicates :: Eq a => [a] -> [a]
removeDuplicates = foldr (\x ys -> x:(filter (x /=) ys)) []
differentDigits :: Int -> Int
differentDigits xs = length (removeDuplicates (show xs))
我试图理解的解决方案对于differentDigits有一个
浏览 0提问于2019-08-05得票数 1
回答已采纳
我熟悉foldl和foldr在单个列表中的底层工作原理和差异。但是，在球拍中，您可以在多个列表上使用折叠。例如，您可以通过以下方式找出两个列表中元素的差异
; (mapMinus '(3 4) '(1 2)) => '(2 2)
(define (mapMinus lst0 lst1)
(foldl (λ (hd0 hd1 acc) (cons (- hd0 hd1) acc)) '() lst0 lst1))
exactly的foldl和foldr实现到底是如何处理多个列表的？GitHub 上提供了foldl的球拍源代码，但我对Chez Scheme
浏览 17提问于2020-02-28得票数 1
回答已采纳
2回答
我正在阅读learnyouahaskell.com，目前正在研究folds。在这本书中有这些例子：
maximum' :: (Ord a) => [a] -> a
maximum' = foldr1 (\x acc -> if x > acc then x else acc)
reverse' :: [a] -> [a]
reverse' = foldl (\acc x -> x : acc) []
product' :: (Num a) => [a] -> a
product
浏览 0提问于2013-05-22得票数 5
回答已采纳
这是我的作业，但我们只允许使用过滤器、map、foldr、排序、构建列表和lambda来代替显式递归。
我怎么才能重写这些，使用上面那些高阶函数来不让函数调用自己。
我现在拥有的是：
(define (worthless loc name)
(cond
[(empty? loc) loc]
[(equal? name (coin-name (first loc))) (cons (make-coin (coin-name (first loc)) 0) (worthless (rest loc) name))]
[else (cons (first loc) (wo
浏览 1提问于2020-12-01得票数 0
我实现了一个函数(！=)，它给出了一个列表和一个包含列表中的索引和一个新值的元组，用给定索引处的新值更新给定的列表。
(!!=) :: [a] -> (Int,a) -> [a]
(!!=) xs (0, a) = a : tail xs
(!!=) [] (i, a) = error "Index not in the list"
(!!=) (x:xs) (i, a) = x : xs !!= (i-1, a)
作为一个使用折叠概念的初学者，我想知道是否有一种方法可以使用foldl或foldr来实现相同的结果？
提前谢谢。
浏览 3提问于2021-04-16得票数 0
回答已采纳
我对Haskell并不熟悉，我遇到了以下令我困惑的代码：
foldr (zipWith (:)) (repeat []) [[1,2,3],[4,5,6],[7,8,9,10]]
它产生了以下结果，在玩了它之后，我不完全确定为什么：
[[1,4,7],[2,5,8],[3,6,9]]
我的印象是，(:)将项添加到列表中，而(repeat [])生成了大量的空列表( [] )，foldr接受函数、项和列表，并通过对列表中的每个项目以及结果连续应用该函数来压缩列表。
也就是说，我直觉地理解以下代码如何产生10的结果：
foldr (+) 1 [2,3,4]
但是，我一点也不确定为什么foldr (
浏览 1提问于2019-03-17得票数 4
回答已采纳
在完成了中的第一个问题(“查找列表的最后一个元素”)之后，我想看看我的解决方案与其他解决方案相比如何，我找到了。
myLast' = foldr1 (const id)
这个似乎表明foldr1有两个参数，第一个是函数，第二个是列表。但是这个定义似乎只将函数作为一个参数。这样传递的参数是否有一个隐含的定义？
myLast' xs = foldr1 (const id) xs
我已经查阅了foldr1、const和id的定义，但我很难理解这三者是如何协同工作的，以返回列表中的最后一项。
浏览 5提问于2013-09-03得票数 8
1回答
如何通过使用foldr和foldl定义函数来反转Scheme中的列表
我们想要的是一个简洁的解决方案，使用foldl调用来反转Scheme中的列表，并使用foldr调用提供不同的解决方案，如定义的那样：
(define (foldl operation lst initial)
(if (null? lst) initial
(foldl operation
(cdr lst)
(operation (car lst) initial))))
和
(define (foldr operation lst i
浏览 6提问于2013-11-05得票数 4
我在编写函数(sublist list from to)时遇到了一个问题，该函数使用两个参数from和to，并从从索引from开始到索引to之前结束的列表生成子序列，其中索引从0开始。例如,
(sublist '(a b c d e f g h) 1 4) ==> '(b c d)
(sublist '(a b c d e f g h) 1 1) ==> '()
(sublist '(a b c d) 0 30) ==> '(a b c d)
我知道，如果我们被允许使用本地助手函数，我们可以编写一个助手函数，它从0开始计数
浏览 0提问于2020-11-20得票数 2
我试图编写一个列表函数，它接受一个简单的列表，并反馈一个列表列表，后者的所有元素都与前一个列表具有相同的关系。
更具体地说，该职能应这样做：
列一张清单；let xs = [1,2,3,4,5,6,8,9,10]
查看头部的两个元素，如果第二个元素等于第一个元素加一个元素(即xs!!0 = xs!!1 - 1)，则在其中创建一个列表。
列表接受元素，而最后一个元素与元素有相同的关系，这是最近从主列表中输入的。当中断时，子列表会关闭，但是函数应该根据相同的条件生成一个新的子列表。
所以，最终的结果应该是，[[1,2,3,4,5,6],[8,9,10]]缺席的7将主列表分成两个子列
浏览 4提问于2011-08-06得票数 2
回答已采纳
我有点纠结于实现一个二进制搜索树的Eq实例。我想检查两个树中的值是否相同，但我真的不知道如何正确执行此操作。因为两个二叉树的结构可能不同，所以我不能直接比较节点。我的想法是将它们转换成列表，对列表进行排序并进行比较，但这似乎相当复杂，我想知道是否有其他方法可以做到这一点。这是我到目前为止所得到的：
data BB a = L | K a (BB a) (BB a) deriving (Show)
instance Eq BB where
not (isBinarySearchTree t1 && isBinarySearchTree t2) = False
inOrd
浏览 4提问于2017-06-27得票数 0
回答已采纳
因此，我得到了一个包含元组的列表，我需要将它分解为两个列表，第一个列表包含带有奇数索引的元素，第二个列表包含偶数索引元素，必须使用折叠完成，下面是我的尝试：
breakList :: [(Integer, Integer)] -> [[(Integer, Integer)]]
breakList [] = [[], []]
breakList xxs@(x:xs) = foldl (\ acc y -> if length (acc !! 0) < length (acc !! 1) then y : (acc !! 0) else y : (acc !! 1) ) [[
浏览 0提问于2019-01-10得票数 1
回答已采纳
1回答
缺失的褶皱
、、、、
如果你想折叠一个列表，我看到了四种方法。
从列表的右侧折叠，右侧为递归项。
(-) 100 1.10=1- (2 - (3 - (4 - (5 - (6 - (7 - (8 - (9 - (10 -(100)= 95
foldrr :: (a -> b -> b) -> b -> [a] -> b
foldrr step zero (x:xs) = step x (foldrr step zero xs)
foldrr _ zero [] = zero
从列表的右边折叠，左边是递归项。
( 100 ))- 9) - 8) - 7) - 6)
浏览 2提问于2017-07-02得票数 9
回答已采纳
我最近一直在学习Haskell，遇到了一些我不太理解的东西: lambda函数的参数。
在“为伟大的好书学习一本Haskell”第5章中，有以下两个功能：
elem' :: (Eq a) => a -> [a] -> Bool
elem' y ys = foldr (\x acc -> if x == y then True else acc) False ys
reverse' :: [a] -> [a]
reverse' = foldl (\acc x -> x : acc) []
在第一个函数中，累加器被列出为lambd
浏览 3提问于2021-09-20得票数 5
回答已采纳
#lang racket
(define (cartesian-product . lists)
(foldr (lambda (xs ys)
(append-map (lambda (x)
(map (lambda (y)
(cons x y))
ys))
xs))
'(())
lists))
浏览 0提问于2019-10-02得票数 0
我目前正在为一个类分配一个任务，我们必须使用lambdas和局部变量来重新定义我们以前定义的函数。我真的不想把它写下来，因为这是我迟早要面对的问题。
我不明白一个地方是怎么工作的，至于兰达，我不知道其中一些条款是什么意思。
下面是我创建的lambda函数的一个例子，它只从列表中提取偶数并对它们进行平方：
(define (even-squares lon)
(foldr (lambda (x y)
(if (even? x) (cons (sqr x) y)
y)) '() lon))
这对于这个问题很有效，但在
浏览 6提问于2022-06-20得票数 0
哈斯克尔新闻报
我正在haskell解决这个问题：
(**) Eliminate consecutive duplicates of list elements.
If a list contains repeated elements they should be replaced with a single copy of the element. The order of the elements should not be changed.
Example:
* (compress '(a a a a b c c a a d e e e e))
(A B C A D E)
解
浏览 4提问于2015-01-12得票数 10
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
