Matrices latinas

PorJosé A. Alonso 29-mayo-201513-junio-2015

Una matriz latina de orden n es una matriz cuadrada de orden n tal que todos sus elementos son cero salvo los de su fila y columna central, si n es impar; o los de sus dos filas y columnas centrales, si n es par.

Definir la función

   latina :: Int -> Array (Int,Int) Int

1	latina :: Int -> Array (Int,Int) Int

tal que (latina n) es la siguiente matriz latina de orden n:

Para n impar:

     | 0  0... 0 1   0 ... 0   0|
     | 0  0... 0 2   0 ... 0   0|
     | 0  0... 0 3   0 ... 0   0|
     | .........................|
     | 1  2..............n-1   n|
     | .........................|
     | 0  0... 0 n-2 0 ... 0   0|
     | 0  0... 0 n-1 0 ... 0   0|
     | 0  0... 0 n   0 ... 0   0|

| 0 0... 0 1 0 ... 0 0|

| 0 0... 0 2 0 ... 0 0|

| 0 0... 0 3 0 ... 0 0|

| .........................|

| 1 2..............n-1 n|

| .........................|

| 0 0... 0 n-2 0 ... 0 0|

| 0 0... 0 n-1 0 ... 0 0|

| 0 0... 0 n 0 ... 0 0|

Para n par:

     | 0  0... 0 1   n    0 ...   0   0|
     | 0  0... 0 2   n-1  0 ...   0   0|
     | 0  0... 0 3   n-2  0 ...   0   0|
     | ................................|
     | 1  2.....................n-1   n|
     | n n-1 .................... 2   1|
     | ................................|
     | 0  0... 0 n-2  3   0 ...   0   0|
     | 0  0... 0 n-1  2   0 ...   0   0|
     | 0  0... 0 n    1   0 ...   0   0|

| 0 0... 0 1 n 0 ... 0 0|

| 0 0... 0 2 n-1 0 ... 0 0|

| 0 0... 0 3 n-2 0 ... 0 0|

| ................................|

| 1 2.....................n-1 n|

| n n-1 .................... 2 1|

| ................................|

| 0 0... 0 n-2 3 0 ... 0 0|

| 0 0... 0 n-1 2 0 ... 0 0|

| 0 0... 0 n 1 0 ... 0 0|

Por ejemplo,

   ghci> elems (latina 5)
   [0,0,1,0,0,
    0,0,2,0,0,
    1,2,3,4,5,
    0,0,4,0,0,
    0,0,5,0,0]
   ghci> elems (latina 6)
   [0,0,1,6,0,0,
    0,0,2,5,0,0,
    1,2,3,4,5,6,
    6,5,4,3,2,1,
    0,0,5,2,0,0,
    0,0,6,1,0,0]

ghci> elems (latina 5)

[0,0,1,0,0,

0,0,2,0,0,

1,2,3,4,5,

0,0,4,0,0,

0,0,5,0,0]

ghci> elems (latina 6)

[0,0,1,6,0,0,

0,0,2,5,0,0,

1,2,3,4,5,6,

6,5,4,3,2,1,

0,0,5,2,0,0,

0,0,6,1,0,0]

Soluciones

latina :: Int -> Array (Int,Int) Int
latina n | even n    = latinaPar n
         | otherwise = latinaImpar n

-- (latinaImpar n) es la matriz latina de orden n, siendo n un número
-- impar. Por ejemplo,
--    ghci> elems (latinaImpar 5)
--    [0,0,1,0,0,
--     0,0,2,0,0,
--     1,2,3,4,5,
--     0,0,4,0,0,
--     0,0,5,0,0]
latinaImpar :: Int -> Array (Int,Int) Int
latinaImpar n = 
    array ((1,1),(n,n)) [((i,j),f i j) | i <- [1..n], j <- [1..n]]
    where c = 1 + (n `div` 2)
          f i j | i == c    = j
                | j == c    = i 
                | otherwise = 0 

-- (latinaPar n) es la matriz latina de orden n, siendo n un número
-- par. Por ejemplo,
--    ghci> elems (latinaPar 6)
--    [0,0,1,6,0,0,
--     0,0,2,5,0,0,
--     1,2,3,4,5,6,
--     6,5,4,3,2,1,
--     0,0,5,2,0,0,
--     0,0,6,1,0,0]
latinaPar :: Int -> Array (Int,Int) Int
latinaPar n = 
    array ((1,1),(n,n)) [((i,j),f i j) | i <- [1..n], j <- [1..n]]
    where c = n `div` 2
          f i j | i == c    = j
                | i == c+1  = n-j+1
                | j == c    = i
                | j == c+1  = n-i+1
                | otherwise = 0

latina :: Int -> Array (Int,Int) Int

latina n | even n = latinaPar n

| otherwise = latinaImpar n

-- (latinaImpar n) es la matriz latina de orden n, siendo n un número

-- impar. Por ejemplo,

-- ghci> elems (latinaImpar 5)

-- [0,0,1,0,0,

-- 0,0,2,0,0,

-- 1,2,3,4,5,

-- 0,0,4,0,0,

-- 0,0,5,0,0]

latinaImpar :: Int -> Array (Int,Int) Int

latinaImpar n =

array ((1,1),(n,n)) [((i,j),f i j) | i <- [1..n], j <- [1..n]]

where c = 1 + (n `div` 2)

f i j | i == c = j

| j == c = i

| otherwise = 0

-- (latinaPar n) es la matriz latina de orden n, siendo n un número

-- par. Por ejemplo,

-- ghci> elems (latinaPar 6)

-- [0,0,1,6,0,0,

-- 0,0,2,5,0,0,

-- 1,2,3,4,5,6,

-- 6,5,4,3,2,1,

-- 0,0,5,2,0,0,

-- 0,0,6,1,0,0]

latinaPar :: Int -> Array (Int,Int) Int

latinaPar n =

array ((1,1),(n,n)) [((i,j),f i j) | i <- [1..n], j <- [1..n]]

where c = n `div` 2

f i j | i == c = j

| i == c+1 = n-j+1

| j == c = i

| j == c+1 = n-i+1

| otherwise = 0

4 Comentarios

import Data.Array

-- definida por función
latina :: Int -> Array (Int,Int) Int
latina n = listArray ((1,1),(n,n)) [ elemento (i,j) | i <- [1..n], j <- [1..n]]
    where
        m = n `div` 2
        elemento | even n    = ePar
                 | otherwise = eImpar
        eImpar (i,j) | i == m+1  = j
                     | j == m+1  = i
                     | otherwise = 0
        ePar (i,j)   | i == m    = j
                     | j == m    = i
                     | i == m+1  = n-j+1
                     | j == m+1  = n-i+1
                     | otherwise = 0

-- por actualización incremental
latina2 :: Int -> Array (Int,Int) Int
latina2 n | even n    = ceros
                     // [ ((i,m),  i)      | i <- [1..n]]
                     // [ ((i,m+1), n-i+1) | i <- [1..n]]
                     // [ ((m,j),  j)      | j <- [1..n]]
                     // [ ((m+1,j), n-j+1) | j <- [1..n]]
          | otherwise = ceros
                     // [ ((i,m+1),i) | i <- [1..n]]
                     // [ ((m+1,j),j) | j <- [1..n]]
    where
        m = n `div` 2
        ceros = listArray ((1,1),(n,n)) (repeat 0)

import Data.Array

-- definida por función

latina :: Int -> Array (Int,Int) Int

latina n = listArray ((1,1),(n,n)) [ elemento (i,j) | i <- [1..n], j <- [1..n]]

where

m = n `div` 2

elemento | even n = ePar

| otherwise = eImpar

eImpar (i,j) | i == m+1 = j

| j == m+1 = i

| otherwise = 0

ePar (i,j) | i == m = j

| j == m = i

| i == m+1 = n-j+1

| j == m+1 = n-i+1

| otherwise = 0

-- por actualización incremental

latina2 :: Int -> Array (Int,Int) Int

latina2 n | even n = ceros

// [ ((i,m), i) | i <- [1..n]]

// [ ((i,m+1), n-i+1) | i <- [1..n]]

// [ ((m,j), j) | j <- [1..n]]

// [ ((m+1,j), n-j+1) | j <- [1..n]]

| otherwise = ceros

// [ ((i,m+1),i) | i <- [1..n]]

// [ ((m+1,j),j) | j <- [1..n]]

where

m = n `div` 2

ceros = listArray ((1,1),(n,n)) (repeat 0)

Responder

import Data.Array

latina :: Int -> Array (Int,Int) Int
latina n = 
    array dim [((i,j), elemento (i,j))  | (i,j) <- range dim]
    where dim = ((1,1),(n,n))
          (men, may) = (ceiling (fromIntegral n / 2), ceiling (fromIntegral (n+1) / 2))
          elemento (i,j)
            | i == men  = j
            | i == may  = n+1-j
            | j == men  = i
            | j == may  = n+1-i
            | otherwise = 0

import Data.Array

latina :: Int -> Array (Int,Int) Int

latina n =

array dim [((i,j), elemento (i,j)) | (i,j) <- range dim]

where dim = ((1,1),(n,n))

(men, may) = (ceiling (fromIntegral n / 2), ceiling (fromIntegral (n+1) / 2))

elemento (i,j)

| i == men = j

| i == may = n+1-j

| j == men = i

| j == may = n+1-i

| otherwise = 0

Responder

Algo más simplificado:

import Data.Array
import Control.Arrow ((&&&))
-- f &&& g = \x -> (f x,g x)

latina :: Int -> Array (Int,Int) Int
latina n = 
    listArray dim (map elemento (range dim))
    where dim = ((1,1),(n,n))
          (men, may) = (floor &&& ceiling) (fromIntegral (n+1) / 2)
          elemento (i,j)
            | i == men  = j
            | i == may  = n+1-j
            | j == men  = i
            | j == may  = n+1-i
            | otherwise = 0

import Data.Array

import Control.Arrow ((&&&))

-- f &&& g = \x -> (f x,g x)

latina :: Int -> Array (Int,Int) Int

latina n =

listArray dim (map elemento (range dim))

where dim = ((1,1),(n,n))

(men, may) = (floor &&& ceiling) (fromIntegral (n+1) / 2)

elemento (i,j)

| i == men = j

| i == may = n+1-j

| j == men = i

| j == may = n+1-i

| otherwise = 0

Responder

import Data.Array

latina :: Int -> Array (Int,Int) Int
latina n = 
    accumArray (\_ y -> y) 0 ((1,1),(n,n)) (if odd n then xs else ys ++ zs)
    where 
      xs = concat [[(((n+1) `div` 2,j),j),((j,(n+1) `div` 2),j)] | j <- [1..n]]
      ys = concat [[((n`div`2,j),j),((j,n`div`2),j)] | j <- [1..n]]
      zs = concat [[((n`div`2+1,j),n-j+1),((j,n`div`2+1),n-j+1)] | j <- [1..n]]

import Data.Array

latina :: Int -> Array (Int,Int) Int

latina n =

accumArray (\_ y -> y) 0 ((1,1),(n,n)) (if odd n then xs else ys ++ zs)

where

xs = concat [[(((n+1) `div` 2,j),j),((j,(n+1) `div` 2),j)] | j <- [1..n]]

ys = concat [[((n`div`2,j),j),((j,n`div`2),j)] | j <- [1..n]]

zs = concat [[((n`div`2+1,j),n-j+1),((j,n`div`2+1),n-j+1)] | j <- [1..n]]

Responder

Matrices latinas

Soluciones

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

4 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico