Menu Close

Enumeración de los números enteros

Definir la sucesión

   enteros :: [Int]

tal que sus elementos son los números enteros comenzando en el 0 e intercalando los positivos y los negativos. Por ejemplo,

   ghci> take 23 enteros
   [0,1,-1,2,-2,3,-3,4,-4,5,-5,6,-6,7,-7,8,-8,9,-9,10,-10,11,-11]

Comprobar con QuickCheck que el n-ésimo término de la sucesión es
(1-(2*n+1)*(-1)^n)/4.

Nota. En la comprobación usar

   quickCheckWith (stdArgs {maxSize=7}) prop_enteros

Soluciones

import Test.QuickCheck
import Control.Applicative ((<**>))
 
-- 1ª definición
enteros :: [Int]
enteros = 0 : concat [[n,-n] | n <- [1..]]
 
-- 2ª definición
enteros2 :: [Int]
enteros2 = 0 : [y | x <- [1..], y <- [x, -x]]
 
-- 3ª definición
enteros3 :: [Int]
enteros3 = iterate siguiente 0
  where siguiente i | i > 0     = -i
                    | otherwise = 1 - i
 
-- 4ª definición
enteros4 :: [Int]
enteros4 = iterate (\i -> if i > 0 then -i else 1-i) 0
 
-- 5ª definición
enteros5 :: [Int]
enteros5 = 0 : [f x | x <- [1..], f <- [id, negate]]
 
-- 6ª definición
enteros6 :: [Int]
enteros6 = 0 : ([1..] <**> [id, negate])
 
-- La propiedad es
prop_enteros :: Int -> Property
prop_enteros n = 
    n >= 0 ==> enteros !! n == (1-(2*n+1)*(-1)^n) `div` 4
 
-- La comprobación es
--    ghci> quickCheckWith (stdArgs {maxSize=7}) prop_enteros
--    +++ OK, passed 100 tests.

8 soluciones de “Enumeración de los números enteros

  1. jaibengue
    enteros :: [Int]
    enteros = 0:(concat [[x,(-1)*x] | x<-[1..]])
  2. carbremor
     
    enteros :: [Int]
    enteros =  0:(tupla2Lista (zip [1..] (map (negate) [1..])))
     
    tupla2Lista :: [(a,a)] -> [a]
    tupla2Lista ((a,b):xs) = a : b : tupla2Lista xs
    tupla2Lista _          = []
  3. alerodrod5
     
    enteros :: [Int]
    enteros = 0:[(-1)^x*n | n<-[1..], x<-[0,1]]
  4. angruicam1
    import Test.QuickCheck
     
    enteros :: [Int]
    enteros = 0 : concat [[x,-x] | x <- [1..]]
     
    prop_enteros :: Int -> Property
    prop_enteros n = n > 0 ==>
      enteros !! n == div (1 - (2 * n + 1) * (-1)^n) 4
     
    -- La comprobación es
    --    λ> quickCheckWith (stdArgs {maxSize=7}) prop_enteros
    --    +++ OK, passed 100 tests
  5. antgongar
    import Control.Applicative ((<**>))
     
    enteros :: [Int]
    enteros = 0 : ([1..] <**> [id, negate])
  6. antgongar
    enteros :: [Int]
    enteros = 0 : [f x | x <- [1..], f <- [id, negate]]
  7. albcarcas1
     
    enteros :: [Int]
    enteros = 0:(aux 1)
      where aux x |x > 0 = [x] ++ aux (-x)
                  |otherwise = [x] ++ aux (-x + 1)
  8. menvealer
     
    enteros :: [Int]
    enteros = 0 : concat (map tuplar (zip [1..] [-1,-2..]))
      where tuplar (a,b) = [a,b]
     
    prop_enteros :: Int -> Property
    prop_enteros n = n > 0 ==>
      enteros !! n == div (1 - (2 * n + 1) * (-1)^n) 4
     
    -- La comprobación es
    --    λ> quickCheckWith (stdArgs {maxSize=7}) prop_enteros
    --    +++ OK, passed 100 tests.

Leave a Reply

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.