Add solution from 10 to 28

parent 4bc07b72
(defun my_last (lista)
(if (null lista)
nil
(if (null (rest lista))
lista ; testa se a lista so tem um elemento
(my_last (rest lista)) ; recursao no resto da lista
)
)
)
(defun penultimo (lista)
(let ((reverso (reverse lista))) ; coloca na variavel reverso o
; reverse de lista
(cond
((null reverso) nil)
;; se a lista tem 2 ou menos elementos, retorno a propria
((<= (length reverso) 2)  lista)
;; se tiver mais de 2 elementos, construo uma lista
(t (list (second reverso) (first reverso)))
)
)
)
;;; Função que retorna o elemento na K-ésima posição de ;;;
;;; uma lista. Se a posição desejada eh maior que a ;;;
;;; última da lista, retorna NIL. ;;;
(defun element-at (org-list pos &optional (ini 1))
(if (eql ini pos)
(car org-list)
(element-at (cdr org-list) pos (+ ini 1))))
;;; Outra solucao
(defun element-at (lista n)
(if (= n 1)
;; o primeiro elemento esta na posicao 1
(first lista)
(element-at (rest lista) (1- n))
)
)
(defun comprimento (lista)
(if (null lista)
0
(1+ (comprimento (rest lista)))))
(defun inverte (lista)
(inverte-aux lista () )
)
(defun inverte-aux (lista resto)
(if (null lista)
resto
(inverte-aux (rest lista) (cons (first lista) resto) )
)
)
(defun palin (lista)
(equal lista (reverse lista))
)
;;; Recebe uma lista e retorna uma lista que, no lugar dos ;;;
;;; elementos que são sub-listas, possui os elementos dessas ;;;
;;; sub-listas, recursivamente. ;;;
(defun flatten (orig-list)
(if (eql orig-list nil)
nil
(let ((elem (car orig-list)) (resto-list (cdr orig-list)))
(if (listp elem)
(append (flatten elem) (flatten resto-list))
(append (cons elem nil) (flatten resto-list))))))
(defun compress (lista)
(cond
((null lista) nil)
((null (cdr lista)) lista)
;; se o primeiro elemento (de lista) e' igual ao consecutivo
;; (primeiro do resto)
((eql (first lista) (first (rest lista)))
;; entao ignora-se o primeiro da lista e continua recursivamente no resto
(compress (rest lista)))
(t (cons (first lista) (compress (rest lista))))
)
)
(defun pack (lista)
(if (eql lista nil)
nil
(cons (pega lista) (pack (tira lista)))
)
)
(defun pega (lista)
(cond ((eql lista nil) nil)
((eql (cdr lista) nil) lista)
((equal (car lista) (cadr lista))
(cons (car lista) (pega (cdr lista))))
(t (list (car lista)))
)
)
(defun tira (lista)
(cond ((eql lista nil) nil)
((eql (cdr lista) nil) nil)
((equal (car lista) (cadr lista))
(tira (cdr lista)))
(t (cdr lista))
)
)
(defun encode (lista)
(if (eql lista nil)
nil
(cons (list (length (pega lista)) (car lista)) (encode (tira lista)))
)
)
(defun pega (lista)
(cond ((eql lista nil) nil)
((eql (cdr lista) nil) lista)
((equal (car lista) (cadr lista))
(cons (car lista) (pega (cdr lista))))
(t (list (car lista)))
)
)
(defun tira (lista)
(cond ((eql lista nil) nil)
((eql (cdr lista) nil) nil)
((equal (car lista) (cadr lista))
(tira (cdr lista)))
(t (cdr lista))
)
)
(defun encode (lista)
(if (eql lista nil)
nil
(if (= (length (pega lista)) 1 )
(cons (car lista) (encode (tira lista)))
(cons (list (length (pega lista)) (car lista)) (encode (tira lista))))
)
)
(defun pega (lista)
(cond ((eql lista nil) nil)
((eql (cdr lista) nil) lista)
((equal (car lista) (cadr lista))
(cons (car lista) (pega (cdr lista))))
(t (list (car lista)))
)
)
(defun tira (lista)
(cond ((eql lista nil) nil)
((eql (cdr lista) nil) nil)
((equal (car lista) (cadr lista))
(tira (cdr lista)))
(t (cdr lista))
)
)
(defun dupli (lista)
(if (eql lista nil)
nil
(append (list (car lista) (car lista)) ( dupli (cdr lista)))
)
)
(dupli '(1 2 3 4 5 6 7 8))
\ No newline at end of file
(defun dupli (lista int &optional (ini int))
(cond ((eql lista nil) nil)
((<= int 0) (dupli (cdr lista) ini ini))
(t (cons (car lista) (dupli lista (1- int) ini )))
)
)
\ No newline at end of file
;;; Função que recebe uma lista e uma posição e retorna ;;;
;;; outra lista contendo os elementos ate e inclusive ;;;
;;; posicao indicada. ;;;
(defun split (pos org-list &optional (ini 0))
(if (> pos ini)
(cons (car org-list) (split pos (cdr org-list) (+ ini 1)))))
;;; Função que recebe uma lista e uma posição e retorna ;;;
;;; outra lista contendo os elementos apos a posicao ;;;
;;; indicada. ;;;
(defun split-after (pos org-list &optional (ini 0))
(if (> pos ini)
(split-after pos (cdr org-list) (+ ini 1))
org-list))
;;; Função que remove o elemento em uma dada posicação da ;;;
;;; lista. Retorna a nova lista sem o elemento em questão ;;;
(defun remove-at (org-list pos &optional (ini 1))
(if (eql pos ini)
(cdr org-list)
(cons (car org-list) (remove-at (cdr org-list) pos (+ ini 1)))))
;;; Função que recebe um elemento, uma lista e uma posição ;;;
;;; e retorna uma nova lista que contém o elemento na ;;;
;;; desejada. Se a posição pedida é maior que a última da ;;;
;;; lista, insere no final da lista. ;;;
(defun insert-at (elem org-list pos)
(if (or (eql pos 1) (eql org-list nil))
(cons elem org-list)
(cons (car org-list) (insert-at elem (cdr org-list) (- pos 1)))))
;;; Função que gera uma lista contendo todos os inteiros em ;;;
;;; um dado intervalo. Se o inicio é menor que o final, gera ;;;
;;; um lista decrescente ;;;
(defun range (ini fim)
(if (> ini fim)
;; Se a lista é de um número maior para um menor ;;
(if (eql ini fim)
(cons fim nil)
(cons ini (range (- ini 1) fim)))
;; Se a lista é de um número menor para um maior ;;
(if (eql ini fim)
(cons fim nil)
(cons ini (range (+ ini 1) fim)))))
(load "p03.lisp")
(load "p20.lisp")
;;; Função que recebe uma lista de opções e um número de ;;;
;;; elementos a serem sorteados, retornando uma lista com ;;;
;;; os elementos que são sorteados. Se o número de ;;;
;;; elementos pedidos for maior que o número de elementos ;;;
;;; o comportamento é indefinido. ;;;
(defun rnd-select (org-list num &optional (selected 0))
(if (eql num selected)
nil
(let ((rand-pos (+ (random (length org-list)) 1)))
(cons (element-at org-list rand-pos) (rnd-select (remove-at org-list rand-pos) num (+ selected 1))))))
(load "p22.lisp")
(load "p23.lisp")
;;; Junta duas outras funções para produzir o resultado desejado ;;;
(defun lotto-select (num-elem max-elem)
(rnd-select (range 1 max-elem) num-elem))
(load "p20.lisp")
(load "p23.lisp")
;;; Funo que gera uma permutao randmica de uma lista ;;;
(defun rnd-permu (org-list)
(if (null org-list)
()
(let ((rand-pos (+ (random (length org-list) 1))))
(cons (element-at org-list rand-pos)
(rnd-permu (org-list)))
(load "p17.lisp")
;;; Funo que recebe uma lista L1 e o nmero de elementos (NE) ;;;
;;; e retorna uma lista com todas as combinaes de L1, NE a NE ;;;
(defun combination (n-elem org-list)
(let ((num-elem (- n-elem 1)))
(if (or (> num-elem (length org-list)) (< n-elem 2))
nil
(let ( (elem-list (split num-elem org-list)) (rest-list (split-after num-elem org-list)))
(append (combination-lista-elem elem-list rest-list) (combination n-elem (cdr org-list)))))))
;;; Funo auxiliar responsvel por criar combinaes de uma lista ;;;
;;; com todos os elementos de outra. ;;;
(defun combination-lista-elem (elem-list org-list)
(if (eql org-list nil)
nil
(append (list (append elem-list (list (car org-list)))) (combination-lista-elem elem-list (cdr org-list)))))
(load "p07.lisp")
(load "p26.lisp")
;;; Subtrai o conjunto B do conjunto A e eetorna S = A - B ;;;
(defun remove-lista (orig-list elem-list)
(if (eql elem-list nil)
orig-list
(remove-lista (remove (car elem-list) orig-list) (cdr elem-list))))
;;; Função auxiliar que retorna um conjunto de todas as combinações ;;;
;;; num-elem a num-elem de orig-list que não contenham nenhum dos ;;;
;;; elementos presentes em res-parc. ;;;
(defun group-n (num-elem res-parc orig-list)
(combination-lista-elem res-parc (combination num-elem (remove-lista orig-list (flatten res-parc)))))
(defun group-n-list (num-elem res-parc-list orig-list)
(if (eql res-parc-list nil)
nil
(let ((res-parc (car res-parc-list)) (resto (cdr res-parc-list)))
(append (group-n num-elem res-parc orig-list) (group-n-list num-elem resto orig-list)))))
(defun group3 (orig)
(group-n-list 5 (group-n-list 2 (group-n 2 nil orig) orig) orig))
(defun group (orig-list elem-list)
(if (eql (cdr elem-list) nil)
(group-n (car elem-list) nil orig-list)
(let ((elem-list (reverse elem-list)))
(group-n-list (car elem-list) (group orig-list (reverse (cdr elem-list))) orig-list))))
;;; Retorna uma lista ordenada de acordo com o tamanho das sublistas ;;;
(defun lsort (orig-list)
(sort orig-list #'> :key #'length))
;;; Retorna uma nova lista, com elementos da forma (N ELEM), onde ;;;
;;; N a freqencia do tamanho da lista ELEM e ELEM uma sublista ;;;
;;; original. ;;;
(defun lfmark (rest-list &optional (orig-list rest-list))
(if (eql rest-list nil)
nil
(cons (list (lfreq orig-list (length (car rest-list))) (car rest-list)) (lfmark (cdr rest-list) orig-list))))
;;; Recebe uma lista com elementos da forma (CHAVE ELEM) e retoran uma nova ;;;
;;; lista sem as chaves ELEM ;;;
(defun lfunmark (orig-list)
(if (eql orig-list nil)
nil
(cons (second (car orig-list)) (lfunmark (cdr orig-list)))))
;;; Conta o nmero de listas com tamanho e-length na orig-list ;;;
(defun lfreq (orig-list e-length)
(if (eql orig-list nil)
0
(if (eql (length (car orig-list)) e-length)
(+ (lfreq (cdr orig-list) e-length) 1)
(lfreq (cdr orig-list) e-length))))
;;; Retorna uma lista ordenada pela freqencia de suas sublistas ;;;
(defun lfsort (orig-list)
(let ((marked-list (lfmark orig-list)))
(lfunmark (sort marked-list #'> :key #'(lambda (x) (car x))))))
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment