:opt no-lint

import Data.Char  
import Test.QuickCheck

[x^2 | x <- [2..5]]

[(x,y) | x <- [1,2,3], y <- [4,5]]

[(x,y) | y <- [4,5], x <- [1,2,3]]

[(x,y) | x <- [1..3], y <- [x..3]]

concat' :: [[a]] -> [a]
concat' xss = [x | xs <- xss, x <- xs]

concat' [[1,3],[2,5,6],[4,7]]

primeros :: [(a, b)] -> [a]
primeros ps =  [x | (x,_) <- ps]

primeros [(1,3),(2,5),(6,3)]

longitud :: [a] -> Int
longitud xs = sum [1 | _ <- xs]

longitud [4,2,7]

longitud "Sevilla"

[x | x <- [1..10], even x]

factores :: Int -> [Int]
factores n = [x | x <- [1..n], n `mod` x == 0]

factores 30

primo :: Int -> Bool
primo n = factores n == [1, n]

primo 30

primo 31

primos :: Int -> [Int]
primos n = [x | x <- [2..n], primo x]

primos 31

busca :: Eq a => a -> [(a, b)] -> [b]
busca c t = [v | (c', v) <- t, c' == c]

adyacentes :: [a] -> [(a, a)]
adyacentes xs = zip xs (tail xs)

adyacentes [2,5,3,7]

and [2 < 3, 2+3 == 5]         

and [2 < 3, 2+3 == 5, 7 < 7]  

ordenada :: Ord a => [a] -> Bool
ordenada xs = and [x <= y | (x,y) <- adyacentes xs]

ordenada [1,3,5,6,7]

ordenada [1,3,6,5,7]

posiciones :: Eq a => a -> [a] -> [Int]
posiciones x xs = 
    [i | (x',i) <- zip xs [0..n], x == x']
    where n = length xs - 1

posiciones 5 [1,5,3,5,5,7]

"abc" == ['a','b','c']

length "abcde"              

reverse "abcde"             

"abcde" ++ "fg"             

posiciones 'a' "Salamanca"  

minusculas :: String -> String
minusculas xs = [x | x <- xs, elem x ['a'..'z']]

minusculas "EstoEsUnaPrueba"

ocurrencias :: Char -> String -> Int
ocurrencias x xs = length [x' | x' <- xs, x == x']  

ocurrencias 'a' "Salamanca"

ord 'a'  

ord 'b'  

ord 'A'  

chr 97  

chr 98  

chr 65  

let2int :: Char -> Int
let2int c = ord c - ord 'a'

let2int 'a'

let2int 'd'

let2int 'z'

int2let :: Int -> Char
int2let n = chr (ord 'a' + n)

int2let 0   

int2let 3   

int2let 25  

desplaza :: Int -> Char -> Char
desplaza n c 
    | elem c ['a'..'z'] = int2let ((let2int c+n) `mod` 26)
    | otherwise         = c

desplaza   3  'a'  

desplaza   3  'y'  

desplaza (-3) 'd'  

desplaza (-3) 'b'  

codifica :: Int -> String -> String
codifica n xs = [desplaza n x | x <- xs]

codifica   3  "En todo la medida" 

codifica (-3) "Eq wrgr od phglgd"   

prop_desplaza n xs = 
    desplaza (-n) (desplaza n xs) == xs

quickCheck prop_desplaza

prop_codifica n xs = 
    codifica (-n) (codifica n xs) == xs

quickCheck prop_codifica

tabla :: [Float]
tabla = [12.53, 1.42, 4.68, 5.86, 13.68, 0.69, 1.01, 
          0.70, 6.25, 0.44, 0.01,  4.97, 3.15, 6.71, 
          8.68, 2.51, 0.88, 6.87,  7.98, 4.63, 3.93, 
          0.90, 0.02, 0.22, 0.90,  0.52]

porcentaje :: Int -> Int -> Float
porcentaje n m = (fromIntegral n / fromIntegral m) * 100

porcentaje 2 5

frecuencias :: String -> [Float]
frecuencias xs = 
    [porcentaje (ocurrencias x xs) n | x <- ['a'..'z']]
    where n = length (minusculas xs)

frecuencias "en todo la medida"

chiCuad :: [Float] -> [Float] -> Float
chiCuad os es = 
    sum [((o-e)^2)/e | (o,e) <- zip os es]

chiCuad [3,5,6] [3,5,6]  

chiCuad [3,5,6] [5,6,3]  

rota :: Int -> [a] -> [a]
rota n xs = drop n xs ++ take n xs

rota 2 "manolo"

descifra :: String -> String
descifra xs =  codifica (-factor) xs
 where
  factor = head (posiciones (minimum tabChi) tabChi)
  tabChi = [chiCuad (rota n tabla') tabla | n <- [0..25]]
  tabla' = frecuencias xs

codifica 5 "Todo para nada" 

descifra "Ttit ufwf sfif"