Por Anderson Zanichelli
ctrl + \ = ?
Formas especiais
lambda
define
cond
quote
let
Definindo uma função
(define (quadrado x) (* x x))
(define quadrado
( lambda (x)
(* x x)))
Definindo um valor, uma variável
(define x 5)
(cond
(cond1 exp1)
(cond2 exp2)
...
[(else expn)])
(define fat
(? (n)
(cond
((= n 1) 1)
((> n 1) (* n (fat(- n 1)))))))
(define (fat n)
(cond
((= n 1) 1)
((> n 1) (* n (fat(- n 1))))))
(integer? x)
(odd? y)
(number? a)
(string? b)
(reminder 10 4) == % mod
(quotient 10 3) divisao inteira
(sqrt 2)
(expt 3 4)
(and #t #t)
(or #t #f)
(quote objeto)
'(+ 2 3)
(length '( 1 2 3 4 5))
(define pessoa '(nome, idade, sexo))
car (first racket) head
cdr (rest racket) tail
(define (tamanho lista)
(cond
((null? lista) 0)
(else (+ 1 (tamanho (cdr lista))))))
Recursão em cauda
(define (tamanho-acc acc lista)
(cond
((null? lista) acc)
(else (tamanho-acc (+ 1 acc) (cdr lista)))))
Função tamanho otimizada
(define (tamanho lista)
(tamanho-acc 0 lista))
(define (minimo lista)
(cond
[((null? (cdr lista)) (car lista))]
[((< (car lista) (minimo (cdr lista))) (car lista))]
[(else (minimo (cdr lista)))]))
Minimo melhorada
(define (minimo lista)
(cond
[((null? (cdr lista)) (car lista))]
[else
(define primeiro (car lista))
(define minimo-resto (minimo (cdr lista)))
(if (< primeiro minimo-resto)
primeiro
minimo-resto)]))
Utilizando o let para criar uma espécie de bloco
(let ((10 valores )*) exp)
Exemplo
(* (+ x x) (+ x x))
usariamos
(let ((z (+ x x )))
(* z z))
(let (()))
Mínimo com o uso do let
(define (minimo lista)
(if (null? (cdr lista))
(car lista)
(let ([primeiro (car lista)])
[minimo-resto (minimo (cdr lista))])
(if (< primeiro minimo-resto)
primeiro
minimo-resto)))
Aumento de expressividade com o let
(let ((x (* 20 10))
(y (+ 50 5))
(* x x y)))
Se fosse com o lambda
(lambda (x y)
(* x x y)) --> Retorna uma função
(lambda (x y)
(* x x y)) (* 21 10) (+ 50 5) deve ser aplicada assim com o lambda, o let facilitou a escrita
let* permitiria fazer algo do tipo
(let* ((x (* 20 10))
(y (- x 5))
(* x x y)))
Minimo com acumulador
(define (minimo-acc acc lista)
(if (null? lista)
acc
(minimo-acc (if (< acc (car lista))
acc
(car lista))
(cdr lista))))
(define (minimo lista)
(minimo-acc (car lista) (cdr lista)))
Abstração para reduce
(define (reduce func acc lista)
(if (null? lista)
acc
(reduce func
(func acc (car lista))
(cdr lista))))
Reescrevendo a minimo e tamanho
(define (minimo lista)
(define (min a b))
(if (< a b) a b)
(reduce min (car lista) (cdr lista)))
(define (tamanho lista)
(define (soma1 acc b)
(add1 acc))
(reduce soma1 0 lista))
internamente o reduce se chama fold, foldl e foldr
ctrl + \ = ?
Formas especiais
lambda -> let
define
cond -> if
quote
fold
map
filter
--------------------
Funções primitivas
car
cdr
cons -> construction
eval
apply
append
negate
----------------------
Funções Predicado
even?
positive?
----------------------
cons
Montar listas, adiciona um elemento na cabeça da lista
(cons 7 '(3 4 6))
(cons '(1 5) '(3 4 6))
(define x 10)
(define y 20)
(cons x '())
(cons y (cons x '()))
(list x y 10)
(enumerar 1 10)
(define (enumerar inicio fim)
(if (>= inicio fim)
(list fim)
(cons inicio (enumerar (add1 inicio) fim))))
faz a enumeração
(1 .. 3)
v
1 (2 .. 3)
v
2 (3 .. 3)
v
3
(define (mais1 lista)
(if (null? lista)
'()
(cons (add1 (car lista)) (mais1 (cdr lista)))))
(mais1 '(2 3 4))
> '(3 4 5)
(foldr cons '() '(7 9 2))
(foldl cons '() '(7 9 2))
cons cons cons
'() (7 9 2)
V
'(7)
V
'(9 7)
V
'(2 9 7)
Mais um com foldr
(define (mais1-fold lista)
(define (cons-mais1 e acc)
(cons (add1 e) acc))
(foldr cons-mais1 '() lista))
(define (quadrado x)
(* x x))
(define (quadrado-fold lista)
(define (cons-quadrado e acc)
(cons (quadrado e) acc))
(foldr cons-quadrado '() lista))
(map quadrado '(3 4 5)) semelhante ao de cima
(define (mymap function lista)
(define (cons-map e acc)
(cons (function e) acc))
(foldr cons-map '() lista))
Função anônima para aplicar o cubo
(mymap (? (x) (* x x x)) '(1 2 3))
----------------------
eval
Avalia listas, ou programas
(eval '(+ 3 4))
> 7
-------------------
apply
Pega os valores de uma lista e aplica a função a ela
(apply < '(3 4))
(apply + '(3 4 5 6))
----------------------
filter
(filter even? '(1 2 4 6 7 9 3))
Quick Sort com o filter
(define (quicksort lista)
(if (null? lista)
'()
(let* ([pivo (car lista)]
[cauda (cdr lista)]
[menor-pivo? (? (x) (< x pivo))]
[maior-pivo? (negate menor-pivo?)])
(append (quicksort (filter menor-pivo? cauda))
(list pivo)
(quicksort (filter maior-pivo? cauda))))))
0 Responses to “LP – Anotações Aula de Racket”