2 Exercícios em Haskell

[Alessandro Bueno Ribeiro]

Alguém poderia me ajudar a resolver esses dois exercícios em haskell?

• Crie uma função recursiva charFound :: Char -> String -> Bool, que verifique se o caracter (primeiro argumento) está contido na string (segundo argumento). Exemplos de uso da função:
  > charFound 'a' ""
  False
  > charFound 'a' "uau"
  True
  
• Dada uma lista de strings, produzir outra lista com strings de 10 caracteres, usando o seguinte esquema: strings de entrada com mais de 10 caracteres são truncadas, strings com até 10 caracteres são completadas com '.' até ficarem com 10 caracteres. Exemplo:
  > func ["palavras","paralelas","pedal","paralelepipedo"]
  ["palavras..","paralelas.","pedal.....","paralelepi"]
  

[thoga31]

Sim, podemos ajudar. Diz-nos, para isso, quais são as tuas dúvidas específicas e que código já tentaste implementar. 😉

[Alessandro Bueno Ribeiro]

ola, esses eu consegui... Agora tenho duvida nesse, se o que eu estou fazendo é possível.

Eu quero usar map pra multiplicar todos os elementos menores que 1000 em uma lista por 0.1. Eu preciso usar o any, ou o all.

funcany :: [Float] -> [Float]
funcany [] =[]
funcany x = map (*0.1) any (> 1000.0) x

-- essa é a solução sem recursão na 1, que eu precisa.

charFound2 :: Char -> String -> Bool
charFound2 x y
       | (filter (== x) y) == " " = False
       | otherwise = True

-- essa é a solução da 2.

stringList :: [string] -> [string]
stringList [] = []
stringList (x:xs)
   |length x >= 10 = (take 10 x) : stringList (xs)
      |length x < 10 = (x ++ (replicate (10 - (length x)) '.')) : stringList (xs)

Agora, preciso de ajuda no post anterior.

Tenho essa lista pra resolver: Alguns eu já fiz. Se alguem quiser me ajudar nos q eu não estou conseguindo. Fico grato.

--1. Escreva uma função recursiva firstName :: String -> String que, dado o nome completo de uma pessoa,

--obtenha seu primeiro nome. Suponha que cada parte do nome seja separada por um espaço e que não existam

--espaços no início ou fim do nome.

firstName :: String -> String
firstName (x:xs) = if x == ' ' then [] else xs

--2.Escreva uma função firstName' :: String -> String com o mesmo resultado do exercício anterior, mas sem usar recursão.

--Dica: estude funções pré-definidas em Haskell (List operations -> Sublists) em

--http://hackage.haskell.org/package/base-4.8.0.0/docs/Prelude.html.

firstName' :: String -> String
firstName' x = takeWhile (/=' ') x

-- 3. Escreva uma função lastName :: String -> String que, dado o nome completo de uma pessoa,

--obtenha seu último sobrenome. Suponha que cada parte do nome seja separada por um espaço e

-- que não existam espaços no início ou fim do nome.

lastName :: String -> String
lastName x = reverse (takeWhile (/=' ') (reverse x)) -- primeiro faço o reverse da string inteira depois pego a primeira palavra dessa string
--que será o último nome invertido, e por último no primeiro reverse do código, inverto essa string, que é o ultimo nome

-- 4. Escreva uma função não-recursiva userName :: String -> String que, dado o nome completo de uma pessoa,

--crie um nome de usuário (login) da pessoa, formado por: primeira letra do nome seguida do sobrenome,

--tudo em minúsculas. Dica: estude as funções pré-definidas no módulo Data.Char, para manipulação

--de maiúsculas e minúsculas.

minusc :: String -> String
minusc [] = []
minusc (x:xs) = toLower x : minusc xs -- função auxiliar devolve string minuscula

userName :: String -> String
userName [] = []
userName (x:xs) = toLower x : minusc (lastName xs)

-- função que chama o exercicio 3 e devolve formato de login : primeira

--letra do nome mais o ultimo sobrenome

--5. Escreva uma função não-recursiva encodeName :: String -> String que substitua vogais em uma string,

--conforme o esquema a seguir: a = 4, e = 3, i = 1, o = 0, u = 00.

{-vogal :: Char -> Char
vogal x | x=='a' = '4'  
       | x=='e' = '3'
       | x=='i' = '1'
       | x=='o' = '0'
       | x=='u' = '5'
       | otherwise = x

encodeName :: String -> String
encodeName (x:xs) = vogal x : encodeName xs-}

--6. Escreva uma função isElem :: Int -> [int] -> Bool que verifique se um dado elemento pertence a uma lista,

--conforme os exemplos abaixo:

-- -- > isElem 4 [3,4,5,6,7]

--True

isElem :: Int -> [int] -> Bool
isElem x lista
       | filter (==x) lista == [] = False
       | otherwise = True

--7. Escreva uma função recursiva que retorne o número de vogais em uma string.

--8. Escreva uma função não-recursiva que retorne o número de consoantes em uma string.

--9. Escreva uma função não-recursiva isInt :: String -> Bool que verifique se uma dada string só contém dígitos (0 a 9).

--Exemplos:

-- -- > isInt "901"

--True

--- -- > isInt "2014a"

--False

Edited April 2, 2015 at 09:45 PM by thoga31
Tags code + GeSHi

[thoga31]

Não vejo onde é que a função any ou all vão ser úteis, ou mesmo sequer fazer parte, da resolução. Iso foi-te pedido, ou é um exercício auto-didáctico?

foo = map (\x -> if x < 1000.0 then x * 0.1 else x)

Edited April 2, 2015 at 09:42 PM by thoga31

[thoga31]

Porque é que fazes isto?

| (filter (== x) y) == " " = False

| filter (==x) lista == [] = False

Tens noção que é completamente desnecessário e ineficiente?

Uma vez que tens a maioria dos exercícios resolvidos ou apenas com pequenos problemas, vou dar a minha resolução até ao 6.

Espero que com estas resoluções recolhas ideias para os exercícios 7, 8 e 9 😉

-- 1
charFound :: Char -> String -> Bool
charFound _ [] = False
charFound x (y:ys) | x == y    = True
                  | otherwise = charFound x ys

-- 2
stringList :: [string] -> [string]
stringList [] = []
stringList (x:xs) | length x < 10  =  (x ++ replicate (10 - length x) '.') : stringList xs
                 | otherwise      =  take 10 x : stringList xs

-- 3
lastName :: String -> String
lastName = last . words

-- 4
import Data.Char (toLower)

userName :: String -> String
userName = getLogin . words . map toLower
  where
     getLogin xs = (head . head $ xs) : last xs

-- 5
encodeName :: String -> String
encodeName [] = []
encodeName (x:xs) = vog2num x ++ encodeName xs
  where
     vog2num c | c == 'a'  = "4"
               | c == 'e'  = "3"
               | c == 'i'  = "1"
               | c == 'o'  = "0"
               | c == 'u'  = "00"
               | otherwise = c:[]

-- 6
isElem :: Int -> [int] -> Bool
isElem x = any (== x)
-- ou
isElem _ [] = False
isElem x (y:ys) | x == y    = True
               | otherwise = isElem x ys

Edited April 2, 2015 at 10:20 PM by thoga31