Menu Close

Sumas parciales de Juzuk

En 1939 Dov Juzuk extendió el método de Nicómaco del cálculo de los cubos. La extensión se basaba en los siguientes pasos:

  • se comienza con la lista de todos los enteros positivos
     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, ...
  • se agrupan tomando el primer elemento, los dos siguientes, los tres
    siguientes, etc.
     [[1], [2, 3], [4, 5, 6], [7, 8, 9, 10], [11, 12, 13, 14, 15], ...
  • se seleccionan los elementos en posiciones pares
     [[1],         [4, 5, 6],                [11, 12, 13, 14, 15], ...
  • se suman los elementos de cada grupo
     [1,           15,                       65,                   ...
  • se calculan las sumas acumuladas
     [1,           16,                       81,                   ...

Las sumas obtenidas son las cuantas potencias de los números enteros positivos.

Definir las funciones

   listasParcialesJuzuk :: [a] -> [[a]]
   sumasParcialesJuzuk  :: [Integer] -> [Integer]

tal que

  • (listasParcialesJuzuk xs) es lalista de ls listas parciales de Juzuk; es decir, la selección de los elementos en posiciones pares de la agrupación de los elementos de xs tomando el primer elemento, los dos siguientes, los tres siguientes, etc. Por ejemplo,
     λ> take 4 (listasParcialesJuzuk [1..])
     [[1],[4,5,6],[11,12,13,14,15],[22,23,24,25,26,27,28]]
     λ> take 4 (listasParcialesJuzuk [1,3..])
     [[1],[7,9,11],[21,23,25,27,29],[43,45,47,49,51,53,55]]
  • (sumasParcialesJuzuk xs) es la lista de las sumas acumuladas de los elementos de las listas de Juzuk generadas por xs. Por ejemplo,
     take 4 (sumasParcialesJuzuk [1..])  ==  [1,16,81,256]
     take 4 (sumasParcialesJuzuk [1,3..])  ==  [1,28,153,496]

Comprobar con QuickChek que, para todo entero positivo n,

  • el elemento de (sumasParcialesJuzuk [1..]) en la posición (n-1) es n^4.
  • el elemento de (sumasParcialesJuzuk [1,3..]) en la posición (n-1) es n^2*(2*n^2 - 1).
  • el elemento de (sumasParcialesJuzuk [1,5..]) en la posición (n-1) es 4*n^4-3*n^2.
  • el elemento de (sumasParcialesJuzuk [2,3..]) en la posición (n-1) es n^2*(n^2+1).

Soluciones

import Data.List (genericIndex)
import Test.QuickCheck
 
listasParcialesJuzuk :: [a] -> [[a]]
listasParcialesJuzuk = elementosEnPares . listasParciales
 
-- (listasParciales xs) es la agrupación de los elementos de xs obtenida
-- tomando el primer elemento, los dos siguientes, los tres siguientes,
-- etc. Por ejemplo, 
--    λ> take 5 (listasParciales [1..])
--    [[1],[2,3],[4,5,6],[7,8,9,10],[11,12,13,14,15]]
listasParciales :: [a] -> [[a]]
listasParciales = aux 1
  where aux n xs = ys : aux (n+1) zs  
          where (ys,zs) = splitAt n xs
 
-- (elementosEnPares xs) es la lista de los elementos de xs en
-- posiciones pares. Por ejemplo,
--    λ> elementosEnPares [[1],[2,3],[4,5,6],[7,8,9,10],[11,12,13,14,15]]
--    [[1],[4,5,6],[11,12,13,14,15]]
elementosEnPares :: [a] -> [a]
elementosEnPares []       = []
elementosEnPares [x]      = [x]
elementosEnPares (x:_:xs) = x : elementosEnPares xs
 
sumasParcialesJuzuk :: [Integer] -> [Integer]
sumasParcialesJuzuk xs =
  scanl1 (+) (map sum (listasParcialesJuzuk xs))
 
-- La primera propiedad es
prop_sumasParcialesJuzuk :: (Positive Integer) -> Bool
prop_sumasParcialesJuzuk (Positive n) =
  sumasParcialesJuzuk [1..] `genericIndex` (n-1) == n^4
 
-- Su comprobación es
--    λ> quickCheck prop_sumasParcialesJuzuk
--    +++ OK, passed 100 tests.
 
-- La segunda propiedad es
prop_sumasParcialesJuzuk2 :: (Positive Integer) -> Bool
prop_sumasParcialesJuzuk2 (Positive n) =
  sumasParcialesJuzuk [1,3..] `genericIndex` (n-1) == n^2*(2*n^2 - 1)
 
-- Su comprobación es
--    λ> quickCheck prop_sumasParcialesJuzuk2
--    +++ OK, passed 100 tests.
 
-- La tercera propiedad es
prop_sumasParcialesJuzuk3 :: (Positive Integer) -> Bool
prop_sumasParcialesJuzuk3 (Positive n) =
  sumasParcialesJuzuk [1,5..] `genericIndex` (n-1) == 4*n^4-3*n^2
 
-- Su comprobación es
--    λ> quickCheck prop_sumasParcialesJuzuk3
--    +++ OK, passed 100 tests.
 
-- La cuarta propiedad es
prop_sumasParcialesJuzuk4 :: (Positive Integer) -> Bool
prop_sumasParcialesJuzuk4 (Positive n) =
  sumasParcialesJuzuk [2,3..] `genericIndex` (n-1) == n^2*(n^2+1)
 
-- Su comprobación es
--    λ> quickCheck prop_sumasParcialesJuzuk4
--    +++ OK, passed 100 tests.

11 soluciones de “Sumas parciales de Juzuk

  1. alerodrod5
     
    import Test.QuickCheck
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk xs = [ys | ys <- listasParciales xs, odd (length ys), not(null ys)]
     
    listasParciales :: [a] -> [[a]]
    listasParciales = aux 0
      where aux n xs = ys : aux (n+1) zs  
              where (ys,zs) = splitAt n xs
     
    sumasParcialesJuzuk :: [Integer] -> [Integer]
    sumasParcialesJuzuk xs = aux (listasParcialesJuzuk xs)
      where aux (xs:xss) = sum xs : map (+sum xs) (aux xss)
     
    propiedad1 n = n>0 ==>fromInteger((sumasParcialesJuzuk [1..])!!(n-1)) ==  n^4
    --quickCheck propiedad1   
    -- +++ OK, passed 100 tests.
     
    propiedad2 n = n>0 ==>fromInteger((sumasParcialesJuzuk [1,3..])!!(n-1)) ==  (n^2)*(2*n^2 -1)
    --quickCheck propiedad2  
    -- +++ OK, passed 100 tests.
     
    propiedad3 n = n>0 ==> fromInteger((sumasParcialesJuzuk [1,5..]) !! (n-1)) == 4*n^4-3*n^2
    --quickCheck propiedad3  
    -- +++ OK, passed 100 tests.
     
     
    propiedad4 n = n>0 ==> fromInteger((sumasParcialesJuzuk [2,3..]) !! (n-1)) == n^2*(n^2+ 1)
    -- quickCheck propiedad4  
    -- +++ OK, passed 100 tests.
  2. albcarcas1
     
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk xs = [xss !! n | n <- [0,2..]]
      where xss = [take n (drop (div (n*(n-1)) 2) xs) | n <- [1..]]
     
    sumasParcialesJuzuk  :: [Integer] -> [Integer]
    sumasParcialesJuzuk xs  = [sum(take n xss) | n <- [1..]]
      where xss = map sum (listasParcialesJuzuk xs)
     
    prop1 :: Int -> Property
    prop1 n = n>0 ==>fromInteger((sumasParcialesJuzuk [1..]) !! (n-1)) ==  n^4
    prop2 :: Int -> Property
    prop2 n = n>0 ==>fromInteger((sumasParcialesJuzuk [1,3..]) !! (n-1)) ==  (n^2)*(2*n^2 -1)
    prop3 :: Int -> Property
    prop3 n = n>0 ==> fromInteger((sumasParcialesJuzuk [1,5..]) !! (n-1)) == 4*n^4-3*n^2
    prop4 :: Int -> Property
    prop4 n = n>0 ==> fromInteger((sumasParcialesJuzuk [2,3..]) !! (n-1)) == n^2*(n^2+ 1)
  3. angruicam1
    import Data.List       (scanl')
    import Data.List.Split (splitPlaces)
    import Test.QuickCheck
     
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk xs =
      [splitPlaces [1..] xs !! n | n <- [0,2..]]
     
    sumasParcialesJuzuk :: [Integer] -> [Integer]
    sumasParcialesJuzuk =
      tail
      . scanl' (flip ((+) . sum)) 0
      . listasParcialesJuzuk
     
    prop_Juzuk1 :: (Positive Integer) -> Bool
    prop_Juzuk1 (Positive n) =
      sumasParcialesJuzuk [1..]
      !! (fromEnum n - 1) == n^4
     
    prop_Juzuk2 :: (Positive Integer) -> Bool
    prop_Juzuk2 (Positive n) =
      sumasParcialesJuzuk [1,3..]
      !! (fromEnum n - 1) == n^2 * (2 * n^2 - 1)
     
    prop_Juzuk3 :: (Positive Integer) -> Bool
    prop_Juzuk3 (Positive n) =
      sumasParcialesJuzuk [1,5..]
      !! (fromEnum n - 1) == 4 * n^4 - 3 * n^2
     
    prop_Juzuk4 :: (Positive Integer) -> Bool
    prop_Juzuk4 (Positive n) =
      sumasParcialesJuzuk [2,3..]
      !! (fromEnum n - 1) == n^2 * (n^2 + 1)
    • angruicam1

      Para comprobar las propiedades:

      {-# LANGUAGE TemplateHaskell #-}
       
      return []
      runTests = $quickCheckAll
       
      -- La comprobación es
      --    λ> runTests
      --    === prop_Juzuk1 ===
      --    +++ OK, passed 100 tests.
      --
      --    === prop_Juzuk2 ===
      --    +++ OK, passed 100 tests.
      --
      --    === prop_Juzuk3 ===
      --    +++ OK, passed 100 tests.
      --
      --    === prop_Juzuk4 ===
      --    +++ OK, passed 100 tests.
      --
      --    True
  4. carbremor
    import Test.QuickCheck
    import Data.List
    import Data.List.Split
     
    listasParciales :: [a] -> [[a]]
    listasParciales xs = splitPlaces [1..] xs
     
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk xs = [x | (x,i) <- zip (listasParciales xs) [1..], i `mod` 2 /= 0]
     
    sumas :: [Integer] -> [Integer]
    sumas xs = map (sum) (listasParcialesJuzuk xs)
     
    sumasParcialesJuzuk :: [Integer] -> [Integer]
    sumasParcialesJuzuk xs = scanl1 (+) (sumas xs)
     
    propiedad_1 :: Int -> Property
    propiedad_1 n = n>0 ==>fromInteger((sumasParcialesJuzuk [1..]) !! (n-1)) ==  n^4
     
    propiedad_2 :: Int -> Property
    propiedad_2 n = n>0 ==>fromInteger((sumasParcialesJuzuk [1,3..]) !! (n-1)) ==  (n^2)*(2*n^2 -1)
     
    propiedad_3 :: Int -> Property
    propiedad_3 n = n>0 ==> fromInteger((sumasParcialesJuzuk [1,5..]) !! (n-1)) == 4*n^4-3*n^2
     
    propiedad_4 :: Int -> Property
    propiedad_4 n = n>0 ==> fromInteger((sumasParcialesJuzuk [2,3..]) !! (n-1)) == n^2*(n^2+ 1)
  5. pabhueacu
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk = aux 1
      where aux _ [] = []
            aux y xs = take y xs : (aux (y+2) (drop (2*y+1) xs))
     
     
    sumasParcialesJuzuk  :: [Integer] -> [Integer]
    sumasParcialesJuzuk  = aux 0.listasParcialesJuzuk
                    where aux _ [] = []
                          aux y (xs:xss) = z : aux z xss
                           where z = y + sum xs
  6. jorcatote
    import Data.List.Split
     
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk xs = aux (splitPlaces [1..] xs)
      where aux (x:y:xs) = x :aux xs
     
    sumasParcialesJuzuk :: [Integer] -> [Integer]
    sumasParcialesJuzuk = scanl1 (+) . map sum . listasParcialesJuzuk
  7. josmoncos
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk = aux2 . aux 1 
      where aux n xs = ys : aux (n+1) zs
              where (ys,zs) = splitAt n xs
     
    aux2 (xs:ys:xss) = xs: aux2 xss
     
    sumasParcialesJuzuk  :: [Integer] -> [Integer]
    sumasParcialesJuzuk = aux3 . listasParcialesJuzuk
      where aux3 (xs:ys:xss) = sum xs : aux3 ((sum xs:ys):xss)

    Las comprobaciones serían análogas al primer comentario

  8. Chema Cortés
    import           Data.List
    import           Test.QuickCheck
     
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk xs = aux xs [1..]
      where
        aux xs (k:p:ks) = take k xs : aux (drop (k+p) xs) ks
     
    sumasParcialesJuzuk  :: [Integer] -> [Integer]
    sumasParcialesJuzuk = scanl1 (+) . map sum . listasParcialesJuzuk
  9. menvealer
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk xs = [ys | (ys,x) <- zip (agrupa1 1 xs) [0..], even x] 
     
    agrupa1 :: Int -> [a] -> [[a]]
    agrupa1 n (x:xs) = ys : agrupa1 (n+1) (drop (length ys - 1) xs )
      where ys = take n (x:xs)
  10. gernarsie

    
    listasParcialesJuzuk :: [a] -> [[a]]
    listasParcialesJuzuk = aux 1
      where aux _ [] = []
            aux x xs = take x xs : (aux (x+2) (drop (2*x+1) xs))
    
    sumasParcialesJuzuk  :: [Integer] -> [Integer]
    sumasParcialesJuzuk xs  = [ sum (take k  ns) | k <- [1..]]
      where ns = map (sum) (listasParcialesJuzuk xs)
            
    

Leave a Reply

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