勿在浮沙筑高台--由LISP公理推导函数的几个练习

/db_自贡黄明儒_ · 发表于 2013-5-21 21:05:15

本帖最后由 /db_自贡黄明儒_ 于 2013-5-21 21:11 编辑

牢固发表于 2013-5-21 18:31
第二个条件的写法多余，直接 y就ok了！看楼上我的回复！

G版就是高！！！

redcat2012 · 发表于 2013-6-1 10:53:47

(defun Pair (x y)
(mapcar 'cons x y)
) ;_ 结束defun
(defun assoc# (x list_)
(if (equal x (caar list_))
(car list_)
(assoc# x (cdr list_))
) ;_ 结束if
) ;_ 结束defun
(defun Append# (x list_)
(if x
(cons (car x) (Append# (cdr x) list_))
list_
) ;_ 结束if
) ;_ 结束defun

redcat2012 · 发表于 2013-6-21 14:02:17

redcat2012 发表于 2013-6-1 10:53

(defun pair (x y)
(if (and (cdr x) (cdr y))
(cons (cons (car x) (car y))
(pair (cdr x) (cdr y))
)
(list (cons (car x) (car y)))
)
)

13808843088 · 发表于 2013-6-21 17:33:56

我也来一个pair

(defun Pair (x y)
(cond ((cond (x
(cond (y t)
(t nil)
)
)
(t nil)
)
(cons (cons (car x) (cons (car y) nil))
(Pair (cdr x) (cdr y))
)
)
(t nil)
)
)

13808843088 · 发表于 2013-6-21 17:54:19

迷惑了，请问H版数学函数是怎么推导出来的

wowan1314 · 发表于 2013-7-27 21:06:22

本帖最后由 wowan1314 于 2013-7-27 21:48 编辑

递归又忘了怎么用了！表反了的用我写的REVERSE#函数处理下。但是大写就没办法了。。。

;(subst# 'm 'b '(a b (a b c) d D))
;最多套三层....
(defun subst# (a b c / a b c d e)
(defun subst3# (a b c / d )
(cond
((setq d (car c))
(cond
((atom d)
(cond
((eq d b)
(setq g (cons a g))
(subst3# a b (cdr c))
)
(t (setq g(cons d g))(subst3# a b (cdr c))
)
)
)
)
)
)
g
)
(defun subst2# (a b c / d g)
(cond
((setq d (car c))
(cond
((atom d)
(cond
((eq d b)
(setq f(cons a f))
(subst2# a b (cdr c))
)
(t (setq f(cons d f))(subst2# a b (cdr c))
)
)
)
(t (setq f (cons (subst3# a b d) f))(subst2# a b (cdr c))
)
)
)
)
f
)
(defun subst1# (a b c / d f)
(cond
((setq d (car c))
(cond
((atom d)
(cond
((eq d b)
(setq e(cons a e))
(subst1# a b (cdr c))
)
(t (setq e(cons d e))(subst1# a b (cdr c))
)
)
)
(t (setq e (cons (subst2# a b d) e))(subst1# a b (cdr c))
)
)
)
)
e
)
(subst1# a b c)
)

;(subst# 'm 'b '(a b (a b c) d D)) 
;最多套三层.... 
(defun subst# (a b c / a b c d e) 
    (defun subst3# (a b c / d ) 
        (cond 
            ((setq d (car c)) 
                (cond 
                    ((atom d) 
                        (cond 
                            ((eq d b) 
                                (setq g (cons a g)) 
                                (subst3# a b (cdr c)) 
                            ) 
                            (t (setq g(cons d g))(subst3# a b (cdr c)) 
                            ) 
                        ) 
                    ) 
                ) 
            ) 
        ) 
        g 
    ) 
    (defun subst2# (a b c / d g) 
        (cond 
            ((setq d (car c)) 
                (cond 
                    ((atom d) 
                        (cond 
                            ((eq d b) 
                                (setq f(cons a f)) 
                                (subst2# a b (cdr c)) 
                            ) 
                            (t (setq f(cons d f))(subst2# a b (cdr c)) 
                            ) 
                        ) 
                    ) 
                    (t (setq f (cons (subst3# a b d) f))(subst2# a b (cdr c)) 
                    ) 
                ) 
            ) 
        ) 
        f 
    ) 
    (defun subst1# (a b c / d f) 
        (cond 
            ((setq d (car c)) 
                (cond 
                    ((atom d) 
                        (cond 
                            ((eq d b) 
                                (setq e(cons a e)) 
                                (subst1# a b (cdr c)) 
                            ) 
                            (t (setq e(cons d e))(subst1# a b (cdr c)) 
                            ) 
                        ) 
                    ) 
                    (t (setq e (cons (subst2# a b d) e))(subst1# a b (cdr c)) 
                    ) 
                ) 
            ) 
        ) 
        e 
    ) 
    (subst1# a b c) 
)

;;(reverse# '(1 2 3 4 5))
;;==>(5 4 3 2 1)
(defun reverse# (a / c)
(defun reverse1# (a / b)
(cond
((setq b (car a)) (setq c (cons b c))(reverse1# (cdr a))
)
)
c
)
(reverse1# A)
)

(defun and# (a b)
(cond
((eq a nil) nil)
((eq b nil) nil)
(t t)
)
)
(defun or# (a b)
(cond
((and#(eq a nil)(eq b nil)) nil)
(t t)
)
)
(defun not# (a)
(cond
((eq a nil) T)
(t nil)
)
)
(defun assoc# (a b / c d)
(cond
((setq c (car b))
(cond
((eq a (car c))
(setq d (cadr c))
)
(t (assoc# a (cdr b))
)
)
)
)
d
)
;(append# '(1 2 3) (4 5))
;===> (3 2 1 4 5) 这个反的可以么？？
(defun append# (a b / c)
(cond
((setq c (car a))
(setq b (cons c b) a (cdr a))
(setq B (append# a b))
)
)
b
)
;(pair '(x y z) '(a b c))
;==>((Z . C) (Y . B) (X . A)) 不但是反的还是大写了？
(defun pair (a b / e pair1)
(defun pair1 (a b / c d)
(cond
((and# (setq c (car a)) (setq d (car b))
)
(setq e (cons (cons c d) e))
(pair1 (cdr a) (cdr b))
)
)
e
)
(pair1 a b)
)
;(subst# 'm 'b '(a b a b c d))
;==>(D C M A M A) 不但是反的还是大写了？
;多层表没弄出来。。可能是递归还没掌握好。
(defun subst# (a b c / a b c d e)
(defun subst1# (a b c / d )
(cond
((setq d (car c))
(cond
((atom d)
(cond
((eq d b)
(setq e(cons a e))
(subst1# a b (cdr c))
)
(t (setq e(cons d e))(subst1# a b (cdr c))
)
)
)
(t (setq e (cons (subst1# a b d) e))
)
)
)
)
e
)
(subst1# a b c)
)

(defun and# (a b) 
    (cond 
        ((eq a nil) nil) 
        ((eq b nil) nil) 
        (t t) 
    ) 
) 
(defun or# (a b) 
    (cond 
        ((and#(eq a nil)(eq b nil)) nil) 
        (t t) 
    ) 
) 
(defun not# (a) 
    (cond 
        ((eq a nil) T) 
        (t nil) 
    ) 
) 
(defun assoc# (a b / c d) 
    (cond 
        ((setq c (car b)) 
            (cond 
                ((eq a (car c)) 
                    (setq d (cadr c)) 
                ) 
                (t (assoc# a (cdr b)) 
                ) 
            ) 
        ) 
    ) 
    d 
) 
;(append# '(1 2 3) (4 5)) 
;===> (3 2 1 4 5) 这个反的可以么？？ 
(defun append# (a b / c) 
    (cond 
        ((setq c (car a)) 
            (setq b (cons c b) a (cdr a)) 
            (setq B (append# a b)) 
        ) 
    ) 
    b 
) 
;(pair '(x y z) '(a b c))    
;==>((Z . C) (Y . B) (X . A))  不但是反的还是大写了？ 
(defun pair (a b / e pair1) 
    (defun pair1 (a b / c d) 
        (cond 
            ((and# (setq c (car a)) (setq d (car b)) 
                ) 
                (setq e (cons (cons c d) e)) 
                (pair1 (cdr a) (cdr b)) 
            ) 
        ) 
        e 
    ) 
    (pair1 a b) 
) 
;(subst# 'm 'b '(a b a b c d)) 
;==>(D C M A M A) 不但是反的还是大写了？ 
;多层表没弄出来。。可能是递归还没掌握好。 
(defun subst# (a b c / a b c d e) 
    (defun subst1# (a b c / d ) 
        (cond 
            ((setq d (car c)) 
                (cond 
                    ((atom d) 
                        (cond 
                                ((eq d b) 
                                        (setq e(cons a e)) 
                                (subst1# a b (cdr c)) 
                            ) 
                            (t (setq e(cons d e))(subst1# a b (cdr c)) 
                            ) 
                        ) 
                    ) 
                    (t (setq e (cons (subst1# a b d) e)) 
                    ) 
                ) 
            ) 
        ) 
        e 
    ) 
    (subst1# a b c) 
)

ngc · 发表于 2014-1-18 21:58:34

学习了，还要继续看书，好多不懂的

账号		自动登录	找回密码
密码			立即注册

[研讨] 勿在浮沙筑高台--由LISP公理推导函数的几个练习

点评

评分

点评

浏览过的版块