Переупорядочить элементы в списке с помощью схемы

Question

Я пытаюсь написать код с использованием SCHEME, который принимает два аргумента, например '(2 1 3) &' (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

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

Первое, что пришло на ум:

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

Вот версия, которая обрабатывает произвольно вложенных списков: во-первых, nested-map это как map но ручками вложенные списки:

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

Затем мы создаем картограф для использования с ним (с помощью list-ref если список короче, чем 16 элементов, в противном случае копирования в вектор первых для лучшей масштабируемости):

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

Вот простой вариант для не- вложенные списки:

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

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

Если вам нужно использовать вложенные списки, распрямите пригождается:

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

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

Обратите внимание, что я использую индексы 0 на основе, как это принято на схеме.