2

我正在尝试实现两个功能：subterm 和 replace。

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

例如，调用

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

应该返回

8

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

(define (subterm list n)                   
  (cond 
    ((null? list) '())             
    ((= n 1) (car list))              
    (else (subterm (cdr list) (- n 1)))))
  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

在上面的示例中， subterm 需要 2 个列表。然后它读取第二个列表。第二个列表基本上告诉 subterm 返回第 1 个元素 (8) 第 2 个元素 ((8)) 第 2 个元素 (7 (8) 9 10) 第 4 个元素 (6 (7 (8) 9 10)第一个列表 (1 2 (3 4 5) (6 (7 (8) 9 10)))。

> (subterm '1 '())
1

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

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

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

考虑这个例子：

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

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

> (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)))

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

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

> (replace '1 '(2 3 4) '())
'(2 3 4)
4

3 回答 3

1

首先，您将名称subterm用于两个不同的功能。让我们调用您提供的代码示例的版本list-ref，并在= 0 而不是 1(car list)时发生这种情况：n

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

事实证明，list-ref它已经在racket库中，所以你不应该真的必须首先实现它。所以使用它，你subterm是微不足道的：

(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))))
于 2015-04-07T04:31:49.833 回答
0

好的，我在你的编程语言课上，我知道这个作业明天就要交了，所以我不想提供太多帮助，也不想给你答案。如果你还在苦苦挣扎，我会尽力给你一些提示。以下提示适用于替换功能。

首先，您需要一个基本案例。我们得到了以下内容

（替换'（1 2（3 4 5）（6（7（8）9 10）））'x'（））'x

（替换'1'（2 3 4）'（））'（2 3 4）

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

现在是困难的部分。一旦您意识到方案/球拍有多少内置功能，这真的很简单。这是我唯一使用的，但它们使解决问题变得容易得多。

(append) (list) (take) (drop) (list-ref) //这个比什么都方便。

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

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

郎球拍

(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)))]))

​</p>

这两个功能。

于 2015-04-09T02:18:36.913 回答
0

我试图编写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)
于 2015-04-07T06:52:39.847 回答