Menu Close

Celdas interiores de una retícula

José A. Alonso,

Las celdas de una retícula cuadrada se numeran consecutivamente. Por ejemplo, la numeración de la retícula cuadrada de lado 4 es

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

Los números de sus celdas interiores son 6,7,10,11.

Definir la función

   interiores :: Int -> [Int]

tal que (interiores n) es la lista de los números de las celdas interiores de la retícula cuadrada de lado n. Por ejemplo,

   interiores 4  == [6,7,10,11]
   interiores 5  == [7,8,9,12,13,14,17,18,19]
   interiores 6  == [8,9,10,11,14,15,16,17,20,21,22,23,26,27,28,29]
   interiores 2  == []
   length (interiores 2018)  == 4064256

Comprobar con QuickCheck que el número de celdas interiores de la retícula cuadrada de lado n, con n > 1, es (n-2)^2.

Soluciones

import Test.QuickCheck
import Data.List.Split (divvy)
 
-- 1ª solución
interiores :: Int -> [Int]
interiores n = [i | i <- [n..n*n-n], i `mod` n > 1]
 
-- 2ª solución
interiores2 :: Int -> [Int]
interiores2 n = aux [n+1..n^2-n]
  where aux xss@(x:xs) = take (n-2) xs ++ aux (drop n xss)
        aux []         = []
 
-- 3ª solución 
interiores3 :: Int -> [Int]
interiores3 n = concat (divvy (n-2) n [n+2..n*(n-1)-1])
 
-- 4ª solución
interiores4 :: Int -> [Int]
interiores4 n = concat [map (+(n*k)) [2..n-1] | k <- [1..n-2]]
 
-- 5ª solución
interiores5 :: Int -> [Int]
interiores5 n = concat (take (n-2) (iterate (map (+n)) [n+2..2*n-1]))
 
-- La propiedad es
prop_interiores :: Int -> Property
prop_interiores n =
  n > 1 ==> length (interiores n) == (n-2)^2
 
-- La comprobación es
--    λ> quickCheck prop_interiores
--    +++ OK, passed 100 tests.
Inicial
, , , , , , , , , ,

10 soluciones de “Celdas interiores de una retícula”

  1. Responder
    alerodrod5 
    import Test.QuickCheck
 
interiores :: Int -> [Int]
interiores = concat . map medio . init. tail . matriz 
  where medio = tail . init 
 
matriz :: Int -> [[Int]]
matriz n = agrupa n [1..n^2]
 
agrupa :: Int -> [a] -> [[a]]
agrupa n = takeWhile (not . null)
         . map (take n)
         . iterate (drop n)
 
propiedad :: Int -> Property
propiedad x = x > 1 ==> length (interiores x) == (x-2)^2 
 
-- > quickCheck propiedad
-- +++ OK, passed 100 tests.
  2. Responder
    antnavoro 
    interiores :: Int -> [Int]
interiores n = filter (x -> mod x n /= 0 && mod x n /= 1) [n+2..n^2-n-1]
    • Responder
      antgongar

      Se puede simplificar como sigue

      interiores :: Int -> [Int]
interiores n = filter (x -> mod x n > 1) [n..n^2-n]
  3. Responder
    anaagumun1 
    interiores :: Int -> [Int]
interiores n = aux $ drop n $ take (n^2-n) [1..n^2]
  where aux xs = concat
               $ map tail
               $ map init
               $ map (take n)
               $ takeWhile (not . null)
               $ map fst [splitAt x (drop y xs)
                         | (x,y) <- zip [n,2*n..n^2-n] [0,n..n^2-n]]
 
interiores2 :: Int -> [Int]
interiores2 n = aux [n+1..n^2-n]
  where aux xss@(x:xs) = take (n-2) xs ++ aux (drop n xss)
        aux []         = []
  4. Responder
    angruicam1 
    import Test.QuickCheck
import Data.List.Split (divvy)
 
interiores :: Int -> [Int]
interiores n = concat (divvy (n-2) n [n+2..n*(n-1)-1])
 
-- Propiedad
-- =========
 
-- La propiedad es
prop_interiores :: Int -> Property
prop_interiores n =
  n > 1 ==> length (interiores n) == (n-2)^2
 
-- La comprobación es
--    λ> quickCheck prop_interiores
--    +++ OK, passed 100 tests.
  5. Responder
    jaibengue 
    import Test.QuickCheck
 
interiores :: Int -> [Int]
interiores n = concat [map (+(n*k)) [2..n-1] | k <- [1..n-2]]
 
prop_CeldasInteriores :: Int -> Property
prop_CeldasInteriores n = n > 1 ==> length (interiores n) == (n-2)^2
  6. Responder
    pabhueacu 
    interiores :: Int -> [Int]
interiores n = concat $ take (n-2) (iterate (map (+n)) [n+2..2*n-1])
  7. Responder
    Chema Cortés 
    interiores :: Int -> [Int]
interiores n = concat [[k..k+n-3] | k <- [n+2,2*n+2..n^2-2*n+2]]
 
interiores2 :: Int -> [Int]
interiores2 n = concat [[k..k+n-3] | k <- take (n-2) (iterate (n+) (n+2))]
 
interiores3 :: Int -> [Int]
interiores3 n = concat [take (n-2) [k..] | k <- take (n-2) (iterate (n+) (n+2))]
  8. Responder
    carbremor 
    -- Celdas interiores de una retícula
 
-- Resolvemos el problema mediante "fuerza bruta"
 
interiores :: Int -> [Int]
interiores n = [x | x <- [n+1..n*(n-1)], rem x n /= 0, rem (x-1) n /= 0]
 
-- λ>  length (interiores 2018)
-- 4064256
-- (5.19 secs, 1,952,161,968 bytes)
 
-- λ> interiores 7
-- [9,10,11,12,13,16,17,18,19,20,23,24,25,26,27,30,31,32,33,34,37,38,39,40,41]
-- (0.01 secs, 152,640 bytes)
 
-- Propiedad
prop_interiores :: Int -> Property
prop_interiores n =
  n > 1 ==> length (interiores n) == (n-2)^2
 
-- Comprobación
-- λ> quickCheck prop_interiores
-- +++ OK, passed 100 tests.
-- (0.19 secs, 53,050,784 bytes)
  9. Responder
    rocruimon 
    import Data.Array
 
interiores :: Int -> [Int]
interiores n = (elems . interioresMatriz . matriz) (n,n)
 
matriz :: (Int,Int) -> Array (Int,Int) Int
matriz (n,m) = listArray ((1,1),(n,m)) [1..]
 
interioresMatriz :: Array (Int,Int) Int -> Array (Int,Int) Int  
interioresMatriz p =
  listArray ((1,1), (n-2,n-2)) [p!(i,j) | i <- [2..n-1] , j <- [2..n-1]]
  where n = (snd . snd . bounds) p

Escribe tu solución

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