### 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!