Sumas parciales de Juzuk

José A. Alonso, 23-enero-2018

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.

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.

Posted in Medio

Tagged genericIndex, map, Orden superior, Recursión, scanl1, splitAt, sum, Test.QuickCheck

11 Comments

alerodrod5

23-enero-2018 at 08:56

Responder

 
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.

albcarcas1

23-enero-2018 at 09:12

Responder

 
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)

angruicam1

23-enero-2018 at 10:03

Responder

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

24-enero-2018 at 15:27

Responder

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

carbremor

23-enero-2018 at 13:48

Responder

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)

pabhueacu

25-enero-2018 at 11:21

Responder

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

jorcatote

25-enero-2018 at 14:05

Responder

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

josmoncos

26-enero-2018 at 18:05

Responder

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

Chema Cortés

27-enero-2018 at 19:29

Responder

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

menvealer

28-enero-2018 at 12:38

Responder

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)

gernarsie
29-enero-2018 at 21:56
Responder
```
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)
        
```

Escribe tu soluciónCancel reply

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

Sumas parciales de Juzuk

Soluciones

11 Comments

Escribe tu soluciónCancel reply

Subscribe to Blog via Email

Entradas recientes

Etiquetas

Sumas parciales de Juzuk

Soluciones

Se puede imprimir o compartir con

11 Comments

Escribe tu soluciónCancel reply

Subscribe to Blog via Email

Entradas recientes

Etiquetas