Menu Close

Diagonales invertidas

Definir la función

   diagonalesInvertidas :: Matrix a -> Matrix a

tal que (diagonalesInvertidas q) es la matriz obtenida invirtiendo el
orden de los elementos de la diagonal principal y de la diagonal
secundaria de q. Por ejemplo,

   λ> fromList 5 5 [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 │
   └                ┘
   λ> diagonalesInvertidas (fromList 5 5 [1..])
   ┌                ┐
   │ 25  2  3  4 21 │
   │  6 19  8 17 10 │
   │ 11 12 13 14 15 │
   │ 16  9 18  7 20 │
   │  5 22 23 24  1 │
   └                ┘
   λ> fromList 3 3 ['a','b'..]
   ┌             ┐
   │ 'a' 'b' 'c' │
   │ 'd' 'e' 'f' │
   │ 'g' 'h' 'i' │
   └             ┘
   λ> diagonalesInvertidas (fromList 3 3 ['a','b'..])
   ┌             ┐
   │ 'i' 'b' 'g' │
   │ 'd' 'e' 'f' │
   │ 'c' 'h' 'a' │
   └             ┘

Soluciones

import Data.Matrix
 
diagonalesInvertidas :: Matrix a -> Matrix a
diagonalesInvertidas q = matrix n n f
  where n = nrows q
        f (i,j) | i == j     = q ! (n + 1 - i, n + 1 - i)
                | i+j == n+1 = q ! (j,i)
                | otherwise  = q ! (i,j)

Pensamiento

Despertad, cantores:
acaben los ecos,
empiecen las voces.

Antonio Machado

3 soluciones de “Diagonales invertidas

  1. frahidzam
    import Data.Matrix
     
    diagonalesInvertidas :: Matrix a -> Matrix a
    diagonalesInvertidas m = matrix a b f
      where (a,b) = (nrows m, ncols m)
            f (i,j) | i == j = m ! (a-i+1,b-j+1)
                    | i + j == a + 1 = m ! (j, i)
                    | otherwise = m ! (i,j)
  2. luipromor
    diagonalesInvertidas :: Matrix a -> Matrix a
    diagonalesInvertidas v = matrix m n f
      where (m,n) = (nrows v,ncols v)
            f (i,j) | i == j = v ! (x,x)
                    | x == j = v ! (j,i)
                    | otherwise = v ! (i,j)
                      where x | odd n  = simetrico ( div n 2 +1) i
                              | even n && i <= div n 2 = simetrico ( div n 2 +1 ) i -1 
                              | even n && i > div n 2 = simetrico ( div n 2 +1 ) (i+1)
     
    simetrico n i | n > i = 2*n -i
                  | otherwise = abs (i -2 *n)
  3. javmarcha1
     
    import Prelude as P
    import Data.Matrix as M
    import Data.Vector as V
    import Data.List as L
     
    diagonalesInvertidas :: Ord a => Matrix a -> Matrix a
    diagonalesInvertidas p = M.fromList (nrows p) (ncols p)
                             (L.map (snd) (elementos p))
     
    diagonal1 :: Matrix a -> [a]
    diagonal1 p = V.toList (getDiag p)
     
    diagonal2 :: Matrix a -> [a]
    diagonal2 p = V.toList(getDiag (cambiar (ncols p) 1 p))
     
    cambiar :: Int -> Int -> Matrix a -> Matrix a
    cambiar i n p | i==n = p
                  | otherwise = switchCols i n (cambiar (i-1) (n+1) p) 
     
    pardiagonal :: Matrix a -> [(a,a)]
    pardiagonal p = [(a,b) | (a,b) <- P.zip (diagonal1 p P.++ diagonal2 p)
                     (P.reverse(diagonal1 p) P.++ P.reverse(diagonal2 p))]
     
    noendiagonal :: Eq a =>  Matrix a -> [(a,a)]
    noendiagonal p = [(x,x) | x <- M.toList p, L.elem x (diagonal1 p P.++ diagonal2 p) == False]
     
    elementos :: Ord a =>  Matrix a -> [(a,a)]
    elementos p = L.sort(nub(pardiagonal p P.++ noendiagonal p))

Escribe tu solución

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