odd

Tablas de operaciones binarias

PorJosé A. Alonso 26-diciembre-20182-enero-2019

Para representar las operaciones binarias en un conjunto finito A con n elementos se pueden numerar sus elementos desde el 0 al n-1. Entonces cada operación binaria en A se puede ver como una lista de listas xss tal que el valor de aplicar la operación a los elementos i y j es el j-ésimo elemento del i-ésimo elemento de xss. Por ejemplo, si A = {0,1,2} entonces las tabla de la suma y de la resta módulo 3 en A son

   0 1 2    0 2 1
   1 2 0    1 0 2
   2 0 1    2 1 0
   Suma     Resta

0 1 2 0 2 1

1 2 0 1 0 2

2 0 1 2 1 0

Suma Resta

Definir las funciones

   tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
   tablaSuma      :: Int -> [[Int]]
   tablaResta     :: Int -> [[Int]]
   tablaProducto  :: Int -> [[Int]]

tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]

tablaSuma :: Int -> [[Int]]

tablaResta :: Int -> [[Int]]

tablaProducto :: Int -> [[Int]]

tales que

(tablaOperacion f n) es la tabla de la operación f módulo n en [0..n-1]. Por ejemplo,

     tablaOperacion (+) 3  ==  [[0,1,2],[1,2,0],[2,0,1]]
     tablaOperacion (-) 3  ==  [[0,2,1],[1,0,2],[2,1,0]]
     tablaOperacion (-) 4  ==  [[0,3,2,1],[1,0,3,2],[2,1,0,3],[3,2,1,0]]
     tablaOperacion (\x y -> abs (x-y)) 3  ==  [[0,1,2],[1,0,1],[2,1,0]]

tablaOperacion (+) 3 == [[0,1,2],[1,2,0],[2,0,1]]

tablaOperacion (-) 3 == [[0,2,1],[1,0,2],[2,1,0]]

tablaOperacion (-) 4 == [[0,3,2,1],[1,0,3,2],[2,1,0,3],[3,2,1,0]]

tablaOperacion (\x y -> abs (x-y)) 3 == [[0,1,2],[1,0,1],[2,1,0]]

(tablaSuma n) es la tabla de la suma módulo n en [0..n-1]. Por ejemplo,

     tablaSuma 3  ==  [[0,1,2],[1,2,0],[2,0,1]]
     tablaSuma 4  ==  [[0,1,2,3],[1,2,3,0],[2,3,0,1],[3,0,1,2]]

1 2	tablaSuma 3 == [[0,1,2],[1,2,0],[2,0,1]] tablaSuma 4 == [[0,1,2,3],[1,2,3,0],[2,3,0,1],[3,0,1,2]]

(tablaResta n) es la tabla de la resta módulo n en [0..n-1]. Por ejemplo,

     tablaResta 3  ==  [[0,2,1],[1,0,2],[2,1,0]]
     tablaResta 4  ==  [[0,3,2,1],[1,0,3,2],[2,1,0,3],[3,2,1,0]]

1 2	tablaResta 3 == [[0,2,1],[1,0,2],[2,1,0]] tablaResta 4 == [[0,3,2,1],[1,0,3,2],[2,1,0,3],[3,2,1,0]]

(tablaProducto n) es la tabla del producto módulo n en [0..n-1]. Por ejemplo,

     tablaProducto 3  ==  [[0,0,0],[0,1,2],[0,2,1]]
     tablaProducto 4  ==  [[0,0,0,0],[0,1,2,3],[0,2,0,2],[0,3,2,1]]

1 2	tablaProducto 3 == [[0,0,0],[0,1,2],[0,2,1]] tablaProducto 4 == [[0,0,0,0],[0,1,2,3],[0,2,0,2],[0,3,2,1]]

Comprobar con QuickCheck, si parato entero positivo n de verificar las siguientes propiedades:

La suma, módulo n, de todos los números de (tablaSuma n) es 0.
La suma, módulo n, de todos los números de (tablaResta n) es 0.
La suma, módulo n, de todos los números de (tablaProducto n) es n/2 si n es el doble de un número impar y es 0, en caso contrario.

Soluciones

import Test.QuickCheck

tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
tablaOperacion f n =
  [[f i j `mod` n | j <- [0..n-1]] | i <- [0..n-1]]

tablaSuma :: Int -> [[Int]]
tablaSuma = tablaOperacion (+)

tablaResta :: Int -> [[Int]]
tablaResta = tablaOperacion (-)

tablaProducto :: Int -> [[Int]]
tablaProducto = tablaOperacion (*)

-- (sumaTabla xss) es la suma, módulo n, de los elementos de la tabla de
-- operación xss (donde n es el número de elementos de xss). Por
-- ejemplo, 
--    sumaTabla [[0,2,1],[1,1,2],[2,1,0]]  ==  1
sumaTabla :: [[Int]] -> Int
sumaTabla = sum . concat

-- La propiedad de la tabla de la suma es
prop_tablaSuma :: (Positive Int) -> Bool
prop_tablaSuma (Positive n) =
  sumaTabla (tablaSuma n) == 0

-- La comprobación es
--    λ> quickCheck prop_tablaSuma
--    +++ OK, passed 100 tests.

-- La propiedad de la tabla de la resta es
prop_tablaResta :: (Positive Int) -> Bool
prop_tablaResta (Positive n) =
  sumaTabla (tablaResta n) == 0

-- La comprobación es
--    λ> quickCheck prop_tablaResta
--    +++ OK, passed 100 tests.
  
-- La propiedad de la tabla del producto es
prop_tablaProducto :: (Positive Int) -> Bool
prop_tablaProducto (Positive n)
  | even n && odd (n `div` 2) = suma == n `div` 2
  | otherwise                 = suma == 0
  where suma = sumaTabla (tablaProducto n)

import Test.QuickCheck

tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]

tablaOperacion f n =

[[f i j `mod` n | j <- [0..n-1]] | i <- [0..n-1]]

tablaSuma :: Int -> [[Int]]

tablaSuma = tablaOperacion (+)

tablaResta :: Int -> [[Int]]

tablaResta = tablaOperacion (-)

tablaProducto :: Int -> [[Int]]

tablaProducto = tablaOperacion (*)

-- (sumaTabla xss) es la suma, módulo n, de los elementos de la tabla de

-- operación xss (donde n es el número de elementos de xss). Por

-- ejemplo,

-- sumaTabla [[0,2,1],[1,1,2],[2,1,0]] == 1

sumaTabla :: [[Int]] -> Int

sumaTabla = sum . concat

-- La propiedad de la tabla de la suma es

prop_tablaSuma :: (Positive Int) -> Bool

prop_tablaSuma (Positive n) =

sumaTabla (tablaSuma n) == 0

-- La comprobación es

-- λ> quickCheck prop_tablaSuma

-- +++ OK, passed 100 tests.

-- La propiedad de la tabla de la resta es

prop_tablaResta :: (Positive Int) -> Bool

prop_tablaResta (Positive n) =

sumaTabla (tablaResta n) == 0

-- La comprobación es

-- λ> quickCheck prop_tablaResta

-- +++ OK, passed 100 tests.

-- La propiedad de la tabla del producto es

prop_tablaProducto :: (Positive Int) -> Bool

prop_tablaProducto (Positive n)

| even n && odd (n `div` 2) = suma == n `div` 2

| otherwise = suma == 0

where suma = sumaTabla (tablaProducto n)

Pensamiento

¿Tu verdad? No, la Verdad,
y ven conmigo a buscarla.
La tuya guárdatela.

Antonio Machado

División equitativa

PorJosé A. Alonso 6-febrero-201826-marzo-2022

Definir la función

   divisionEquitativa :: [Int] -> Maybe ([Int],[Int])

1	divisionEquitativa :: [Int] -> Maybe ([Int],[Int])

tal que (divisionEquitativa xs) determina si la lista de números enteros positivos xs se puede dividir en dos partes (sin reordenar sus elementos) con la misma suma. Si es posible, su valor es el par formado por las dos partes. Si no lo es, su valor es Nothing. Por ejemplo,

   divisionEquitativa [1,2,3,4,5,15]  ==  Just ([1,2,3,4,5],[15])
   divisionEquitativa [15,1,2,3,4,5]  ==  Just ([15],[1,2,3,4,5])
   divisionEquitativa [1,2,3,4,7,15]  ==  Nothing
   divisionEquitativa [1,2,3,4,15,5]  ==  Nothing

divisionEquitativa [1,2,3,4,5,15] == Just ([1,2,3,4,5],[15])

divisionEquitativa [15,1,2,3,4,5] == Just ([15],[1,2,3,4,5])

divisionEquitativa [1,2,3,4,7,15] == Nothing

divisionEquitativa [1,2,3,4,15,5] == Nothing

Soluciones

import Data.Maybe (isNothing, fromJust, listToMaybe)
import Data.List  (elemIndex, inits, tails)

-- 1ª solución
divisionEquitativa1 :: [Int] -> Maybe ([Int],[Int])
divisionEquitativa1 xs = aux (particiones xs)
 where aux []                              = Nothing
       aux ((as,bs):ys) | sum as == sum bs = Just (as,bs)
                        | otherwise        = aux ys                   
       particiones xs = [splitAt i xs | i <- [1..length xs-1]]

-- 2ª solución
divisionEquitativa2 :: [Int] -> Maybe ([Int],[Int])
divisionEquitativa2 xs
  | 2 * b == suma = Just $ splitAt (length as + 1) xs
  | otherwise     = Nothing
  where suma        = sum xs
        (as,(b:bs)) = span (<suma `div` 2) $ scanl1 (+) xs

-- 3ª solución
divisionEquitativa3 :: [Int] -> Maybe ([Int],[Int])
divisionEquitativa3 xs
  | odd n       = Nothing
  | isNothing p = Nothing
  | otherwise   = Just (splitAt (1 + fromJust p) xs)
  where n  = sum xs
        ys = scanl1 (+) xs
        p  = elemIndex (n `div` 2) ys

-- 4ª solución
divisionEquitativa4 :: [Int] -> Maybe ([Int],[Int])
divisionEquitativa4 xs
  | odd (sum xs) = Nothing
  | otherwise    = aux [] xs
  where aux as bs@(b:bs') | sum as == sum bs = Just (reverse as, bs)
                          | sum as > sum bs  = Nothing
                          | otherwise        = aux (b:as) (bs')

-- 5ª solución
divisionEquitativa5 :: [Int] -> Maybe ([Int],[Int])
divisionEquitativa5 xs =
  listToMaybe
    [(ys, zs) | (ys,zs) <- zip (inits xs) (tails xs)
              , sum ys == sum zs ]

import Data.Maybe (isNothing, fromJust, listToMaybe)

import Data.List (elemIndex, inits, tails)

-- 1ª solución

divisionEquitativa1 :: [Int] -> Maybe ([Int],[Int])

divisionEquitativa1 xs = aux (particiones xs)

where aux [] = Nothing

aux ((as,bs):ys) | sum as == sum bs = Just (as,bs)

| otherwise = aux ys

particiones xs = [splitAt i xs | i <- [1..length xs-1]]

-- 2ª solución

divisionEquitativa2 :: [Int] -> Maybe ([Int],[Int])

divisionEquitativa2 xs

| 2 * b == suma = Just $ splitAt (length as + 1) xs

| otherwise = Nothing

where suma = sum xs

(as,(b:bs)) = span (<suma `div` 2) $ scanl1 (+) xs

-- 3ª solución

divisionEquitativa3 :: [Int] -> Maybe ([Int],[Int])

divisionEquitativa3 xs

| odd n = Nothing

| isNothing p = Nothing

| otherwise = Just (splitAt (1 + fromJust p) xs)

where n = sum xs

ys = scanl1 (+) xs

p = elemIndex (n `div` 2) ys

-- 4ª solución

divisionEquitativa4 :: [Int] -> Maybe ([Int],[Int])

divisionEquitativa4 xs

| odd (sum xs) = Nothing

| otherwise = aux [] xs

where aux as bs@(b:bs') | sum as == sum bs = Just (reverse as, bs)

| sum as > sum bs = Nothing

| otherwise = aux (b:as) (bs')

-- 5ª solución

divisionEquitativa5 :: [Int] -> Maybe ([Int],[Int])

divisionEquitativa5 xs =

listToMaybe

[(ys, zs) | (ys,zs) <- zip (inits xs) (tails xs)

, sum ys == sum zs ]

Listas alternadas

PorJosé A. Alonso 2-diciembre-20169-diciembre-2016

Una lista de números enteros se llama alternada si sus elementos son alternativamente par/impar o impar/par.

Definir la función

   alternada :: [Int] -> Bool

1	alternada :: [Int] -> Bool

tal que (alternada xs) se verifica si xs es una lista alternada. Por ejemplo,

   alternada [1,2,3]     == True
   alternada [1,4,6,5]   == False
   alternada [1,4,3,5]   == False
   alternada [8,1,2,3,4] == True
   alternada [8,1,2,3]   == True
   alternada [8]         == True
   alternada [7]         == True

alternada [1,2,3] == True

alternada [1,4,6,5] == False

alternada [1,4,3,5] == False

alternada [8,1,2,3,4] == True

alternada [8,1,2,3] == True

alternada [8] == True

alternada [7] == True

Soluciones

-- 1ª solución:
alternada1 :: [Int] -> Bool
alternada1 (x:y:xs)
  | even x    = odd y  && alternada1 (y:xs)
  | otherwise = even y && alternada1 (y:xs)
alternada1 _ = True

-- 2ª solución
alternada2 :: [Int] -> Bool
alternada2 xs = all odd (zipWith (+) xs (tail xs))

-- 1ª solución:

alternada1 :: [Int] -> Bool

alternada1 (x:y:xs)

| even x = odd y && alternada1 (y:xs)

| otherwise = even y && alternada1 (y:xs)

alternada1 _ = True

-- 2ª solución

alternada2 :: [Int] -> Bool

alternada2 xs = all odd (zipWith (+) xs (tail xs))

Sumas de posiciones pares e impares

PorJosé A. Alonso 1-diciembre-20168-diciembre-2016

Definir la función

   sumasParesImpares :: [Integer] -> (Integer,Integer)

1	sumasParesImpares :: [Integer] -> (Integer,Integer)

tal que (sumasParesImpares) xs es el par formado por la suma de los elementos de xs en posiciones pares y por la suma de los elementos de xs en posiciones impares. Por ejemplo,

   sumasParesImpares []         ==  (0,0)
   sumasParesImpares [3]        ==  (3,0)
   sumasParesImpares [3,2]      ==  (3,2)
   sumasParesImpares [3,2,1]    ==  (4,2)
   sumasParesImpares [3,2,1,5]  ==  (4,7)
   sumasParesImpares [1..10^7]  ==  (25000000000000,25000005000000)

sumasParesImpares [] == (0,0)

sumasParesImpares [3] == (3,0)

sumasParesImpares [3,2] == (3,2)

sumasParesImpares [3,2,1] == (4,2)

sumasParesImpares [3,2,1,5] == (4,7)

sumasParesImpares [1..10^7] == (25000000000000,25000005000000)

Soluciones

-- 1ª solución
sumasParesImpares1 :: [Integer] -> (Integer,Integer)
sumasParesImpares1 xs =
  (sum [x | (x,n) <- xns, even n],
   sum [x | (x,n) <- xns, odd n])
  where xns = zip xs [0..]

-- 2ª solución
sumasParesImpares2 :: [Integer] -> (Integer,Integer)
sumasParesImpares2 xs = aux xs (0,0)
  where aux (x1:x2:xs) (a,b) = aux xs (x1+a,x2+b)
        aux [x]        (a,b) = (x+a,b)
        aux []         (a,b) = (a,b)
  
-- Comparación de eficiencia
--    λ> sumasParesImpares1 [1..10^6]
--    (250000000000,250000500000)
--    (4.48 secs, 731,994,904 bytes)
--    λ> sumasParesImpares2 [1..10^6]
--    (250000000000,250000500000)
--    (1.78 secs, 235,663,400 bytes)

-- 1ª solución

sumasParesImpares1 :: [Integer] -> (Integer,Integer)

sumasParesImpares1 xs =

(sum [x | (x,n) <- xns, even n],

sum [x | (x,n) <- xns, odd n])

where xns = zip xs [0..]

-- 2ª solución

sumasParesImpares2 :: [Integer] -> (Integer,Integer)

sumasParesImpares2 xs = aux xs (0,0)

where aux (x1:x2:xs) (a,b) = aux xs (x1+a,x2+b)

aux [x] (a,b) = (x+a,b)

aux [] (a,b) = (a,b)

-- Comparación de eficiencia

-- λ> sumasParesImpares1 [1..10^6]

-- (250000000000,250000500000)

-- (4.48 secs, 731,994,904 bytes)

-- λ> sumasParesImpares2 [1..10^6]

-- (250000000000,250000500000)

-- (1.78 secs, 235,663,400 bytes)

Paridad del número de divisores

PorJosé A. Alonso 10-marzo-201617-marzo-2016

Definir la función

   nDivisoresPar :: Integer -> Bool

1	nDivisoresPar :: Integer -> Bool

tal que (nDivisoresPar n) se verifica si n tiene un número par de divisores. Por ejemplo,

   nDivisoresPar 12                     ==  True
   nDivisoresPar 16                     ==  False
   nDivisoresPar (product [1..2*10^4])  ==  True

nDivisoresPar 12 == True

nDivisoresPar 16 == False

nDivisoresPar (product [1..2*10^4]) == True

Soluciones

import Data.List (group)
import Data.Numbers.Primes (primeFactors)

-- 1ª definición
-- =============

nDivisoresPar1 :: Integer -> Bool
nDivisoresPar1 = even . length . divisores

-- (divisores n) es la lista de los divisores de n. Por ejemplo,
--    divisores 12  ==  [1,2,3,4,6,12]
--    divisores 16  ==  [1,2,4,8,16]
divisores :: Integer -> [Integer]
divisores n =
    [x | x <- [1..n], n `mod` x == 0]

-- 2ª definición
-- =============

nDivisoresPar2 :: Integer -> Bool
nDivisoresPar2 n =
    any odd (map length (group (primeFactors n)))

-- Comparación de eficiencia
-- =========================

--    λ> nDivisoresPar1 (10^7)
--    True
--    (14.18 secs, 2,078,736,992 bytes)
--    λ> nDivisoresPar2 (10^7)
--    True
--    (0.01 secs, 0 bytes)
--
--    λ> nDivisoresPar2 (product [1..2*10^4])
--    True
--    (2.30 secs, 1,003,013,112 bytes)

import Data.List (group)

import Data.Numbers.Primes (primeFactors)

-- 1ª definición

-- =============

nDivisoresPar1 :: Integer -> Bool

nDivisoresPar1 = even . length . divisores

-- (divisores n) es la lista de los divisores de n. Por ejemplo,

-- divisores 12 == [1,2,3,4,6,12]

-- divisores 16 == [1,2,4,8,16]

divisores :: Integer -> [Integer]

divisores n =

[x | x <- [1..n], n `mod` x == 0]

-- 2ª definición

-- =============

nDivisoresPar2 :: Integer -> Bool

nDivisoresPar2 n =

any odd (map length (group (primeFactors n)))

-- Comparación de eficiencia

-- =========================

-- λ> nDivisoresPar1 (10^7)

-- True

-- (14.18 secs, 2,078,736,992 bytes)

-- λ> nDivisoresPar2 (10^7)

-- True

-- (0.01 secs, 0 bytes)

-- λ> nDivisoresPar2 (product [1..2*10^4])

-- True

-- (2.30 secs, 1,003,013,112 bytes)

Solución en Maxima

/* concat(xs) es la lista obtenida concatenado los elementos de xss. Por
   ejemplo,
      concat([[1,3],[2,4],[5,7]])  ==  [1, 3, 2, 4, 5, 7]             */
concat (xs) := block ([r:[]],
  for x in reverse (xs) do r : append (x,r),
  r)$

nDivisoresPares (n) := block(
  [xs : concat (map (rest, ifactors (n))), p : false],
  for x in xs do p: oddp (x) or p,
  p)$

/* concat(xs) es la lista obtenida concatenado los elementos de xss. Por

ejemplo,

concat([[1,3],[2,4],[5,7]]) == [1, 3, 2, 4, 5, 7] */

concat (xs) := block ([r:[]],

for x in reverse (xs) do r : append (x,r),

r)$

nDivisoresPares (n) := block(

[xs : concat (map (rest, ifactors (n))), p : false],

for x in xs do p: oddp (x) or p,

p)$

Tablas de operaciones binarias

Soluciones

Pensamiento

División equitativa

Soluciones

Listas alternadas

Soluciones

Sumas de posiciones pares e impares

Soluciones

Entradas recientes

Buscar

Correo electrónico