Aplicaciones biyectivas

6 Comentarios

1. Haskell

   import Data.List (permutations,genericLength) biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys | length xs /= length ys = [] | otherwise = map (zip xs) $ permutations ys nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys | lx /= genericLength ys = 0 | otherwise = product [1..lx] where lx = genericLength xs

   1 2 3 4 5 6 7 8 9 10 11 12

   import Data.List (permutations,genericLength)   biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys   | length xs /= length ys = []   | otherwise              = map (zip xs) $ permutations ys   nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys   | lx /= genericLength ys = 0   | otherwise              = product [1..lx]     where lx = genericLength xs

   Responder

   1. Llego prácticamente a la misma solución pero definiendo factorial como una función aparte

      Haskell

      import Data.List (genericLength, permutations) biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys | length xs == length ys = map (zip xs) (permutations ys) | otherwise = [] nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys | x == genericLength ys = factorial x | otherwise = 0 where x = genericLength xs factorial :: Integer -> Integer factorial x = product [1..x]

      1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

      import Data.List (genericLength, permutations)   biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys   | length xs == length ys = map (zip xs) (permutations ys)   | otherwise              = []   nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys   | x ==  genericLength ys = factorial x   | otherwise              = 0   where x = genericLength xs   factorial :: Integer -> Integer factorial x = product [1..x]

      Responder

2. Haskell

   import Data.List biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys | length xs == length ys = inyecciones xs ys | otherwise = [[]] inyecciones :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] inyecciones [] _ = [[]] inyecciones (x:xs) ys = concat [map ((x,y):) (inyecciones xs (delete y ys)) | y <- ys] nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys | x' == length ys = toInteger $ product [1..x'] | otherwise = 0 where x' =length xs

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   import Data.List   biyectivas  :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys | length xs == length ys = inyecciones xs ys                   | otherwise = [[]]                    inyecciones :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] inyecciones [] _ = [[]] inyecciones (x:xs) ys = concat [map ((x,y):) (inyecciones xs (delete y ys)) | y <- ys]   nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys | x' == length ys = toInteger $ product [1..x']                   | otherwise = 0                           where x' =length xs

   Responder

   1. Falla en el tercer ejemplo.

      Responder

3. Usando la función permutations de Data.List es mucho más sencillo. Llego a la misma definición que angruicam1 y alerodrod5.

   Haskell

   biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys | length xs == length ys = map (zip xs) (permutations ys) | otherwise = []

   1 2 3 4

   biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas xs ys   | length xs == length ys = map (zip xs) (permutations ys)   | otherwise              = []

   Responder

4. Haskell

   import Data.List biyectivas :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas [] ys = [] biyectivas xs [] = [] biyectivas xs ys | length xs /= length ys = [] | otherwise = map (zip xs) (permutations ys) nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys = genericLength (biyectivas xs ys)

   1 2 3 4 5 6 7 8 9 10 11 12

   import Data.List   biyectivas  :: (Ord a, Ord b) => [a] -> [b] -> [[(a,b)]] biyectivas [] ys = [] biyectivas xs [] = [] biyectivas xs ys | length xs /= length ys = []                  | otherwise = map (zip xs) (permutations ys)       nBiyectivas :: (Ord a, Ord b) => [a] -> [b] -> Integer nBiyectivas xs ys = genericLength (biyectivas xs ys)

   Responder