2个列表中的交替元素SML

在交替使用2个列表元素时，我的SML代码遇到了一些困难。我必须创建一个最终列表，其中包含两个相同大小的列表，并替换它们的元素。例如

alternate（[1,3,5]，[2,4,6]）=[1,2,3,4,5,6]

我不确定我的代码哪里出了问题。任何帮助都将不胜感激。这是我目前拥有的代码

fun alternate2([],y) = []
    | alternate2(a::x,y) = 
    if length listx = length listy then
        if countListx = countListy then (List.nth(listx, countListx)::alternate2(x,y); count(countListx))
        else if countListx <> length listx - 1 then 
            if countListy < countListx then (alternate2(x, a::y); count(countListy))
            else alternate2(x,y)
        else alternate2(x,y)
    else alternate2(x,y);

fun alternate2（[]，y）=[]
|备选方案2（a：：x，y）=
如果length listx=length listy，则
如果countListx=countListy，那么（List.nth（listx，countListx）：：备选2（x，y）；count（countListx））
否则，如果countListx长度listx为-1，则
如果countListy

您可以完全通过模式匹配和递归来实现这一点，而无需使用

长度

、

if-then-else或
=
。由于这个练习太小，我发现在不给出答案的情况下很难给出字面上的提示，因此我将尝试以类似的方式解决一个类似的练习：

给定一个函数
f:'a*'b->'c
和两个列表，
xs:'a list
和
ys:'b list
，我可以通过将函数
f
应用于每对
（x，y）
来创建一个结果
'z list
，其中每个
x
来自
xs code>，而每个
y
来自
ys
。如果一个列表比另一个长，我将丢弃多余的元素

fun-zipWith（f，x：：xs，y：：ys）=f（x，y）：：zipWith（f，xs，ys）
|zipWith（u，[]，[]）=[]（*两个列表的末尾*）
|zipWith（x，xs，[]）=[]（*xs更长，丢弃它*）
|zipWIth（，[]，ys）=[]（*ys更长，丢弃它*）

由于最后三种情况的反应都是相同的，我还可以写：

fun-zipWith（f，x：：xs，y：：ys）=f（x，y）：：zipWith（f，xs，ys）
|zipWith（u，u，u）=[]（*一个或两个列表为空*）

您的函数
alternate2
的行为非常相似，只是每个步骤的计算不是
f（x，y）
，因为您自然没有
f
。此外，对于
alternate2
，每对
x
和
y
不应产生一个元素，而应连续产生两个元素

- zipWith (op+, [1,2,3], [10,20,30]);
> val it = [11, 22, 33] : int list

您可以完全通过模式匹配和递归来实现这一点，而无需使用
length
、
if-then-else
或
=
。由于这个练习太小，我发现在不给出答案的情况下很难给出字面上的提示，因此我将尝试以类似的方式解决一个类似的练习：

给定一个函数
f:'a*'b->'c
和两个列表，
xs:'a list
和
ys:'b list
，我可以通过将函数
f
应用于每对
（x，y）
来创建一个结果
'z list
，其中每个
x
来自
xs code>，而每个
y
来自
ys
。如果一个列表比另一个长，我将丢弃多余的元素

fun-zipWith（f，x：：xs，y：：ys）=f（x，y）：：zipWith（f，xs，ys）
|zipWith（u，[]，[]）=[]（*两个列表的末尾*）
|zipWith（x，xs，[]）=[]（*xs更长，丢弃它*）
|zipWIth（，[]，ys）=[]（*ys更长，丢弃它*）

由于最后三种情况的反应都是相同的，我还可以写：

fun-zipWith（f，x：：xs，y：：ys）=f（x，y）：：zipWith（f，xs，ys）
|zipWith（u，u，u）=[]（*一个或两个列表为空*）

您的函数
alternate2
的行为非常相似，只是每个步骤的计算不是
f（x，y）
，因为您自然没有
f
。此外，对于
alternate2
，每对
x
和
y
不应产生一个元素，而应连续产生两个元素

- zipWith (op+, [1,2,3], [10,20,30]);
> val it = [11, 22, 33] : int list

有几种方法可以做到这一点，但我将建议一种符合函数类型的方法（
“a list*”a list->“a list”
），并严格执行两个输入列表必须具有相同大小的约束

fun交错（[]，[]）=[]
|交织（x:：xs，y:：ys）=x:：y:：交织（xs，ys）；

此函数通过模式匹配工作。在最简单的情况下，它接受两个空列表并返回一个空列表。否则，它应该有两个列表，每个列表中至少有一个项目

如果传递的两个列表长度不同，则会引发匹配异常，因为案例
（[]，y:：ys）
和
（x:：xs，[]）
与任何指定模式都不匹配

这意味着编译器可能会产生一个警告（
警告：匹配项并非详尽无遗。
），但这是经过设计的

还可以创建一个显式异常，结果如下：

异常差异长度异常；
有趣的交错（[]，[]）=[]
|交织（x:：xs，y:：ys）=x:：y:：交织（xs，ys）
|交织（xs，ys）=引发不同长度的异常；

如果将两个不同长度的列表传递给这两个函数中的任何一个，将引发异常（下面是堆栈跟踪的示例）

有几种方法可以做到这一点，但我将建议一种符合函数类型的方法（
“a list*”a list->“a list”
），并严格执行两个输入列表必须具有相同大小的约束

fun交错（[]，[]）=[]
|交织（x:：xs，y:：ys）=x:：y:：交织（xs，ys）；

此函数通过模式匹配工作。在最简单的情况下，它接受两个空列表并返回一个空列表。否则，它应该有两个列表，每个列表中至少有一个项目

如果传递了两个长度不同的列表，则会根据情况引发匹配异常