~misterio/veraoPFPA-Listas

085146837857aec09e9af6e5a8336f83e5430d8d — Gabriel Fontes 5 months ago 61d15f8
melhora formatação e misc na lista
1 files changed, 30 insertions(+), 63 deletions(-)

M lista.md
M lista.md => lista.md +30 -63
@@ 15,7 15,7 @@ Gabriel Silva Fontes
*Solução*:
<!-- require: main -->
```haskell
    [ x | x <- [0,5..50]]
  [ x | x <- [0,5..50]]
```




@@ 24,7 24,7 @@ Gabriel Silva Fontes
*Solução*:
<!-- require: main -->
```haskell
    [ x | x <- ['a'..'z'], not $ x `elem` "aeiou" ]
  [ x | x <- ['a'..'z'], not $ x `elem` "aeiou" ]
```




@@ 33,7 33,7 @@ Gabriel Silva Fontes
*Solução*:
<!-- require: main -->
```haskell
    [ x | x <- [0..50], not $ x `elem` [2,7,13,35,42]]
  [ x | x <- [0..50], not $ x `elem` [2,7,13,35,42]]
```




@@ 42,7 42,7 @@ Gabriel Silva Fontes
*Solução*:
<!-- require: main -->
```haskell
    [ 500 / 2^x | x <- [0..9] ]
  [ 500 / 2^x | x <- [0..9] ]
```




@@ 51,7 51,7 @@ Gabriel Silva Fontes
*Solução*:
<!-- require: main -->
```haskell
    [ (x, y) | x <- ['a'..'h'], y <- [1..8] ]
  [ (x, y) | x <- ['a'..'h'], y <- [1..8] ]
```

## 2) Crie as funções da forma como solicitado:


@@ 63,21 63,9 @@ Gabriel Silva Fontes
<!-- name: 2-a -->
```haskell
elem' :: Eq a => a -> [a] -> Bool
elem' e (x:xs) = (e == x) || (elem' e xs)
elem' e (x:xs) = (e == x) || elem' e xs
elem' _ [] = False
```
<!-- require: 2-a
```haskell
main = do
    print $ True == (1 `elem'` [1,2,3])
    print $ True == (1 `elem'` [1,2])
    print $ False == (3 `elem'` [1])
    print $ False == (3 `elem'` [])
    print $ True == ('a' `elem'` "banana")
    print $ False == ('c' `elem'` "banana")
```
-->


### b) Crie um função que receba 3 valores numéricos, de qualquer tipo, e considerando que cada valor é a medida de um lado de um triângulo, retorne um valor do tipo Bool informando se estas são medidas validas para formar um triângulo.



@@ 85,17 73,8 @@ main = do
<!-- name: 2-b -->
```haskell
ehTriangulo :: (Num a, Ord a) => a -> a -> a -> Bool
ehTriangulo a b c = (a+b > c) && (a+c > b) && (b+c > a)
```

<!-- require: 2-b
```haskell
main = do
    print $ ehTriangulo 7 5 10
    print $ not $ ehTriangulo 7 5 100
ehTriangulo a b c = a+b > c && a+c > b && b+c > a
```
-->


### c) Crie uma função recursiva que tenha dois parâmetros númericos, de qualquer tipo, e calcule a potenciação, o primeiro parâmetro sendo a base e o segundo o expoente.



@@ 105,21 84,9 @@ main = do
potencia :: (Fractional a, Ord a) => a -> a -> a
potencia _ 0 = 1
potencia b e
    | e > 0 = (potencia b (e-1)) * b
    | e < 0 = (potencia b (e+1)) / b
  | e > 0 = potencia b (e -1) * b
  | e < 0 = potencia b (e + 1) / b
```
<!-- require: 2-c
```haskell
main = do
    print $ 4 == (potencia 2 2)
    print $ 8 == (potencia 2 3)
    print $ 1 == (potencia 2 0)
    print $ 1 == (potencia 2 0)
    print $ 2 == (potencia 0.5 (-1))
    print $ 2 == (potencia 0.5 (-1))
    print $ 0.25 == (potencia 2 (-2))
```
-->

## 3) Siga as instruções abaixo na sequência:



@@ 161,9 128,9 @@ data Cor a = Cor { red::a, green::a, blue::a }
```haskell
somaCor :: (Ord a, Num a) => Cor a -> Cor a -> Cor a
somaCor a b = 
        Cor (canal red) (canal green) (canal blue)
    where
        canal f = min 255 $ (f a)+(f b)
  Cor (canal red) (canal green) (canal blue)
  where
    canal f = min 255 $ f a + f b
```

### e) Crie um operador <+> que faça a mesma coisa que a função somaCor, utilize-se do conceito de currying para definir o operador


@@ 181,10 148,10 @@ somaCor a b =
<!-- name: 3-f require: 3-e -->
```haskell
instance (Ord a, Num a) => Semigroup (Cor a) where
    (<>) = (<+>)
  (<>) = (<+>)

instance (Ord a, Num a) => Monoid (Cor a) where
    mempty = Cor 0 0 0
  mempty = Cor 0 0 0
```

## 4) Siga as intruções abaixo em sequência:


@@ 203,7 170,7 @@ data Cofre a = Cofre [a]
<!-- name: 4-b require: 4-a -->
```haskell
instance Functor Cofre where
    fmap f (Cofre x) = Cofre $ fmap f x
  fmap f (Cofre x) = Cofre $ f <$> x
```

### c) Crie uma instância do typeclass Applicative para esse tipo.


@@ 212,8 179,8 @@ instance Functor Cofre where
<!-- name: 4-c require: 4-b -->
```haskell
instance Applicative Cofre where
    pure x = Cofre [x]
    (Cofre f) <*> (Cofre x) = Cofre $ f <*> x
  pure x = Cofre [x]
  (Cofre f) <*> (Cofre x) = Cofre $ f <*> x
```

## 5) Siga as instruções abaixo na sequência:


@@ 232,8 199,8 @@ data Automovel = Carro | Moto
<!-- name: 5-b require: 5-a -->
```haskell
data Veiculo = Veiculo {
    automovel :: Automovel,
    placa :: String
  automovel :: Automovel,
  placa :: String
}
```



@@ 243,7 210,7 @@ data Veiculo = Veiculo {
<!-- name: 5-c require: 5-b -->
```haskell
class EhCarro a where
    ehCarro :: a -> Bool
  ehCarro :: a -> Bool
```

### d) Crie uma instância de `EhCarro` para o tipo `Veiculo`


@@ 252,11 219,11 @@ class EhCarro a where
<!-- name: 5-d require: 5-c -->
```haskell
instance EhCarro Automovel where
    ehCarro Carro = True
    ehCarro Moto = False
  ehCarro Carro = True
  ehCarro Moto = False

instance EhCarro Veiculo where
    ehCarro = ehCarro . automovel
  ehCarro = ehCarro . automovel
```

### e) Crie uma instância de `EhCarro` para o tipo `Int` (Nenhum número é um carro)


@@ 265,7 232,7 @@ instance EhCarro Veiculo where
<!-- name: 5-e require: 5-d -->
```haskell
instance EhCarro Int where
    ehCarro _ = False
  ehCarro _ = False
```

## 6) Seguindo os axiomas de Peano:


@@ 301,8 268,8 @@ naturalParaInt (Succ x) = 1 + naturalParaInt x
intParaNatural :: Int -> Maybe Natural
intParaNatural 0 = Just Zero
intParaNatural x
    | x < 0 = Nothing
    | otherwise = fmap Succ $ intParaNatural (x-1)
  | x < 0 = Nothing
  | otherwise = Succ <$> intParaNatural (x-1)
```

## 7) Crie uma função que receba 3 parâmetros, sendo eles duas funções (referenciadas aqui no enunciado como f e g) e um valor (referenciado aqui no enunciado como x), e retorne uma tupla de duas posições contendo na primeira posição o resultado de f composta em g aplicado em x e na segunda o resultado de g composta em f aplicado em x. Construa a função da forma mais genérica que for possível de criar uma função com essas caracteristicas e deixe explicita a assinatura da função. Faça uma breve explicação sobre a forma como vc pensou para criar essa função.


@@ 329,7 296,7 @@ Portanto, a forma mais genérica possível tem como restrição que ambas as fun
*Solução*:
```haskell
data JoKenPo = Pedra | Papel | Tesoura
    deriving (Ord, Eq)
  deriving (Ord, Eq)

data Resultado = Vitoria1 | Vitoria2 | Empate



@@ 337,7 304,7 @@ jogar :: JoKenPo -> JoKenPo -> Resultado
jogar Pedra Tesoura = Vitoria1
jogar Tesoura Pedra = Vitoria2
jogar x y
    | x == y = Empate
    | x > y = Vitoria1
    | x < y = Vitoria2
  | x == y = Empate
  | x > y = Vitoria1
  | x < y = Vitoria2
```