liste-recursiv, Common Lisp

liste-recursiv

(defun listae1e2(e1 e2 lista) 
     ;functia verifica daca e1 e inaintea lui e2 in lista
    (cond 
        ( (null lista) nil)
        ( (= e1 (car lista) ) t ) ;inseamna ca e1 e inaintea lui e2
        ( (= e2 (car lista) ) nil)
        ( t (listae1e2 e1 e2 (cdr lista) ) )
        );de la cond
    )

;(print (listae1e2 2 4 '(6 2 3 4 2 9) ) )
;(print (listae1e2 3 6 '(6 2 3 4 2 9) ) )
;(print (listae1e2 1 1 '(6 2 3 4 2 9) ) )

(defun aparitii(el lista)
    ;nr de aparitii ale unui element intr-o lista
    
    (cond 
        ( (null lista) 0)
        ( (= el (car lista) ) (+ 1 (aparitii el (cdr lista) )) )
        ( t (aparitii el (cdr lista) ) )
        );cond
    );fctie

;(print (aparitii 3 '(4 3 3 3 5 6 3 9) ) )
;(print (aparitii 3 '(4 3 1 3 5 6 3 9) ) )

(defun egal (l1 l2)
    (cond 
        ( (and (null l1) (null l2) ) t)
        ( (or (null l1) (null l2) ) nil) ;daca amandoua sunt null inseamna ca sunt egale
        ( (/= (car l1) (car l2) ) nil ) ;daca primele 2 elemente sunt diferite   
        ( (= (car l1) (car l2) ) (egal (cdr l1) (cdr l2) ) ) 
        );cond
    );fctie

;(print (egal '(1 2 3 4) '(1 2 3 4) ) )
;(print (egal '(1 2 3 4 5) '(1 2 3 4 7 6) ) )

;pozitia n in lista l 
(defun ninlista( n lista) 
    (cond
        ( (= n 0) nil )
        ( (= n 1) (first lista) )
        ( (> n 1) (ninlista (- n 1) (cdr lista) ) )
        )
    )

;(print (ninlista 5 '(1 2 3 4 8 7 5 34) ) )

(defun dupan (n lista) 
    (cond 
        ( (= n 0) nil )
        ( (= n 1) (cdr lista) )
        ( (> n 1) (dupan (- n 1) (cdr lista)))
        )
    );fctie

;(print (dupan 4 '(1 2 3 4 5 6 7 8 9) ) )
;(print (dupan 4 '(1 2 3 4 5 61 7 8 9) ) )

(defun copyList (l)
    (cond
        ( (null l) nil)
        ( t (cons (first l) (copyList (cdr l) ) ) )
        )
    )

;(print (copyList '(1 2 3 4 5) ) )

;(print (copyList '(1 2 3 4 5 7 7 7) ) )
;(print (copyList '(1 ) ) )

(defun appendList (l1 l2)
    (cond
        ((null l2) l1)
        (t (appendList l1 (cdr l2) ))
        (t (cons l1 (first l2) ) )
        )
    )

;9 2 1 | 2 3 4
;3 4 
;4 
;null
;(print (appendList '(9 2 1) '(2 3 4) ) )

(defun appendList2 (l1 l2)
    (cond
        ((null l1) l2)
        ((cons (first l1) (appendList2 (rest l1) l2 ) ) )
        )
    )

;(load "appendList2")
(defun inversa(l)
    (if (null l) '()
        (appendList2 (inversa (rest l) ) (list (first l) ) )
        )
    )
;(print (appendList2 '(3 4 5 ) '(1 1 2) ) )
(print (inversa '(1 2 3 4 5) ) )


run \| edit \| history \| help	0

λ

                                      .NET NoSQL database for rapid development