Question

我正在尝试使用带有两个参数的SCHEME编写代码，例如'（2 1 3）＆amp; '（a b c）并给出一个清单'（b a c）。我的代码无法递归或迭代。任何帮助!!

(define project 
(lambda (list1 list2 list3 n b index)
(define n (length(list1)))
   (let ((i n))
     (for-each (i)
        (cond 
            ((null? list1) (display "empty"))
            (else
                (define n (car list1))
                (define index (- n 1)) 
                (define b (list-ref list2 index)) 
                (define list3 (cons list3 b)) 
                (define list1 (cdr list1)) 
                list3 ))))))

Answer 1

这是一个处理任意嵌套列表的版本：首先，nested-map类似于map但处理嵌套列表：

(define (nested-map func tree)
  (if (list? tree)
      (map (lambda (x)
             (nested-map func x))
           tree)
      (func tree)))

然后，我们创建一个与它一起使用的映射器（如果列表短于16个元素，则使用list-ref，否则首先复制到向量以获得更好的可伸缩性）：

(define (rearrange indices lst)
  (define mapper (if (< (length lst) 16)
                     (lambda (i)
                       (list-ref lst (- i 1)))
                     (let ((vec (list->vector lst)))
                       (lambda (i)
                         (vector-ref vec (- i 1))))))
  (nested-map mapper indices))

请注意，在定义映射器之后，该函数只是对nested-map的单个调用。简单！ :-D

Answer 2

(define (rearrange order l)
  (cond ((number? order) (rearrange (list order) l))
        ((list?   order) (map (lambda (num) (list-ref l (- num 1))) order))
        (else 'bad-order)))

如果您需要命令为“复杂”（例如'(1 (2 3) 4)），请使用此：

(define (listify thing)
  (cond ((null? thing) '())
        ((pair? thing) (apply append (map listify thing)))
        (else (list thing))))

> (listify 10)
(10)
> (listify '(1 (2 3) 4))
(1 2 3 4)
>

然后

(define (rearrange order l)
  (map (lambda (num) (list-ref l (- num 1)))
       (listify order)))

Answer 3

首先想到的是：

(define (rearrange order symbols)
  (define (element i list)
    (if (= i 1) 
      (car list)
      (element (- i 1) (cdr list))))
  (define (iter order output)
    (if (null? order) 
      output
      (iter (cdr order) 
            (append output (list (element (car order) symbols))))))
  (iter order '()))

更好的解决方案：

(define (rearrange order symbols)
  (define (nth-element i list)
    (if (= i 1)
      (car list)
      (nth-element (- i 1) (cdr list))))
  (map (lambda (x) (nth-element x symbols)) order))

Answer 4

以下是非嵌套列表的简单版本：

(define (arrange idx lst)
  (map (lambda (i) (list-ref lst i)) idx))

(arrange '(1 0 2) '(a b c))
=> '(b a c)

如果你需要使用嵌套列表，flatten就派上用场了：

(define (arrange idx lst)
  (map (lambda (i) (list-ref lst i)) (flatten idx)))

(arrange '(1 (0 2)) '(a b c))
=> '(b a c)

请注意，我使用基于0的索引，就像Scheme中的自定义一样。

使用Scheme重新排列List中的元素

4 个答案: