BCC101 – Matemática Discreta

Indução / RecursãoIndução Estrutural

Sequências, Listas, Strings

Sequências ou listas são fundamentais em computação. Toda estrutura discreta pode ser descrita como uma sequência de caracteres:

Números decimais : 1010230824879 Números binários : 0111010101010111 Textos. Por exemplo, este documento Programas de computador Padrões da natureza

DNA Proteinas

Linguagens de programação

Sequências, Listas, Strings

Notação:[a] representa o tipo (ou conjunto) das listas de elementos de um dado tipo a. Ex:[2,5,23] :: [Int][‘a’, ‘b’, ‘c’, ’d’] :: [Char][(2,’a’), (9,’d’)] :: [(Int,Char)] [[‘a’, ‘b’], [‘c’], []] :: [[Char]]

Sequências, Listas, Strings

DEF: O tipo [a] pode ser definido recursivamente do seguinte modo:

[] :: [a] se x :: a e xs::[a] então (x:xs) :: [a]

Ex:[1,2,3] = 1:[2,3] = 1:(2:[3]) = 1:(2:(3:[]))

Funções sobre listas - length

A função length :: [a] -> Int computa o comprimento (ou número de elementos) de uma lista

Ex: length [1,6,10,3,9] = 5 length [‘u’,’m’] = 2 length [[‘a’, ‘b’], [‘c’], []] = 3

Q: Defina length recursivamente

Funções sobre listas - length

R:

Base: length [] = 0Recursão: length (x:xs) = 1 + length(xs)

Funções sobre listas – sum e product

sum :: [Int] -> Int computa a soma de todos os valores da lista. Ex: sum [10,7,8] = 25

Q: Defina sum recursivamente product :: [Int] -> Int computa o

produto de todos os valores da lista. product [10,7,8] = 150

Q: Defina product recursivamente

Funções sobre listas – sum, product

R:sum [] = 0sum (x:xs) = x + length(xs)

product [] = 1product (x:xs) = x * length(xs)

Funções sobre listas – concat

(++) :: [a] -> [a] -> [a] computa a concatenação das duas listas dadas como argumento. Ex: [3,7] ++ [10,7,8] = [3,7,10,7,8]

Q: Defina (++) recursivamente

Funções sobre listas – concat

R:

[] ++ ys = ys(x:xs) ++ ys = x : (xs ++ ys)

Q: Prove, por indução, quelength(xs++ys) = length(xs) + length(ys)

Funções sobre listas – reverse

reverse :: [a] -> [a] retorna o reverso da lista dada. Ex:

reverse [10,7,8] = [8,7,10]

Q: Defina recursivamente reverse

Funções sobre listas – reverse

reverse [] = []reverse (x:xs) = reverse xs ++ [x]

reverse xs = reverse’ xs []reverse’ [] ys = ysreverse’ (x:xs) ys = reverse’ xs (x:ys)

Q: Prove, por indução, quereverse(reverse xs) = xs

Funções sobre listas – maximum

maximum :: [Int] -> Int computa o máximo dentre os valores da lista.

maximum [10,7,8] = 10

Q: Defina recursivamente maximum

Funções sobre listas – maximum

maximum [x] = xmaximum (x:xs) = max(x,maximum(xs))max (x,y) = if x >= y then x else y

Q: Prove, por indução, que para toda lista xs e todo elemento x de xs,

maximum(xs) ≥ x Use como hipótese que

max(x,y) ≥ x ∧max(x,y) ≥ x

CelebridadeUma celebridade em um grupo de n pessoas é alguém que não conhece ninguém mas é conhecido por todas as demais pessoas. O problema aqui é determinar quem é a celebridade, fazendo apenas perguntas com resposta SIM ou NÃO. Supondo que todo grupo de n>0 pessoas possui uma celebridade, qual é a maneira mais eficiente de determinar quem é a celebridade?

CelebridadeSuponha que o grupo de n pessoas é

representado como uma lista. Suponha que x `knows` y retorna true se x

conhece y, ou false caso contrário

celebridade [x] = xcelebridade [x,y] = if x `knows` y then y else xcelebridade [x,y:xs] = if x `knows` y then celebridade(y:xs) else celebridade (x:ys)

Ordenação Diversas aplicações em

computação requerem ordenação de uma sequência de dados.

Função de ordenação de listas:sort :: [a] -> [a]

Existem diversos métodos para ordenação de listas. Vamos ver a definição recursiva de alguns deles.

Ordenação por inserção

insort :: [a] -> [a]insort [] = []insort (x:xs) = insert x (insort xs)

insert :: a -> [a] -> [a]insert y [] = [y]insert y (x:xs) = if y<x then (y:x:xs) else x:(insert y xs)

Ordenação por seleção

selsort :: [a] -> [a]selsort [] = []selsort xs = min : selsort yswhere (min,ys) = getmin xssplitmin :: [a] -> (a,[a])getmin [x] = (x,[])getmin (x:xs) = if x<min then (x,(min:ys)) else (min, (x:ys))where (min,ys) = getmin xs

Quicksort

qsort :: [a] -> [a]qsort [] = []qsort (x:xs) = qsort les ++ [x] ++ qsort gts

where les = [y | y <- xs, y < x] gts = [y | y <- xs, y > x]

ÁrvoresÁrvore

diagrama ou grafo sem ciclos. estrutura de dados na qual diretamente

abaixo de cada elemento estão associados um ou mais elementos.

Árvores definição indutiva: um nodo, juntamente com uma sequência de árvores

Terminologia subárvore — um nodo, juntamente com sua sequência de

árvores raiz — o nodo que, com suas subárvores, constitui a árvore

toda nodo interior — nodo com um sequência não vazia de

subárvores folha — nodo que tem uma sequência vazia de subárvores ramo — linha conectando um nodo a suas subárvores (no

diagrama) árvore binária — árvore na qual cada nodo tem no máximo 2

subárvores

Para que servem árvoresAplicações computacionais que usam árvores

Bancos de dados, compiladores, jogos, sistemas especialistas, processadores de texto, sistemas operacionais, …

Árvores de Pesquisa Estruturas que facilitam a recuperação de dados Cada nodo armazena uma chave para recuperação de

um dado associado à chave Uma chave é um elemento de algum tipo ordenável Subárvores são organizadas de maneira a tornar a

pesquisa mais rápida Busca ingênua: procurar sequencialmente toda a

árvoreTempo de pesquisa proporcional ao número de items

Árvore de pesquisa — tempo de busca proporcional a log(n), onde n = número de items

Árvore de Pesquisa Binária – diagrama

Cada nodo armazena chave/dado Subárvore esquerda contém todas as

chaves menores Subárvore direita contém todas as

chaves maiores Folhas apenas marcam os limites da

árvore: nenhuma chave/dado

5120PDA Cam

9605Palm Pilot

4403HotSync

4878Palm Games

7268Zip Drive

8444Audio

System

6876Intellimouse

3663Net Hub

6419128MB RAM

142556K Modem

2088LaserJet

1143InkJet

Chave – ordered

Data – anything

Para encontrar um item comece pela raiz pesquise à esq., se menor pesquise à dir., se maior 12 items: 4 passos, no maximo

Árvore de Pesquisa Bináriadata SearchTree key dat = Leaf | Node key dat (SearchTree key dat) (SearchTree key dat)

Parâmetros de tipo — key, datkey — pode ser, por exemplo, Int (ordenável)dat — pode ser qualquer tipo

Exemplo s :: SearchTree Int (String, Float) s é uma SearchTree

tipo de key – Int (ex: catalogo ordenado numericamente)

tipo de dat – par contendo um string String (descrição de um produto description) e um Float (preço)

chave dado subárvore esq (chaves menores)

subárvore direita (chves maiores)

Leaf – construtor de folhaNode – construtor de árvore não vazia

Obtendo um dado da Árvore de Pesquisa

Encontrado ou Não Encontrado A chave procurada pode ou não ocorrer na árvore

de pesquisa O que fazer se ela não ocorre

Retornar algum indicador de não ocorrênciaUsar o tipo Maybe para isso

data Maybe a = Just a | Nothing

Indica não encontradoExemplo, item encontrado Just (2088, “LaserJet”)

Obtendo um dado da Árvore de Pesquisa

getItem :: Ord key => SearchTree key dat -> key -> Maybe (key, dat)

getItem (Node key dat smaller bigger) searchKey= if searchKey key then (getItem smaller searchKey) else if searchKey key then (getItem bigger searchKey) else (Just(key, dat))getItem Leaf searchKey = Nothing