List 两个长度相同的输入列表与长度不同的输入列表的行为不同（方案）

代码“tsFunc”获取两个列表作为输入，并将两个列表中的每个元素配对。 它在大多数情况下都有效。 但是当我给出两个相同长度的列表时，我发现有一点奇怪的行为（例如，“（12）”（34）…或“（abc）”（1233）…，它的工作原理很奇怪。首先，这里是代码

[问题1]

（定义（tsFunc lst1 lst2）
（定义（辅助对象ls1 ls2 rst）
（相反（如果（或（空？ls1）（空？ls2））
rst
（助手（cdr ls1）（cdr ls2）
（cons（cons（ls1车）（ls2车））rst()())）
（辅助对象lst1 lst2’（））

这样的行为：

1） 列表长度不均匀时的正确行为： （tsFunc'（123b））==>输出：（（1.a）（2.b））

2） 列表长度为偶数的奇怪行为 ：（tsFunc'（1.23）'（a b c））==>输出（错误）：（（3.c）（2.b）（1.a）） =>预期：（（1.a）（2.b）（3.c））

当两个输入列表长度相同时，会发生什么情况？ 相同长度的输入列表与不同长度的输入列表之间，tsFunc逻辑的行为是否不同？ （注意。正如我所知，代码需要有“反向”才能得到最终结果。所以这不是因为代码中有“反向”）

[问题2]对于tsFunc=>tsFunc结果：（1.2）（3.4）=>尝试实现这样的产品（1*2）+（3*4）=14，所以我喜欢这样

（定义（函数l1-l2）
（tsFunc（l1-l2）；；第2行-如何调用tsFunc的结果？？
（foldl（lambda（acc对）；；第3行
（+acc（*（车对）（cdr对））；；第4行
'()
l1（l2））；；这样地？？或

---

第3行，第4行，好的..这就是要做的逻辑，然后，如何调用tsFunc结果将其用作输入和。。最后一行有两个列表。。不清楚

第一个问题是，在每次迭代中都要不断地反转列表，如果确实需要反转输出，那么在结束时只执行一次：

(define (tsFunc lst1 lst2)
  (define (helper ls1 ls2 rst)
    (if (or (null? ls1) (null? ls2))
        (reverse rst)
        (helper (cdr ls1) (cdr ls2)
                (cons (cons (car ls1) (car ls2)) rst))))
  (helper lst1 lst2 '()))

现在，对于第二个问题，代码甚至没有编译：您没有正确地调用

tsFunc

过程，并且调用它的位置错误。此外，累加器参数的初始值错误-如果要返回数字，则不能使用列表：

(define (func l1 l2)
  (foldl (lambda (acc pair)
           (+ acc (* (car pair) (cdr pair))))
         0
         (tsFunc l1 l2)))

使用问题中的示例输入，下面是它的工作原理：

(func '(1 3) '(2 4))
=> 14

---

在上面的

tsFunc

将

'（13）

和

'（24）

作为输入，将它们转换为

'（（1.2）（3.4））

，然后

foldl

按照预期执行操作

（1*2）+（3*4）=14

。

第一个问题是，您在每次迭代时都要不断地反转列表，如果确实需要反转输出，请在结束时只执行一次：

(define (tsFunc lst1 lst2)
  (define (helper ls1 ls2 rst)
    (if (or (null? ls1) (null? ls2))
        (reverse rst)
        (helper (cdr ls1) (cdr ls2)
                (cons (cons (car ls1) (car ls2)) rst))))
  (helper lst1 lst2 '()))

现在，对于第二个问题，代码甚至没有编译：您没有正确地调用

tsFunc

过程，并且调用它的位置错误。此外，累加器参数的初始值错误-如果要返回数字，则不能使用列表：

(define (func l1 l2)
  (foldl (lambda (acc pair)
           (+ acc (* (car pair) (cdr pair))))
         0
         (tsFunc l1 l2)))

使用问题中的示例输入，下面是它的工作原理：

(func '(1 3) '(2 4))
=> 14

---

在上面的

tsFunc

将

'（13）

和

'（24）

作为输入，将它们转换为

'（（1.2）（3.4））

，然后

foldl

按照预期执行操作

（1*2）+（3*4）=14

。

第一个问题是，您在每次迭代时都要不断地反转列表，如果确实需要反转输出，请在结束时只执行一次：

(define (tsFunc lst1 lst2)
  (define (helper ls1 ls2 rst)
    (if (or (null? ls1) (null? ls2))
        (reverse rst)
        (helper (cdr ls1) (cdr ls2)
                (cons (cons (car ls1) (car ls2)) rst))))
  (helper lst1 lst2 '()))

现在，对于第二个问题，代码甚至没有编译：您没有正确地调用

tsFunc

过程，并且调用它的位置错误。此外，累加器参数的初始值错误-如果要返回数字，则不能使用列表：

(define (func l1 l2)
  (foldl (lambda (acc pair)
           (+ acc (* (car pair) (cdr pair))))
         0
         (tsFunc l1 l2)))

使用问题中的示例输入，下面是它的工作原理：

(func '(1 3) '(2 4))
=> 14

---

在上面的

tsFunc

将

'（13）

和

'（24）

作为输入，将它们转换为

'（（1.2）（3.4））

，然后

foldl

按照预期执行操作

（1*2）+（3*4）=14

。

第一个问题是，您在每次迭代时都要不断地反转列表，如果确实需要反转输出，请在结束时只执行一次：

(define (tsFunc lst1 lst2)
  (define (helper ls1 ls2 rst)
    (if (or (null? ls1) (null? ls2))
        (reverse rst)
        (helper (cdr ls1) (cdr ls2)
                (cons (cons (car ls1) (car ls2)) rst))))
  (helper lst1 lst2 '()))

现在，对于第二个问题，代码甚至没有编译：您没有正确地调用

tsFunc

过程，并且调用它的位置错误。此外，累加器参数的初始值错误-如果要返回数字，则不能使用列表：

(define (func l1 l2)
  (foldl (lambda (acc pair)
           (+ acc (* (car pair) (cdr pair))))
         0
         (tsFunc l1 l2)))

使用问题中的示例输入，下面是它的工作原理：

(func '(1 3) '(2 4))
=> 14

---

在上面的

tsFunc

将

'（13）

和

'（24）

作为输入，将它们转换为

'（（1.2）（3.4））

，然后

foldl

按预期执行操作

（1*2）+（3*4）=14

。

既然允许使用高阶函数，为什么不使用

fold

#!r6rs

(import (rnrs base)
        (only (srfi :1) fold)) ;; srfi-1 fold stop at the shortest list 

(define (func lst1 lst2)
  (fold (lambda (x y acc)
          (+ acc (* x y)))
        0
        lst1
        lst2))


(func '(1 3) '(2 4 8)) ; ==> 14

---

既然您可以使用更高阶的函数，为什么不只使用

折叠

#!r6rs

(import (rnrs base)
        (only (srfi :1) fold)) ;; srfi-1 fold stop at the shortest list 

(define (func lst1 lst2)
  (fold (lambda (x y acc)
          (+ acc (* x y)))
        0
        lst1
        lst2))


(func '(1 3) '(2 4 8)) ; ==> 14

---

既然您可以使用更高阶的函数，为什么不只使用

折叠

#!r6rs

(import (rnrs base)
        (only (srfi :1) fold)) ;; srfi-1 fold stop at the shortest list 

(define (func lst1 lst2)
  (fold (lambda (x y acc)
          (+ acc (* x y)))
        0
        lst1
        lst2))


(func '(1 3) '(2 4 8)) ; ==> 14

---

既然您可以使用更高阶的函数，为什么不只使用

折叠

#!r6rs

(import (rnrs base)
        (only (srfi :1) fold)) ;; srfi-1 fold stop at the shortest list 

(define (func lst1 lst2)
  (fold (lambda (x y acc)
          (+ acc (* x y)))
        0
        lst1
        lst2))


(func '(1 3) '(2 4 8)) ; ==> 14

---

好像你每次都在倒车。当您准备返回蓄能器时，只需倒车。似乎您每次都在倒车。当您准备返回蓄能器时，只需倒车。似乎您每次都在倒车。当您准备返回蓄能器时，只需倒车。似乎您每次都在倒车。当你准备返回蓄能器时，只需反转。是的，你是对的。这是我真正没有的第二个问题