;; General backtracking program

(define solve
  (lambda (*initial* *complete?* *extensions* *first* 
                     *rest* *empty?* *extend* *legal?* *return*)
    (letrec ([try
              (lambda (psol choices k q)
                (if (*complete?* psol) (k psol)
                    (if (*empty?* choices) (q)
                        (let ([new-psol (*extend* psol (*first* choices))])
                          (if (*legal?* new-psol)
                              (try new-psol (*extensions* new-psol) k
                                   (lambda () 
                                     (try psol (*rest* choices) k q)))
                              (try psol (*rest* choices) k q))))))])
      (try *initial* (*extensions* *initial*) *return*
           (lambda () 'failed)))))

;; Below are definitions specific to the good sequences problem
;; good sequences problem

(define goodseq
  (lambda (n)
    (solve initial (complete? n) extensions first 
                     rest empty? extend legal? return)))

(define initial ())
(define complete? (lambda (len) (lambda (x) (= (length x) len))))
(define extensions (lambda (x) 3))
(define first (lambda (x) x))
(define rest (lambda (x) (1- x)))
(define return (lambda (x) x))
(define empty? zero?)
(define extend (lambda (x y) (cons y x)))

(define legal?
  (lambda (str) 
    (let legal1 ([left (list (car str))]
                 [right (cdr str)])
      (if (null? right) #t
          (if (check left right) #f
              (legal1 (append left (list (car right))) (cdr right)))))))

(define check
  (lambda (pat dat)
    (if (null? pat) #t
        (if (null? dat) #f
            (if (eq? (car pat) (car dat)) (check (cdr pat) (cdr dat))
                #f)))))