Fund Comp Trabalhos

1) Manipulador de tabelas

Considere este exemplo de um texto contendo uma tabela:

Mostramos uma lista de cinco afirmações para quatro pessoas e
perguntamos o quanto cada uma dessas pessoas concordava, numa escala
de 0 a 5, com cada uma de cinco afirmações apresentadas. Obtivemos as
seguintes respostas:

 Nome/resposta A1 A2 A3 A4 A5
  Alice        0  1  2  3  4
  Beto         1  1  3  1  2
  Camila       4  2  2  1  1
  Daniel       5  5  0  0  2

Repare que a tabela é formada por algumas linhas do texto; a primeira linha é a que diz "Nome/resposta A1 A2 A3 A4 A5". Cada linha da tabela e' formada por várias "palavras"; na primeira linha, "Nome/resposta", "A1", "A2", "A3", "A4", "A5", na segunda linha "Alice", "0", "1", "2", "3", "4", etc.

O objetivo deste trabalho é fazer uma série de funções que nos permitam trabalhar com esse tipo de tabela em textos. A primeira destas funções, "string->tabela", pega um string correspondente a uma tabela destas e transforma-o num objeto que é bem mais fácil de manipular em Lisp: uma lista de listas.

(setq tabela (string->tabela "
  .    Q1 Q2 Q3 Q4 A5
Alice   0  1  2  3  4
Beto    1  1  3  1  2
Camila  4  2  2  1  1
Daniel  5  5  0  0  2
"))
  |-> (("." "Q1" "Q2" "Q3" "Q4" "Q5")
       ("Alice" 0 1 2 3 4)
       ("Beto" 1 1 3 1 2) 
       ("Camila" 4 2 2 1 1)
       ("Daniel" 5 5 0 0 2))

2) Calculadora RPN

O primeiro objetivo deste trabalho é fazer uma função - a função "calcula" - que simule uma calculadora RPN. A função "calcula" recebe uma lista de operações a serem feitas com uma pilha de números - essa pilha é uma lista de números que fica guardada na variável "pilha" - e vai executando essas operações uma a uma, modificando a pilha a cada passo e mostrando o valor novo da pilha. Por exemplo, a lista (2 3 * 4 5 * +) corresponde às operações:

2 - põe o número 2 no topo da pilha
3 - põe o número 3 no topo da pilha
* - tira os dois números que estão no topo da pilha, 2 e 3,
    multiplica-os e põe o resultado na pilha
4 - põe o número 4 no topo da pilha
5 - põe o número 5 no topo da pilha
* - multiplica os dois números que estão no topo da pilha, 4 e 5, e
    põe o resultado, 20, no lugar
+ - soma os dois caras do topo da pilha, 6 e 20, e põe o resultado,
    26, no lugar

Um exemplo de como a função "calcula" deve se comportar:

(setq pilha ())
(calcula '(2 3 * 4 5 * +))
  |-> (2)
      (3 2)
      (6)
      (4 6)
      (5 4 6)
      (20 6)
      (26)
(car pilha)
  |-> 26

Depois que a função "calcula" estiver pronta tentem fazer uma função "calcula-arit" que trata a pilha como uma pilha de "contas" em notação aritmética usual; essas "contas" vão ser coisas como

  2
  (2 * 3)
  (2 * ((3 * 4) * (5 * 6)))

Uma definição mais precisa do que é uma "conta" é a seguinte:

- qualquer número é uma "conta";
- se c1 e c2 são "contas" então (c1 * c2), (c1 + c2), (c1 - c2), etc,
  são "contas";
- as "contas" são só os objetos que são formados a partir de
  sucessivas aplicações das regras acima.

Um exemplo de como a função "calcula-arit" deve se comportar:

(setq pilha ())
(calcula-arit '(2 3 * 4 5 * +))
  |-> (2)
      (3 2)
      ((2 * 3))
      (4 (2 * 3))
      (5 4 (2 * 3))
      ((4 * 5) (2 * 3))
      (((2 * 3) + (4 * 5)))
(car pilha)
  |-> ((2 * 3) + (4 * 5))

(setq pilha ())
(calcula-lisp '(2 3 * 4 5 * +))
  |-> (2)
      (3 2)
      ((* 2 3))
      (4 (* 2 3))
      (5 4 (* 2 3))
      ((* 4 5) (* 2 3))
      ((+ (* 2 3) (* 4 5)))
(car pilha)
  |-> (+ (* 2 3) (* 4 5))

3) Simular o "eval" do Lisp

(* (+ 1 2) (+ 3 4))
(_ * (+ 1 2) (+ 3 4))
(* _ (+ 1 2) (+ 3 4))
(* _ (_ + 1 2) (+ 3 4))
(* _ (+ _ 1 2) (+ 3 4))
(* _ (+ 1 _ 2) (+ 3 4))
(* _ (+ 1 2 _) (+ 3 4))
(* 3 _ (+ 3 4))
(* 3 _ (_ + 3 4))
(* 3 _ (+ _ 3 4))
(* 3 _ (+ 3 _ 4))
(* 3 _ (+ 3 4 _))
(* 3 7 _)
21

4) "Calculadora" para geometria

O grupo que

Trabalha com vetores, pontos, retas dadas por equações, e se possível também círculos. Pontos podem ter nomes e a gente pode especificar segmentos para serem traçados.

(defponto 'O '(0 0))
  |-> (0 0 ponto O)
(defponto 'A '(2 0))
  |-> (2 0 ponto A)
(defponto 'B '(0 1))
  |-> (0 1 ponto B)
(defponto 'C '(3 -2))
  |-> (3 -2 ponto C)

(defvetor 'v (-- B A))
  |-> (-2 1 vetor v)

(++ C v)
  |-> (1 -1 ponto)
(++ A B)
  |-> ERRO

(defreta 'r (reta O A))
  |-> ((0 1) 0 reta)
(defreta 's (reta B C))
  |-> ((1 1) 1 reta)
(cruzamento 'r 's)
  |-> (1 0 ponto)

5) Programa para desenhar gráficos

Desenhar funções e figuras de geometria descritiva: pontos, nomes nos pontos, segmentos, eixos, tracinhos e números nos eixos; ajuste de escala, o que fazer quando a função não cabe na tela. Desenhar algumas figuras de geometria descritiva: por exemplo, a do Teorema de Pitágoras. Fazer o programa desenhar alguns exemplos de gráficos: exp, seno e cosseno e algumas aproximações deles por série de Taylor.

Tarefas menores - coisas que eu estou encarregando algumas pessoas de aprenderem e passarem adiante

condicionais e estruturas de controle (if, progn, cond, while, dotimes, etc)
manuais, info-mode e links com find-node
emacs-wiki e dired-mode
picture-mode
recursão (ainda não)
single-stepper (ainda não)
edebug (ainda não)
calc (principalmente pra verificar a calculadora geométrica; ainda não)
help sobre funções e variáveis, find-efunction etc (ainda não)
uma tabela das funções que a gente conhece, com exemplos

Funções que a gente conhece:

+, -, *, /, <, <, >, >, =, ffloor, sqrt
cons, car, cdr, list, nth
let, setq, defun
numberp, listp, null, not, t
if, progn, cond, while, dotimes
eval, read, format
insert

Comandos

C-h k - describe-key
C-h f - describe-function

Modos

fundamental
lisp-interaction
emacs-lisp
info
help/view
dired
picture
emacs-wiki

Hiperlinks

find-node

Updated: 2004-05-13

Home / Index