Aula 8

Implemente a função vogalmaiscomum que dado um string retorna a (uma das) vogal mais comum no string. Considerar que vogais maiúsculas e minúsculas contam como a mesma vogal

Assuma que um contador é implementado como uma lista de tuplas onde o primeiro elemento da tupla é a chave e o segundo a contagem relativa a chave.

Assuma a função soma1 que dado uma chave e um contador (a lista) soma 1 na contagem relativa a chave no contador, ou inclui a chave na lista com contagem 1 se ela não tiver lista. Voce pode usar essa função se quiser, voce não precisa implementa-la

soma1 :: (Eq a) => a -> [(a,Int)] -> [(a,Int)]

soma1 "abc" [("efg",4),("abc",2),("qwe",1)] ==> [("efg",4),("abc",3),("qwe",1)]
soma1 'a' [('b',1),('d',3),('u',2)] ==>  [('a',1),('b',1),('d',3),('u',2)]

soma1 ch [] = [(ch,1)]
soma1 ch ((a,b):xs) 
    | ch == a = (a,b+1):xs
    | otherwise = (a,b):soma1 ch xs

Outras funções úteis, que voce pode usar se quiser:

• elem :: (Eq a) => a -> [a] -> Bool retorna True se o 1o argumento é membro da lista (2o argumento)
• toLower :: Char -> Char que se o argumento é uma letra maiúscula retorna a minúscula correspondente, e se for minúscula, retorna ela própria

import Data.Char (toLower)  # se voce for rodar o seu programa

toLower 'A' ==> 'a'
toLower 'a' ==> 'a'

• snd retorna o segundo elemento de uma upla de 2

snd (a,b) = b

• maximum retorna o maior elemento de uma lista

import Data.List  # tudo !!!

import Data.List (nub,sort)  # apenas

import qualified Data.List as DL # qualificado

DL.sort

De uma olhada em Data.List e Data.Map.Strict

Data.List

• fold, map, filter, elem, etc
• sum, maximum
• !! - acesso a um elemento (indexado apartir do 0)
• zip, zipWith
• lines - divide um stringão em linhas
• words - divide um string em palavras (igual ao split() do python)
• unlines e unwords - dual das funcoes acima
• sort
• nub - remove duplicadas
• operações em conjuntos: union, // (set difference) etc

Data.Map.Strict

• empty - dicionario vazio
• fromList Ord k => [(k, a)] -> Map k a
• fromListWith Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
• insert Ord k => k -> a -> Map k a -> Map k a
• insertWith - funcao de combinacao entre valor velho e novo
• delete Ord k => k -> Map k a -> Map k a
• lookup Ord k => k -> Map k a -> Maybe a (a ser discutido na aula que vem)
• member Ord k => k -> Map k a -> Bool
• map (a -> b) -> Map k a -> Map k b
• mapWithKey (k -> a -> b) -> Map k a -> Map k b
• elems Map k a -> [a]
• keys Map k a -> [k]
• assocs Map k a -> [(k, a)]

import qualified Data.Map.Strict as Map

soma1 ch dic = Map.insertWith (+) ch 1 dic