Tablas de operaciones binarias

José A. Alonso, 26-diciembre-2018

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

Definir las funciones

   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]]

(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]]

(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]]

(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]]

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)

Pensamiento

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

Antonio Machado

Posted in Medio

Tagged Comprensión, concat, div, even, mod, odd, Orden superior, sum, Test.QuickCheck

6 Comments

frahidzam

26-diciembre-2018 at 09:47

Responder

import Test.QuickCheck
 
tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
tablaOperacion o n = [tablaOperacionAux o n x | x <- [0..(n-1)]]
 
tablaOperacionAux :: (Int -> Int -> Int) -> Int -> Int -> [Int]
tablaOperacionAux o n x = [mod (o x b) n | b <- [0..(n-1)]]
 
tablaSuma :: Int -> [[Int]]
tablaSuma n = tablaOperacion (+) n
 
tablaResta :: Int -> [[Int]]
tablaResta n = tablaOperacion (-) n
 
tablaProducto :: Int -> [[Int]]
tablaProducto n = tablaOperacion (*) n
 
prop_tablaSuma :: Int -> Property
prop_tablaSuma n =
  n > 0 ==> mod (sum (map sum (tablaSuma n))) n == 0
 
prop_tablaResta :: Int -> Property
prop_tablaResta n =
  n > 0 ==> mod (sum (map sum (tablaResta n))) n == 0
 
prop_tablaProducto :: Int -> Property
prop_tablaProducto n
  | even n && odd (div n 2) =
      n > 0 ==> mod (sum (map sum (tablaProducto n))) n == div n 2
  | otherwise =
      n > 0 ==> mod (sum (map sum (tablaProducto n))) n == 0
 
-- Las comprobaciones son:
--    λ> quickCheck prop_tablaSuma
--    +++ OK, passed 100 tests.
--    λ> quickCheck prop_tablaResta
--    +++ OK, passed 100 tests.
--    λ> quickCheck prop_tablaProducto
--    +++ OK, passed 100 tests.

ireprirod

26-diciembre-2018 at 12:20

Responder

import Test.QuickCheck
 
tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
tablaOperacion f x = map opera [0..x-1]
  where opera n = [mod (f n m) x | m <- [0..x-1]]
 
tablaSuma :: Int -> [[Int]]
tablaSuma x = tablaOperacion (+) x
 
tablaResta :: Int -> [[Int]]
tablaResta x = tablaOperacion (-) x
 
tablaProducto :: Int -> [[Int]]
tablaProducto x = tablaOperacion (*) x
 
prop_suma :: Int -> Property
prop_suma n =
  n > 0 ==> mod (sum (map sum (tablaSuma n))) n == 0
 
prop_resta :: Int -> Property
prop_resta n =
  n > 0 ==> mod (sum (map sum (tablaResta n))) n == 0
 
prop_producto :: Int -> Property
prop_producto n
  | even n && odd (div n 2) = n > 0 ==> s == div n 2
  | otherwise               = n > 0 ==> s == 0
  where s = mod (sum (map sum (tablaProducto n))) n

adogargon

26-diciembre-2018 at 14:37

Responder

import Test.QuickCheck
 
tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
tablaOperacion f n = [map (`mod` n) (map (f x) [0..n-1]) | x <- [0..n-1]]
 
tablaSuma :: Int -> [[Int]]
tablaSuma n = tablaOperacion (+) n
 
tablaResta :: Int -> [[Int]]
tablaResta n = tablaOperacion (-) n
 
tablaProducto :: Int -> [[Int]]
tablaProducto n = tablaOperacion (*) n
 
prop_tablaSuma :: Int -> Property
prop_tablaSuma n =
  n > 0 ==> mod (sum (map sum (tablaSuma n))) n == 0
 
prop_tablaResta :: Int -> Property
prop_tablaResta n =
  n > 0 ==> mod (sum (map sum (tablaResta n))) n == 0
 
prop_tablaProducto :: Int -> Property
prop_tablaProducto n
  | even n && odd (div n 2) =
      n > 0 ==> mod (sum (map sum (tablaProducto n))) n == div n 2
  | otherwise =
      n > 0 ==> mod (sum (map sum (tablaProducto n))) n == 0

luipromor

26-diciembre-2018 at 16:20

Responder

import Test.QuickCheck
 
tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
tablaOperacion f n = [[mod (f y x) n  | x <- [0..n-1]  ] | y <- [0..n-1] ]
 
tablaSuma :: Int -> [[Int]]
tablaSuma = tablaOperacion (+)
 
tablaResta :: Int -> [[Int]]
tablaResta = tablaOperacion (-)
 
tablaProducto :: Int -> [[Int]]
tablaProducto  = tablaOperacion (*)
 
prop_tablaSuma :: Int -> Property
prop_tablaSuma n =
  n > 0 ==> mod ((sum . map sum . tablaSuma) n) n == 0
 
prop_tablaResta :: Int -> Property
prop_tablaResta n =
  n > 0 ==> mod ((sum . map sum . tablaResta ) n) n == 0
 
prop_tablaProducto :: Int -> Property
prop_tablaProducto n
  | odd( div  n 2) && mod n 2 == 0 =
    n > 0 ==> mod ((sum . map sum . tablaProducto ) n) n == div n 2
  | otherwise =
    n > 0 ==> mod ((sum . map sum . tablaProducto ) n) n == 0

lucsanand

26-diciembre-2018 at 16:35

Responder

import Test.QuickCheck
 
tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
tablaOperacion f x = [aux (map (f n) xs) | n <- xs]
 where aux n = map (`mod` x) n
       xs = [0..x-1]
 
tablaSuma :: Int -> [[Int]]
tablaSuma x = tablaOperacion (+) x
 
tablaResta :: Int -> [[Int]]
tablaResta x = tablaOperacion (-) x
 
tablaProducto :: Int -> [[Int]]
tablaProducto x = tablaOperacion (*) x
 
prop_tSuma :: Int -> Property
prop_tSuma n =
  n > 0 ==> mod (sum (map sum (tablaSuma n))) n == 0
 
prop_tResta :: Int -> Property
prop_tResta n =
  n > 0 ==> mod (sum (map sum (tablaResta n))) n == 0
 
prop_tProducto :: Int -> Property
prop_tProducto n
  | even n && odd x =
    n > 0 ==>  mod (sum (map sum (tablaProducto n))) n == x
  | otherwise =
    n > 0 ==> mod (sum (map sum (tablaProducto n))) n == 0
  where x = div n 2

javmarcha1

1-enero-2019 at 21:57

Responder

import Test.QuickCheck
 
tablaOperacion :: (Int -> Int -> Int) -> Int -> [[Int]]
tablaOperacion f n =
  agrupaR1 n [mod (f x y) n | x <- take n [0..], y <- take n [0..]]
 
tablaSuma :: Int -> [[Int]]
tablaSuma n =
  agrupaR1 n [mod (x+y) n | x <- take n [0..], y <- take n [0..]] 
 
tablaResta :: Int -> [[Int]]
tablaResta n =
  agrupaR1 n [mod (x-y) n | x <- take n [0..], y <- take n [0..]]
 
tablaProducto :: Int -> [[Int]]
tablaProducto n =
  agrupaR1 n [mod (x*y) n | x <- take n [0..], y <- take n [0..]]
 
agrupaR1 :: Int -> [a] -> [[a]]
agrupaR1 _ []                 = []
agrupaR1 n xs | n > length xs = []
agrupaR1 n xs                 = take n xs : agrupaR1 n (drop n xs) 
 
prop_tablaSuma :: Int -> Bool
prop_tablaSuma n = prop_tablaSuma1 (abs n) == True
 
prop_tablaSuma1 :: Int -> Bool
prop_tablaSuma1 n
  | n == 0    = sum [] == 0
  | n > 0     = mod (sum (concat (tablaSuma n))) n == 0
  | otherwise = False
 
prop_tablaResta :: Int -> Bool
prop_tablaResta n = prop_tablaResta1 (abs n) == True
 
prop_tablaResta1 :: Int -> Bool
prop_tablaResta1 n
  | n == 0    = sum [] == 0
  | n > 0     = mod (sum (concat (tablaResta n))) n == 0
  | otherwise = False
 
prop_tablaProducto :: Int -> Bool
prop_tablaProducto n = prop_tablaProducto1 (abs n) == True
 
prop_tablaProducto1 :: Int -> Bool
prop_tablaProducto1 n
  | n == 0 = sum [] == 0
  | even n && odd (div n 2) && n > 0 =
    mod (sum (concat (tablaProducto n))) n == div n 2
  | otherwise = mod (sum (concat (tablaProducto n))) n == 0
 
--   λ> quickCheck prop_tablaSuma
--   +++ OK, passed 100 tests.
--   λ> quickCheck prop_tablaResta
--   +++ OK, passed 100 tests.
--   λ> quickCheck prop_tablaProducto
--   +++ OK, passed 100 tests.

Escribe tu soluciónCancel reply

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

Tablas de operaciones binarias

Soluciones

Pensamiento

6 Comments

Escribe tu soluciónCancel reply

Subscribe to Blog via Email

Entradas recientes

Etiquetas

Tablas de operaciones binarias

Soluciones

Pensamiento

Se puede imprimir o compartir con

6 Comments

Escribe tu soluciónCancel reply

Subscribe to Blog via Email

Entradas recientes

Etiquetas