List 用于打印和替换列表中的元素的函数

我试图实现两个功能：subterm和replace

subterm将两个列表作为参数，并打印在用尽第二个列表后到达的第一个列表中的元素

例如，打电话

（subterm'（12（3 4 5）（6（7（8）9 10）））（42 2 1））

应该回来

8

我提出了以下函数，用于打印列表中的第n个元素：

(define (subterm list n)                   
  (cond 
    ((null? list) '())             
    ((= n 1) (car list))              
    (else (subterm (cdr list) (- n 1)))))

replace获取3个列表，并返回将达到的值替换为列表其余部分不变的结果

例如呼叫：

 (replace '(1 2 (3 4 5) (6 (7 (8) 9 10))) '(11 12) '(4 2 2 1))

应返回：

'(1 2 (3 4 5) (6 (7 ((11 12)) 9 10)))

我再次提出了这段代码，它将第一个列表中的第n个元素替换为第二个列表，第一个列表的其余部分保持不变：

#lang racket
(define (replace list elem n)
  (cond
    ((empty? list) empty)
    ((eq? n 1) (cons elem (cdr list)))
    (#t (cons (car list) (replace (cdr list) elem (- n 1))))))

我如何修改这些函数以包含两个列表

编辑1： 一些例子：

> (subterm '(1 2 3 4 5) '(3))
3

> (subterm '(1 2 3 4 5) '(2))
2

> (subterm '(1 2 (3 4 5) 6 7) '(3 2))
4

考虑这个例子：

> (subterm '(1 2 (3 4 5) (6 (7 (8) 9 10))) '(4 2 2 1))
8

> (replace '(1 2 (3 4 5) 6 7) '(8 9) '(3 2))
'(1 2 (3 (8 9) 5) 6 7)

在上面的示例中，子项包含2个列表。然后它读取第二个列表。第二个列表基本上告诉子项返回第二个元素（（8））的第一个元素（8），第二个元素（7（8）9 10）的第四个元素（6（7（8）9 10）的第一个元素（12（3 4 5）（6（7（8）9 10）））

考虑这个例子：

> (subterm '(1 2 (3 4 5) (6 (7 (8) 9 10))) '(4 2 2 1))
8

> (replace '(1 2 (3 4 5) 6 7) '(8 9) '(3 2))
'(1 2 (3 (8 9) 5) 6 7)

替换包含三个列表：第一个列表是必须替换元素的列表。第二个列表包含必须放入第一个列表的新元素。第三个列表包含必须替换元素的位置。 因此，它基本上取代了第一个列表（12（3 4 5）6 7）中第三个元素（3 4 5）中的第二个元素（4）

---

首先，您将名称

子项

用于两个不同的函数。让我们调用您为

列表参考

提供的代码示例版本，并使

（汽车列表）

案例在

n

=0而不是1时发生：

(define (list-ref list n)                   
  (cond 
    ((null? list) '())             
    ((= n 0) (car list))              
    (else (list-ref (cdr list) (- n 1)))))

事实证明，

list ref

已经在

racket

库中，因此您不必首先真正实现它。因此，使用它，您的

子项

非常简单：

(define (subterm main-list path)
   (match path
     ('() #f)
     ((list n) (list-ref main-list (sub1 n)))
     ((cons n rest) (subterm (list-ref main-list (sub1 n)) rest))))

---

我尝试编写

replace

过程。据我所知，这是一个很难的过程。但是，我设法使它工作起来，至少使用了您给出的示例。您可以阅读它，尝试理解它，然后尝试修改它以与任何其他列表一起工作。我相信您将需要一个额外的函数使其正常工作

#lang racket
(require racket/trace)
(define (replace list elem n)
  (cond
    ((empty? list) empty)
    ((eq? n 1) (cons elem (cdr list)))
    (#t (cons (car list) (replace (cdr list) elem (- n 1))))))

(define replace-with-lists
  (λ (items replacement path res aux)
     (letrec ([splits (list-split-at items (car path) '())])
    (cond 
      ((empty? (cdr path)) 
;       (append
;        (car (list-ref res 0))
;       (list (append
;        (car (list-ref res 1))
;        (list (append (car aux) 
;               (replace (list-ref aux 1) replacement (car path))
;               (list-ref aux 2)))))))
       (let ([result (replace splits replacement 2)])
      (replace aux
               (append (car result)
              (list (cadr result))
              (caddr result)
              )
               2)))

      (else
       (replace-with-lists
             (list-ref splits 1)
             replacement
             (cdr path)
             (foldr cons (list (list 
                          (list-ref splits 0)
                          (list-ref splits 2)))
                    res)
             splits
             )))
    ))
    )

(define list-split-at
  (λ (lst place res)
    (cond
      ((empty? lst) res)
      ((= 1 place) (foldl cons
                          (list (cdr lst))
                          (foldr cons (list res) (list (car lst)))
                          ))
      (else
       (list-split-at (cdr lst) (- place 1) (foldr cons (list (car lst)) res))
       )
      )))
(trace replace-with-lists)

---

好的，我在你们的编程语言课上，我知道这项作业明天就要交了，所以我不想给你们太多帮助，也不想给你们答案。如果你们还在努力，我会尽力给你们一些提示。以下提示是关于replace函数的

首先，您需要一个基本案例

（取代“（12（3）4 5）（6（7（8）9 10）））‘x’（）） 'x

（将“1”（2 3 4）替换为（）） "(2 3 4)

为此，我们只需要一个检查空列表的条件语句。很明显，如果最后一个参数是空列表，我们需要“返回”倒数第二个参数。（在您的代码中，这将是“elem”和“n”）

现在是困难的部分。当你意识到scheme/racket有多少内置函数时，这真的很简单。这里是我唯一使用的函数，但它们使解决问题变得更容易

（附加） （名单） （采取行动） （下降） （列表参考）//这个比什么都方便

交工日期过后，我将发布我的解决方案。希望这能有所帮助

编辑：由于这项作业需要几分钟的时间，我将发布我的解决方案，因为我认为这不会被视为作弊

朗格球拍 ​

---

这两个都是函数。

当你说这些函数时，你指的是什么？有可能使

replace

的算术等于2吗？在我看来，你似乎遗漏了一些需要解释的内容。@DavidMerinos:这些函数意味着子项和replace。为了清晰起见，我添加了一些示例。谢谢！好的。我明白了函数的作用，但您的问题到底是什么？是否希望

replace

只包含两个列表？@DavidMerinos:不，我希望replace和subterm与示例中的一样工作。我编写了类似的函数，但它们只能包含一个列表和一个数字作为参数。@DavidMerinos:在这两个函数中，第二个列表都用于在类似于f的树中向下移动从第一个列表开始。在第一个列表的每个级别上，使用第二个列表中的一个数字原子。此原子将指示从左到右的顺序位置以继续。子项应返回值（原子或列表）当第二个列表已用尽时，将达到该值。replace应返回替换所达到值的结果，而第一个列表的其余部分应保持不变。对replace函数有何想法？

(define (subterm term1 lat)
  (cond
    [(eqv? lat '()) term1]
    [(eqv? (car lat)1) (subterm (car term1) (cdr lat))]
    [else (subterm (cdr term1) (cons(-(car lat)1)(cdr lat)))])
  )

(define (replace term1 term2 lat)
  (cond
    [(eqv? lat '()) term2]
    [else (append(take term1 (-(car lat)1)) (list(replace (list-ref term1 (-(car lat)1)) term2 (cdr lat))) (drop term1 (car lat)))]))