Menu Close

Representación reducida de matrices dispersas

Una representación reducida de una matriz dispersa es una lista de listas donde cada una de las listas representa una fila de la matriz mediante listas de pares correspondientes a las snúmeros de columnas con valores no nulos de la matriz. Por ejemplo, la representacioń reducida de la matriz

   ( 0 0 4 )
   ( 0 5 0 )
   ( 0 0 0 )

es [[(3,4)],[(2,5)],[]].

Definir la función

   reducida :: (Num a, Eq a) => Matrix a -> [[(Int,a)]]

tal que (reducida p) es la representación reducida de la matriz p. Por ejemplo,

   reducida (fromList 3 3 [0,0,4,0,5,0,0,0,0])  ==  [[(3,4)],[(2,5)],[]]
   reducida (identity 3)  ==  [[(1,1)],[(2,1)],[(3,1)]]
   reducida (zero 9 3)    ==  [[],[],[],[],[],[],[],[],[]]
   reducida (zero 9 4)    ==  [[],[],[],[],[],[],[],[],[]]

Soluciones

import Data.Matrix (Matrix, (!), nrows, ncols)
 
reducida :: (Num a, Eq a) => Matrix a -> [[(Int,a)]]
reducida p =
  [[(j,x) | j <- [1..n], let x = p!(i,j), x /= 0] | i <- [1..m]] 
  where m = nrows p
        n = ncols p
Inicial

5 soluciones de “Representación reducida de matrices dispersas

  1. angruicam1
    import Data.Matrix (Matrix, fromList, identity, zero, (!), nrows, ncols)
     
    reducida :: (Num a, Eq a) => Matrix a -> [[(Int,a)]]
    reducida p =
      [[(j,p!(i,j)) | j <- [1..ncols p], p!(i,j) /= 0] | i <- [1..nrows p]]
  2. alerodrod5
     
    import Data.Matrix
     
    reducida :: (Num a, Eq a) => Matrix a -> [[(Int,a)]]
    reducida p =  map (borra0.zip [1..ncols p]) (toLists p)
     
    borra0 ::(Num a, Eq a) => [(Int,a)] -> [(Int,a)]
    borra0 [] = []
    borra0 ((x,y):xs) | y == 0 = borra0 xs
                      | otherwise = (x,y) : borra0 xs
    • menvealer
      He llegado a una solución muy parecida, pero la he definido por comprensión. 
       
      import qualified Data.Vector as V (toList)
      import Data.Matrix (Matrix, getRow, nrows, ncols)
       
      reducida :: (Num a, Eq a) => Matrix a -> [[(Int,a)]]
      reducida p = [borraCero (zip [1..ncols p] (V.toList (getRow i p))) | i <- [1..nrows p]]
       
      borraCero :: (Num a, Eq a) => [(Int,a)] -> [(Int,a)]
      borraCero [] = []
      borraCero ((a,b):ps) | b == 0 = borraCero ps
                           | otherwise = (a,b) : borraCero ps
  3. carbremor
    import Data.Matrix
    reducida :: (Num a, Eq a) => Matrix a -> [[(Int,a)]]
    reducida m = [[(j,a) | j<-[1..ncols m], let a = m ! (i,j), a /= 0] | i<-[1..nrows m]]
  4. Chema Cortés
    import           Data.Matrix
     
     
    reducida :: (Num a, Eq a) => Matrix a -> [[(Int,a)]]
    reducida = map aux . toLists
      where
        aux xs = [(i,x) | (i,x) <- zip [1..] xs, x /= 0]

Escribe tu solución

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