List Haskell:：如何在列表之间比较/提取/添加每个元素_List_Haskell_Compare_Extract_Add

List Haskell:：如何在列表之间比较/提取/添加每个元素

list haskell

List Haskell:：如何在列表之间比较/提取/添加每个元素,list,haskell,compare,extract,add,List,Haskell,Compare,Extract,Add,我试图从列表列表中获取每个元素例如，[1,2,3,4][1,2,3,4] 我需要创建一个列表，它是[1+1,2+2,3+3,4+4] 列表可以是任何内容。“abcd”“defg”=>[“ad”、“be”、“cf”、“dg”] 问题是两个列表可以有不同的长度，所以我不能使用zip 这是一件事，另一件事是比较我需要将[1,2,3,4]与[1,2,3,4,5,6,7,8]进行比较。第一个列表可以比第二个列表长，第二个列表可能比第一个列表长因此，如果我将[1,2,3,4]与[1,2,3,4,5,6

我试图从列表列表中获取每个元素

例如，[1,2,3,4][1,2,3,4]

我需要创建一个列表，它是[1+1,2+2,3+3,4+4]

列表可以是任何内容。“abcd”“defg”=>[“ad”、“be”、“cf”、“dg”]

问题是两个列表可以有不同的长度，所以我不能使用zip

这是一件事，另一件事是比较

我需要将[1,2,3,4]与[1,2,3,4,5,6,7,8]进行比较。第一个列表可以比第二个列表长，第二个列表可能比第一个列表长

因此，如果我将[1,2,3,4]与[1,2,3,4,5,6,7,8]进行比较，结果应该是[5,6,7,8]。无论第一个列表没有什么，但是第二个列表有什么，都需要输出

我也不能使用任何递归函数。我只能导入数据。Char

我相信您可以使用concat和nub的组合来解决这个问题，这将删除所有重复项

nub (concat [[0,1,2,3], [1,2,3,4]])

在执行此操作之前，需要从第一个列表中删除唯一的元素。ie 0

（使用相同的函数）

我相信您可以使用concat和nub的组合来解决此问题，这将删除所有重复项

nub (concat [[0,1,2,3], [1,2,3,4]])

在执行此操作之前，需要从第一个列表中删除唯一的元素。ie 0

（使用相同的函数）

我相信您可以使用concat和nub的组合来解决此问题，这将删除所有重复项

nub (concat [[0,1,2,3], [1,2,3,4]])

在执行此操作之前，需要从第一个列表中删除唯一的元素。ie 0

（使用相同的函数）

我相信您可以使用concat和nub的组合来解决此问题，这将删除所有重复项

nub (concat [[0,1,2,3], [1,2,3,4]])

在执行此操作之前，需要从第一个列表中删除唯一的元素。ie 0 （使用相同的函数）

对于第二个问题（如果我读对了），简单的筛选或列表理解就足够了：

uniques a b = filter (not . flip elem a) b

对于第二个问题（如果我读对了），一个简单的过滤器或列表理解就足够了：

uniques a b = filter (not . flip elem a) b

对于第二个问题（如果我读对了），一个简单的过滤器或列表理解就足够了：

uniques a b = filter (not . flip elem a) b

对于第二个问题（如果我读对了），一个简单的过滤器或列表理解就足够了：

uniques a b = filter (not . flip elem a) b

对于第一个问题，您可以使用zipWith：

zipWith f [a1, a2, ...] [b1, b2, ...] == [f a1 b1, f a2 b2, ...]

就像你的例子一样

Prelude> zipWith (+) [1 .. 4] [1 .. 4]
[2,4,6,8]

我不确定如果列表长度不同，你需要什么。标准的

zip

和

zipWith

只需忽略没有成对的较长元素。您可以保持它们不变，并编写自己的zipWith模拟，但它类似于

zipWithRest:：（a->a->a）->[a]->[a]->[a]

，这与第二个示例中的字符串类型相矛盾

对于第二种情况，您可以使用列表理解：

Prelude> [e | e <- [1 .. 8], e `notElem` [1 .. 4]]
[5,6,7,8]

Prelude>[e|e对于第一个问题，您可以使用zipWith：
zipWith f [a1, a2, ...] [b1, b2, ...] == [f a1 b1, f a2 b2, ...]

就像你的例子一样
Prelude> zipWith (+) [1 .. 4] [1 .. 4]
[2,4,6,8]

我不确定在不同长度的列表中需要什么。标准的zip
和zipWith
只需忽略没有成对的较长列表中的元素。您可以保持它们不变，并编写自己的zipWith模拟，但类似于zipWithRest:：（a->a->a）->[a]->[a]->[a]->[a] 
这与第二个示例中的字符串类型相矛盾
对于第二种情况，您可以使用列表理解：
Prelude> [e | e <- [1 .. 8], e `notElem` [1 .. 4]]
[5,6,7,8]

Prelude>[e|e对于第一个问题，您可以使用zipWith：
zipWith f [a1, a2, ...] [b1, b2, ...] == [f a1 b1, f a2 b2, ...]

就像你的例子一样
Prelude> zipWith (+) [1 .. 4] [1 .. 4]
[2,4,6,8]

我不确定在不同长度的列表中需要什么。标准的zip
和zipWith
只需忽略没有成对的较长列表中的元素。您可以保持它们不变，并编写自己的zipWith模拟，但类似于zipWithRest:：（a->a->a）->[a]->[a]->[a]->[a] 
这与第二个示例中的字符串类型相矛盾
对于第二种情况，您可以使用列表理解：
Prelude> [e | e <- [1 .. 8], e `notElem` [1 .. 4]]
[5,6,7,8]

Prelude>[e|e对于第一个问题，您可以使用zipWith：
zipWith f [a1, a2, ...] [b1, b2, ...] == [f a1 b1, f a2 b2, ...]

就像你的例子一样
Prelude> zipWith (+) [1 .. 4] [1 .. 4]
[2,4,6,8]

我不确定在不同长度的列表中需要什么。标准的zip
和zipWith
只需忽略没有成对的较长列表中的元素。您可以保持它们不变，并编写自己的zipWith模拟，但类似于zipWithRest:：（a->a->a）->[a]->[a]->[a]->[a] 
这与第二个示例中的字符串类型相矛盾
对于第二种情况，您可以使用列表理解：
Prelude> [e | e <- [1 .. 8], e `notElem` [1 .. 4]]
[5,6,7,8]

前奏曲>[e | e
问题是两个列表可以有不同的长度，所以我不能使用zip
在这种情况下，结果应该是什么
不能使用任何递归函数
那是不可能的。在你使用的库函数中（就像在其他答案中一样），或者在你自己编写的函数中，都会出现递归。我怀疑你误解了你的任务
问题是两个列表可以有不同的长度，所以我不能使用zip
在这种情况下，结果应该是什么
不能使用任何递归函数
那是不可能的。在你使用的库函数中（就像在其他答案中一样），或者在你自己编写的函数中，都会出现递归。我怀疑你误解了你的任务
问题是两个列表可以有不同的长度，所以我不能使用zip
在这种情况下，结果应该是什么
不能使用任何递归函数
那是不可能的。在你使用的库函数中（就像在其他答案中一样），或者在你自己编写的函数中，都会出现递归。我怀疑你误解了你的任务
问题是两个列表可以有不同的长度，所以我不能使用zip
在这种情况下，结果应该是什么
不能使用任何递归函数
那就不可能了，不会有了