Mayor producto de n números adyacentes en una matriz

3 Comentarios

1. Haskell

   type Matriz a = Array (Int,Int) a mayorProductoAdyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes n p = takeWhile ((==x).product) xs where xs = reverse $ sortBy (compare `on` product) (adyacentes n p) x = product (head xs) --Si solo nos interesa uno de los máximos: mayorProductoAdyacentes' :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes' n p = [maximumBy (compare `on` product) (adyacentes n p)] --Aquí hay varias funciones auxiliares, muchas vistas en ejercicios anteriores. adyacentes :: Int -> Matriz a -> [[a]] adyacentes n p = concatMap (segmentos n) (diagonales1 n p ++ diagonales2 n p++ filas p ++ columnas p) diagonales1 :: Int -> Matriz a -> [[a]] diagonales1 n p = filter (xs -> length xs >=n) (diagonalesPrincipales p) diagonales2 :: Int -> Matriz a -> [[a]] diagonales2 n p = filter (xs -> length xs >=n) (diagonalesSecundarias p) filas :: Array (Int, Int) a -> [[a]] filas p = [[p!(i,j)|j<-[1..n]]|i<-[1..m]] where (_,(m,n)) = bounds p columnas :: Array (Int, Int) a -> [[a]] columnas = transpose.filas diagonalesPrincipales :: Matriz a -> [[a]] diagonalesPrincipales p = [[p!ij1 | ij1 <- extension ij] | ij <- iniciales] where (_,(m,n)) = bounds p iniciales = [(i,1) | i <- [m,m-1..2]] ++ [(1,j) | j <- [1..n]] extension (i,j) = [(i+k,j+k) | k <- [0..min (m-i) (n-j)]] diagonalesSecundarias :: Matriz a -> [[a]] diagonalesSecundarias p = [[p!ij1 | ij1 <- extension ij] | ij <- iniciales] where (_,(m,n)) = bounds p iniciales = [(1,j) | j <- [1..n]] ++ [(i,n) | i <- [2..m]] extension (i,j) = [(i+k,j-k) | k <- [0..min (j-1) (m-i)]] segmentos :: Int -> [a] -> [[a]] segmentos n xs | length xs < n = [] | otherwise = take n xs : segmentos n (tail xs)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

   type Matriz a = Array (Int,Int) a   mayorProductoAdyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes n p = takeWhile ((==x).product) xs             where xs = reverse $  sortBy (compare `on` product)                              (adyacentes n p)                   x = product (head xs)   --Si solo nos interesa uno de los máximos: mayorProductoAdyacentes' :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes' n p = [maximumBy (compare `on` product)                              (adyacentes n p)]     --Aquí hay varias funciones auxiliares, muchas vistas en ejercicios anteriores. adyacentes :: Int -> Matriz a -> [[a]] adyacentes n p = concatMap (segmentos n) (diagonales1 n p ++           diagonales2 n p++ filas p ++ columnas p)    diagonales1 :: Int -> Matriz a -> [[a]] diagonales1 n p = filter (xs -> length xs >=n) (diagonalesPrincipales p)   diagonales2 :: Int -> Matriz a -> [[a]] diagonales2 n p = filter (xs -> length xs >=n) (diagonalesSecundarias p)   filas :: Array (Int, Int) a -> [[a]] filas p = [[p!(i,j)|j<-[1..n]]|i<-[1..m]]       where (_,(m,n)) = bounds p   columnas :: Array (Int, Int) a -> [[a]] columnas = transpose.filas   diagonalesPrincipales :: Matriz a -> [[a]] diagonalesPrincipales p =     [[p!ij1 | ij1 <- extension ij] | ij <- iniciales]     where (_,(m,n)) = bounds p           iniciales = [(i,1) | i <- [m,m-1..2]] ++ [(1,j) | j <- [1..n]]           extension (i,j) = [(i+k,j+k) | k <- [0..min (m-i) (n-j)]]     diagonalesSecundarias :: Matriz a -> [[a]] diagonalesSecundarias p =     [[p!ij1 | ij1 <- extension ij] | ij <- iniciales]     where (_,(m,n)) = bounds p           iniciales = [(1,j) | j <- [1..n]] ++ [(i,n) | i <- [2..m]]           extension (i,j) = [(i+k,j-k) | k <- [0..min (j-1) (m-i)]]   segmentos :: Int -> [a] -> [[a]] segmentos n xs | length xs < n = []                | otherwise = take n xs : segmentos n (tail xs)

   Responder

2. Haskell

   type Matriz a = Array (Int,Int) a mayorProductoAdyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes n p = map snd $ takeWhile (\(a,_) -> a == fst (head ys)) ys where ys = reverse $ sort $ map (\xs -> (product xs, xs)) segmentos segmentos = concatMap (segmentosN n) $ concatMap (filter (\xs -> length xs >= n)) [filas p, columnas p, diagPrinc p, diagSec p] segmentosN :: Int -> [a] -> [[a]] segmentosN n xs = [take n (drop k xs) | k <- [0..length xs - n]] filas :: Matriz a -> [[a]] filas p = [take n $ drop (k*n) (elems p) | k <- [0..m-1]] where (_,(m,n)) = bounds p columnas :: Matriz a -> [[a]] columnas p = [map (!! k) (filas p) | k <- [0..n-1]] where (_,(_,n)) = bounds p diagPrinc :: Matriz a -> [[a]] diagPrinc p = [[p!ij1 | ij1 <- extension ij] | ij <- iniciales] where (_,(m,n)) = bounds p iniciales = [(i,1) | i <- [m,m-1..2]] ++ [(1,j) | j <- [1..n]] extension (i,j) = [(i+k,j+k) | k <- [0..min (m-i) (n-j)]] diagSec:: Matriz a -> [[a]] diagSec p = [[p!ij1 | ij1 <- extension ij] | ij <- iniciales] where (_,(m,n)) = bounds p iniciales = [(1,j) | j <- [1..n]] ++ [(i,n) | i <- [2..m]] extension (i,j) = [(i+k,j-k) | k <- [0..min (j-1) (m-i)]]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   type Matriz a = Array (Int,Int) a   mayorProductoAdyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes n p =     map snd $ takeWhile (\(a,_) -> a == fst (head ys)) ys     where ys = reverse $ sort $ map (\xs -> (product xs, xs)) segmentos           segmentos = concatMap (segmentosN n) $                       concatMap (filter (\xs -> length xs >= n))                       [filas p, columnas p, diagPrinc p, diagSec p]   segmentosN :: Int -> [a] -> [[a]] segmentosN n xs = [take n (drop k xs) | k <- [0..length xs - n]]   filas :: Matriz a -> [[a]] filas p = [take n $ drop (k*n) (elems p) | k <- [0..m-1]]     where (_,(m,n)) = bounds p   columnas :: Matriz a -> [[a]] columnas p = [map (!! k) (filas p) | k <- [0..n-1]]     where (_,(_,n)) = bounds p   diagPrinc :: Matriz a -> [[a]] diagPrinc p = [[p!ij1 | ij1 <- extension ij] | ij <- iniciales]     where (_,(m,n)) = bounds p           iniciales = [(i,1) | i <- [m,m-1..2]] ++ [(1,j) | j <- [1..n]]           extension (i,j) = [(i+k,j+k) | k <- [0..min (m-i) (n-j)]]   diagSec:: Matriz a -> [[a]] diagSec p = [[p!ij1 | ij1 <- extension ij] | ij <- iniciales]     where (_,(m,n)) = bounds p           iniciales = [(1,j) | j <- [1..n]] ++ [(i,n) | i <- [2..m]]           extension (i,j) = [(i+k,j-k) | k <- [0..min (j-1) (m-i)]]

   Responder

3. Haskell

   import Data.Array type Matriz a = Array (Int, Int) a mayorProductoAdyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes n p = snd . foldr aux (0,[]) $ adyacentes n p where aux xs (maxProd,xss) | null xss = (r, [xs]) | r > maxProd = (r, [xs]) | r == maxProd = (maxProd, xs:xss) | otherwise = (maxProd, xss) where r = product xs -- Lista de 'n' elementos adyacentes en horizontal, vertical y en diagonales adyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] adyacentes n p = concat [ f (i,j) | i <- [1..a], j <- [1..b] ] where ((_,_),(a,b)) = bounds p f (i,j) = filter ((n==).length) [ take n [p!(i,k) | k <- [j..b]], take n [p!(k,j) | k <- [i..a]], take n [p!(k,l) | (k,l) <- zip [i..a] [j..b]], take n [p!(k,l) | (k,l) <- zip [i..a] [j,j-1..1]] ]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   import Data.Array   type Matriz a = Array (Int, Int) a   mayorProductoAdyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] mayorProductoAdyacentes n p = snd . foldr aux (0,[]) $ adyacentes n p     where         aux xs (maxProd,xss)             | null xss        = (r, [xs])             | r > maxProd     = (r, [xs])             | r == maxProd    = (maxProd, xs:xss)             | otherwise       = (maxProd, xss)             where r = product xs     -- Lista de 'n' elementos adyacentes en horizontal, vertical y en diagonales adyacentes :: (Num a, Ord a) => Int -> Matriz a -> [[a]] adyacentes n p = concat [ f (i,j) | i <- [1..a], j <- [1..b] ]     where         ((_,_),(a,b)) = bounds p         f (i,j) = filter ((n==).length) [                             take n [p!(i,k) | k <- [j..b]],                             take n [p!(k,j) | k <- [i..a]],                             take n [p!(k,l) | (k,l) <- zip [i..a] [j..b]],                             take n [p!(k,l) | (k,l) <- zip [i..a] [j,j-1..1]]                         ]

   Responder