Aula 7

f (g (h x y)) 

f $ g $ h x y

( f . g ) x = f (g x)

aplica2 f = f . f

usado principalmente em map e fold, para criar uma função nova

• conta o numero de vezes um item aparece numa lista

conta it l = foldl (\ac x -> if x==it then ac+1 else ac) 0 l

conta it l = foldr (\x res -> if x==it then res+1 else res) 0 l 

• conta quantos elementos satisfazem uma função

contafunc f l = foldl (\ac x -> if f x then ac+1 else ac) 0 l

• troca elemento velho por novo

troca velho novo l = foldr (\x res -> if x==velho then novo:res else x:res) [] l 

trocal velho novo l = foldl (\ac x -> if x==velho then acc++[novo] else acc++[x]) [] l

se voce esta construindo uma lista é preferível usar o FOLDR

• remove elemento de uma lista

rem it l = foldr (\x res -> if it==x then res else x:res) [] l

• remove elemento de uma lista (primeiras n vezes)

remn it n l = fst $ foldl (\(li,nn) x -> 
                     if x == it && nn > 0 
                         then (li,nn-1) 
                         else (li++[x],nn))
                   ([],n) l 

remn it 0 l = l
remn it n (x:xs)
   | x == it = remn it (n-1) xs 
   | otherwise = x: remn it n xs 

• lista de posições de um item numa lista

posicoes it l = foldr (\(acc,n) x -> 
                         if x==it then (acc++[x], n+1) else (acc,n+1)) 
                      ([],0) l 

• inserelista

inserelista l = foldl insereArvore Vazia l



insereArvore Vazia x = No x Vazia Vazia
insereArvore (No n ae ad) x 
   | x == n = (No n ae ad)
   | x < n  = (No n (insereArvore ae x) ad)
   | x > n  = (No n ae (insereArvoce ad x))

inserelistar l = foldr (flip . insereArvore) Vazia l 

• reimplemente os exercicios da aula 1 usando as funcoes de alto nivel

(map, filter, fold)

• uma matrix é implementada como uma lista de linhas (que são listas)

1  2  3
4  5  6 
7  8  9
0  0 -1

[[1,2,3],[4,5,6],[7,8,9],[0,0,-1]]

implemente transposta que transpoe uma matrix

transp ([]:_) = []
transp mat = col1 : (transp restmat)
   where col1 = map head mat
         restmat = map tail mat

• implemente matmul que dado duas matrizes de formatos apropriados multiplica-as. (*)

matmul m1 m2 = matmul' m1 (transp m2)

matmul' [] _ = [[]]
matmul' (lin:r) m2 = (map (\l -> dotprod l lin) m2) : (matmul' r m2)

dotprod l1 l2 = sum $ zipWith (*) l1 l2