Rotación de una matriz

8 Comentarios

1. Haskell

   import Data.Matrix import Data.Vector as V (toList) rota1 :: Matrix Int -> Matrix Int rota1 p = fromLists [[ p!(i,j) | i <- reverse [1..a]] | j <- [1..b]] where a = nrows p b = ncols p rota2 :: Matrix Int -> Matrix Int rota2 p = fromLists . map reverse $ toCols p where toCols m = [V.toList (getCol n m) | n <- [1..ncols p]]

   1 2 3 4 5 6 7 8 9 10 11

   import Data.Matrix import Data.Vector as V (toList)   rota1 :: Matrix Int -> Matrix Int rota1 p = fromLists [[ p!(i,j) | i <- reverse [1..a]] | j <- [1..b]]     where a = nrows p           b = ncols p   rota2 :: Matrix Int -> Matrix Int rota2 p = fromLists . map reverse $ toCols p     where toCols m = [V.toList (getCol n m) | n <- [1..ncols p]]

   Responder

2. Haskell

   import Data.List as P import Data.Matrix as M import Data.Vector as V rota p = M.fromList m n (rota' p) where m = nrows p n = ncols p rota' p = P.concat [P.reverse (V.toList (getCol x p)) | x <- [1..ncols p]]

   1 2 3 4 5 6 7 8 9 10

   import Data.List as P import Data.Matrix as M import Data.Vector as V     rota p = M.fromList m n (rota' p)          where m = nrows p                n = ncols p   rota' p = P.concat [P.reverse (V.toList (getCol x p)) | x <- [1..ncols p]]

   Responder

3. Haskell

   import Data.List as P import Data.Matrix as M import Data.Vector as V rota :: Matrix Int -> Matrix Int rota p = M.fromList m n (rota' p) where m = nrows p n = ncols p rota' :: Matrix a -> [a] rota' p = P.concat [P.reverse (V.toList (getCol x p)) | x <- [1..ncols p]]

   1 2 3 4 5 6 7 8 9 10 11

   import Data.List as P import Data.Matrix as M import Data.Vector as V   rota :: Matrix Int -> Matrix Int rota p = M.fromList m n (rota' p)          where m = nrows p                n = ncols p   rota' :: Matrix a -> [a] rota' p = P.concat [P.reverse (V.toList (getCol x p)) | x <- [1..ncols p]]

   Responder

4. Haskell

   import Data.Matrix -- En colaboración con abrdelrod y pequeños ajustes finales rota :: Matrix Int -> Matrix Int rota p = fromList m n [ p!(m-j+1,i) | i <- [1..m], j <- [1..n]] where (m,n) = (nrows p,ncols p)

   1 2 3 4 5 6 7

   import Data.Matrix   -- En colaboración con abrdelrod y pequeños ajustes finales   rota :: Matrix Int -> Matrix Int rota p = fromList m n [ p!(m-j+1,i) | i <- [1..m], j <- [1..n]]          where (m,n) = (nrows p,ncols p)

   Responder

5. Haskell

   import Data.Matrix rota :: Matrix Int -> Matrix Int rota p = fromLists $ map reverse $ toLists $ transpose p

   1 2 3 4

   import Data.Matrix   rota :: Matrix Int -> Matrix Int rota p = fromLists $ map reverse $ toLists $ transpose p

   Responder

6. Version en Maxima hecha con la traducción a listas y la conversión a matriz

   Haskell

   rota (M) := block( [xs : rotando(matriz2Listas(M))], P : matrix(first(xs)), xs : rest(xs), for x in xs do ( P : addrow(P,x)), P)$ rotando (xss) := block( [xs : []], n : length (first (xss)), for j from 1 thru n do ( xs : cons(map(first,xss),xs), xss : map(rest,xss)), xs)$ matriz2Listas (M) := block( [xs : list_matrix_entries(M), ys : []], l : length(xs), n : sqrt(l), unless emptyp(xs) do ( ys : cons(take_n_xs(n,xs),ys), xs : rest(xs,n)), ys)$ take_n_xs (n,xs) := block( [ys : []], for j from 1 thru n do ( ys : cons(first(xs),ys), xs : rest(xs)), ys)$

   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

   rota (M) := block(   [xs : rotando(matriz2Listas(M))],   P : matrix(first(xs)),   xs : rest(xs),   for x in xs do (     P : addrow(P,x)),   P)$   rotando (xss) := block(   [xs : []],   n : length (first (xss)),   for j from 1 thru n do (     xs : cons(map(first,xss),xs),     xss : map(rest,xss)),   xs)$   matriz2Listas (M) := block(   [xs : list_matrix_entries(M),    ys : []],   l : length(xs),   n : sqrt(l),   unless emptyp(xs) do (     ys : cons(take_n_xs(n,xs),ys),     xs : rest(xs,n)),   ys)$   take_n_xs (n,xs) := block(   [ys : []],   for j from 1 thru n do (     ys : cons(first(xs),ys),     xs : rest(xs)),   ys)$

   Responder

   1. La comprobación sería

      Haskell

      /* (%i13) Q : matrix([1,2,3],[4,5,6],[7,8,9]); [ 1 2 3 ] [ ] (%o13) [ 4 5 6 ] [ ] [ 7 8 9 ] (%i14) rota(Q); [ 7 4 1 ] [ ] (%o14) [ 8 5 2 ] [ ] [ 9 6 3 ] (%i15) rota(%); [ 9 8 7 ] [ ] (%o15) [ 6 5 4 ] [ ] [ 3 2 1 ] */

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

      /*  (%i13) Q : matrix([1,2,3],[4,5,6],[7,8,9]);                                   [ 1  2  3 ]                                   [         ] (%o13)                            [ 4  5  6 ]                                   [         ]                                   [ 7  8  9 ] (%i14) rota(Q);                                   [ 7  4  1 ]                                   [         ] (%o14)                            [ 8  5  2 ]                                   [         ]                                   [ 9  6  3 ] (%i15) rota(%);                                   [ 9  8  7 ]                                   [         ] (%o15)                            [ 6  5  4 ]                                   [         ]                                   [ 3  2  1 ] */

      Responder

7. Definición alternativa a la de fracruzam en Maxima:

   Haskell

   nFilas (p) := first (matrix_size (p))$ nCols (p) := second (matrix_size (p))$ rotaA2 (p) := genmatrix (lambda ([i,j], part (p, nFilas (p)-j+1, i)), nCols (p), nFilas(p))$

   1 2 3 4 5 6 7

   nFilas (p) := first  (matrix_size (p))$ nCols (p)  := second (matrix_size (p))$   rotaA2 (p) :=   genmatrix (lambda ([i,j], part (p, nFilas (p)-j+1, i)),              nCols (p),              nFilas(p))$

   Responder