역 목록 체계

Question

나는 목록을 반대하기 위해 노력하고있어

, 여기 내 코드입니다 : 내가 입력하면, 나는 그것이로 나올 할 (역 (1 2 3 4) ') 그래서

(define (reverse list) 
    (if (null? list) 
    list 
     (list (reverse (cdr list)) (car list)))) 

(4 3 2 1),하지만 지금은 내게 그렇게주지 않습니다. 내가 뭘 잘못하고 어떻게 해결할 수 있니?

Answer 1

목록을 반복적으로 사용하는 것이이 문제를 해결하는 최선의 방법은 아닙니다. @lancery가 지적한 인정 된 답변에서 제안한대로 append을 사용하면 좋은 생각이 아닙니다. Scheme에서 자신의 길을 배우는 중이라면 솔루션을 직접 구현하려고 할 때 가장 좋습니다. do, but first tips - list을 매개 변수 이름으로 사용하지 마십시오. 내장 프로 시저이므로 덮어 쓰게됩니다. 다른 이름 (예 : lst)을 사용하십시오.

그것은 결과의 머리에서 각 요소는이 목록을 반전의 영향을 미칠 것 consing의 결과를 축적하는 도우미 절차에 의해 목록을 반대로 간단 - 또한, 도우미 절차는 꼬리 - 재귀 적. 여기에 일반적인 생각이야, 채우기에 공백 :

물론

(define (reverse lst) 
    (<???> lst '()))      ; call the helper procedure 

(define (reverse-aux lst acc) 
    (if <???>        ; if the list is empty 
     <???>        ; return the accumulator 
     (reverse-aux <???>     ; advance the recursion over the list 
        (cons <???> <???>)))) ; cons current element with accumulator 

, 실제 생활에서 처음부터 reverse를 구현하지 것이다, 거기에 내장 된 그것에 대해 procedure. 오스카의 유사

(define reverse 
    (lambda (l) 
    (let ((len (length l))) 
     (build-list len 
        (lambda (i) 
        (list-ref l (- len i 1))))))) 

Answer 2

여기 build-list 절차를 사용하여 솔루션입니다. 나는 방금 학습 계획을 시작 했으니 까, 그래서 당신이 문제를 찾으면 저를 실례합니다 :).

Answer 3

(define reverse? 
    (lambda (l) 
    (define reverse-aux? 
     (lambda (l col) 
     (cond 
      ((null? l) (col)) 
      (else 
      (reverse-aux? (cdr l) 
          (lambda() 
          (cons (car l) (col)))))))) 
    (reverse-aux? l (lambda() (quote()))))) 
(reverse? '(1 2 3 4)) 

하나 더 대답 :

Answer 4

이 하나가 작동하지만이 꼬리 재귀 절차되지 않습니다 : 추가 또는 람다의 무리와 함께 몸을 채우는 필요는 실제로 없다

(define (rev lst) 
(if (null? lst) 
    '() 
     (append (rev (cdr lst)) (car lst)))) 

Answer 5

.

는

(define (reverse items) 
    (if (null? items) 
     '() 
     (cons (reverse (cdr items)) (car items)))) 

Answer 6

꼬리 재귀 적 접근 방식을 사용하여 let 이름 :

(define (reverse lst) 
    (let loop ([lst lst] [lst-reversed '()]) 
    (if (empty? lst) 
     lst-reversed 
     (loop (rest lst) (cons (first lst) lst-reversed))))) 

이 let가 만드는 후 loop 바인딩 오스카의 대답에서와 같이 누적 기 인수 도우미 기능을 갖는 같은 접근 방식은 기본적으로 당신이 부를 수있는 내적인 기능을 맡아 라.

Answer 7

내가 대신 단점

(define (myrev l) 
    (if (null? l) 
     '() 
     (append (myrev (cdr l)) (list (car l))) 
) 
) 

이 꼬리 재귀 여기

(define (myrev2 l) 
    (define (loop l acc) 
    (if (null? l) 
     acc 
     (loop (cdr l) (append (list (car l)) acc)) 
    ) 
) 
    (loop l '()) 
) 

Answer 8

또 다른 버전은 반복적 인 과정을 설명하는 재귀 절차 (꼬리 재귀)의 추가 사용하는 것이 더 좋을 것 같아 Scheme에서 목록을 반대로 바꾸는 방법

(define (reverse lst) 
    (define (go lst tail) 
    (if (null? lst) tail 
     (go (cdr lst) (cons (car lst) tail)))) 
    (go lst()))) 

EVERSE (리스트 1 2 3 4)) 여기서

;; (reverse (list 1 2 3 4))                               
;; (go (list 1 2 3 4)())                                
;; (go (list 2 3 4) (list 1))                               
;; (go (list 3 4) (list 2 1))                               
;; (go (list 4) (list 3 2 1))                               
;; (go() (list 4 3 2 1))                                
;; (list 4 3 2 1) 

은 (reverse2위한 교체 모델을 사용하여 반응식

(define (reverse2 lst) 
    (if (null? lst)() 
    (append (reverse2 (cdr lst)) (list (car lst))))) 

(define (append l1 l2) 
    (if (null? l1) l2 
     (cons (car l1) (append (cdr l1) l2)))) 

의 목록을 반전 재귀 프로세스 (꼬리없는 재귀)를 설명하는 재귀 절차 (목록 1 2 3 4))

;; (reverse2 (list 1 2 3 4))                               
;; (append (reverse2 (list 2 3 4)) (list 1))                           
;; (append (append (reverse2 (list 3 4)) (list 2)) (list 1))                       
;; (append (append (append (reverse2 (list 4)) (list 3)) (list 2)) (list 1))                   
;; (append (append (append (append (reverse2()) (list 4)) (list 3)) (list 2)) (list 1))                
;; (append (append (append (append() (list 4)) (list 3)) (list 2)) (list 1))                   
;; (append (append (append (list 4) (list 3)) (list 2)) (list 1))                      
;; (append (append (list 4 3) (list 2)) (list 1))                          
;; (append (list 4 3 2) (list 1))                              
;; (list 4 3 2 1)