Menu Close

Representación reducida de matrices dispersas

José A. Alonso,

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. Responder
    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. Responder
    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
    • Responder
      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. Responder
    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. Responder
    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.