{"id":7690,"date":"2022-03-19T17:03:52","date_gmt":"2022-03-19T16:03:52","guid":{"rendered":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/?p=7690"},"modified":"2022-03-19T17:24:23","modified_gmt":"2022-03-19T16:24:23","slug":"la-semana-en-exercitium-del-14-al-18-de-marzo","status":"publish","type":"post","link":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/la-semana-en-exercitium-del-14-al-18-de-marzo\/","title":{"rendered":"La semana en Exercitium (del 14 al 18 de marzo)"},"content":{"rendered":"<p>Esta semana he publicado en <a href=\"http:\/\/bit.ly\/2sqPtGs\">Exercitium<\/a> las soluciones de los siguientes problemas:<\/p>\n<ul>\n<li><a href=\"#ej1\">1. Diagonales principales de una matriz.<\/a><\/li>\n<li><a href=\"#ej2\">2. Matrices de Toepliz<\/a><\/li>\n<li><a href=\"#ej3\">3. M\u00e1ximos locales<\/a><\/li>\n<li><a href=\"#ej4\">4. Lista cuadrada<\/a><\/li>\n<li><a href=\"#ej5\">5. Segmentos de elementos consecutivos<\/a><\/li>\n<\/ul>\n<p>A continuaci\u00f3n se muestran las soluciones.<br \/>\n<!--more--><br \/>\n<a name=\"ej1\"><\/a><\/p>\n<h3>1. Diagonales principales de una matriz.<\/h3>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- La lista de las diagonales principales de la matriz\n--    1  2  3  4\n--    5  6  7  8\n--    9 10 11 12\n-- es\n--    [[9],[5,10],[1,6,11],[2,7,12],[3,8],[4]]\n--\n-- Definir la funci\u00f3n\n--    diagonalesPrincipales :: Array (Int,Int) a -> [[a]]\n-- tal que (diagonalesPrincipales p) es la lista de las diagonales\n-- principales de p. Por ejemplo,\n--    \u03bb> diagonalesPrincipales (listArray ((1,1),(3,4)) [1..12])\n--    [[9],[5,10],[1,6,11],[2,7,12],[3,8],[4]]\n-- ---------------------------------------------------------------------\n\nmodule Diagonales_principales where\n\nimport Data.Array (Array, (!), bounds, listArray)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\ndiagonalesPrincipales1 :: Array (Int,Int) a -> [[a]]\ndiagonalesPrincipales1 p =\n  [[p ! ij | ij <- ijs] | ijs <- posicionesDiagonalesPrincipales1 m n]\n  where (_,(m,n)) = bounds p\n\nposicionesDiagonalesPrincipales1 :: Int -> Int -> [[(Int, Int)]]\nposicionesDiagonalesPrincipales1 m n =\n  [extension ij | ij <- iniciales]\n  where iniciales = [(i,1) | i <- [m,m-1..2]] ++ [(1,j) | j <- [1..n]]\n        extension (i,j) = [(i+k,j+k) | k <- [0..min (m-i) (n-j)]]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\ndiagonalesPrincipales2 :: Array (Int,Int) a -> [[a]]\ndiagonalesPrincipales2 p =\n  [[p ! ij | ij <- ijs] | ijs <- posicionesDiagonalesPrincipales2 m n]\n  where (_,(m,n)) = bounds p\n\nposicionesDiagonalesPrincipales2 :: Int -> Int -> [[(Int, Int)]]\nposicionesDiagonalesPrincipales2 m n =\n  [zip [i..m] [1..n] | i <- [m,m-1..1]] ++\n  [zip [1..m] [j..n] | j <- [2..n]]\n\n-- Equivalencia de las definiciones\n-- ================================\n\n-- La propiedad es\nprop_diagonalesPrincipales :: Positive Int -> Positive Int -> Bool\nprop_diagonalesPrincipales (Positive m) (Positive n) =\n  diagonalesPrincipales1 p == diagonalesPrincipales2 p\n  where p = listArray ((1,1),(m,n)) [1..]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_diagonalesPrincipales\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> length (diagonalesPrincipales1 (listArray ((1,1),(10^4,10^4)) [1..]))\n--    19999\n--    (6.90 secs, 8,010,369,224 bytes)\n--    \u03bb> length (diagonalesPrincipales2 (listArray ((1,1),(10^4,10^4)) [1..]))\n--    19999\n--    (6.78 secs, 8,008,289,224 bytes)\n<\/pre>\n<p><a name=\"ej2\"><\/a><\/p>\n<h3>2. Matrices de Toepliz<\/h3>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Una [matriz de Toeplitz](https:\/\/bit.ly\/3pqjY9D) es una matriz\n-- cuadrada que es constante a lo largo de las diagonales paralelas a la\n-- diagonal principal. Por ejemplo,\n--    |2 5 1 6|       |2 5 1 6|\n--    |4 2 5 1|       |4 2 6 1|\n--    |7 4 2 5|       |7 4 2 5|\n--    |9 7 4 2|       |9 7 4 2|\n-- la primera es una matriz de Toeplitz y la segunda no lo es.\n--\n-- Las anteriores matrices se pueden definir por\n--    ej1, ej2 :: Array (Int,Int) Int\n--    ej1 = listArray ((1,1),(4,4)) [2,5,1,6,4,2,5,1,7,4,2,5,9,7,4,2]\n--    ej2 = listArray ((1,1),(4,4)) [2,5,1,6,4,2,6,1,7,4,2,5,9,7,4,2]\n--\n-- Definir la funci\u00f3n\n--    esToeplitz :: Eq a => Array (Int,Int) a -> Bool\n-- tal que (esToeplitz p) se verifica si la matriz p es de Toeplitz. Por\n-- ejemplo,\n--    esToeplitz ej1  ==  True\n--    esToeplitz ej2  ==  False\n-- ---------------------------------------------------------------------\n\nmodule Matriz_Toeplitz where\n\nimport Data.Array (Array, (!), bounds, listArray)\n\nej1, ej2 :: Array (Int,Int) Int\nej1 = listArray ((1,1),(4,4)) [2,5,1,6,4,2,5,1,7,4,2,5,9,7,4,2]\nej2 = listArray ((1,1),(4,4)) [2,5,1,6,4,2,6,1,7,4,2,5,9,7,4,2]\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nesToeplitz1 :: Eq a => Array (Int,Int) a -> Bool\nesToeplitz1 p =\n  esCuadrada p &&\n  all todosIguales (diagonalesPrincipales p)\n\n-- (esCuadrada p) se verifica si la matriz p es cuadrada. Por ejemplo,\n--    esCuadrada (listArray ((1,1),(4,4)) [1..])  ==  True\n--    esCuadrada (listArray ((1,1),(3,4)) [1..])  ==  False\nesCuadrada :: Eq a => Array (Int,Int) a -> Bool\nesCuadrada p = m == n\n  where (_,(m,n)) = bounds p\n\n-- (diagonalesPrincipales p) es la lista de las diagonales principales\n-- de p. Por ejemplo,\n--    \u03bb> diagonalesPrincipales ej1\n--    [[2,2,2,2],[5,5,5],[1,1],[6],[2,2,2,2],[4,4,4],[7,7],[9]]\n--    \u03bb> diagonalesPrincipales ej2\n--    [[2,2,2,2],[5,6,5],[1,1],[6],[2,2,2,2],[4,4,4],[7,7],[9]]\ndiagonalesPrincipales :: Array (Int,Int) a -> [[a]]\ndiagonalesPrincipales p =\n  [[p ! i |i <- is] | is <- posicionesDiagonalesPrincipales m n]\n  where (_,(m,n)) = bounds p\n\n-- (posicionesDiagonalesPrincipales m n) es la lista de las\n-- posiciones de las diagonales principales de una matriz con m filas y\n-- n columnas. Por ejemplo,\n--   \u03bb> mapM_ print (posicionesDiagonalesPrincipales 3 4)\n--   [(3,1)]\n--   [(2,1),(3,2)]\n--   [(1,1),(2,2),(3,3)]\n--   [(1,2),(2,3),(3,4)]\n--   [(1,3),(2,4)]\n--   [(1,4)]\n--   \u03bb> mapM_ print (posicionesDiagonalesPrincipales 4 4)\n--   [(4,1)]\n--   [(3,1),(4,2)]\n--   [(2,1),(3,2),(4,3)]\n--   [(1,1),(2,2),(3,3),(4,4)]\n--   [(1,2),(2,3),(3,4)]\n--   [(1,3),(2,4)]\n--   [(1,4)]\n--   \u03bb> mapM_ print (posicionesDiagonalesPrincipales 4 3)\n--   [(4,1)]\n--   [(3,1),(4,2)]\n--   [(2,1),(3,2),(4,3)]\n--   [(1,1),(2,2),(3,3)]\n--   [(1,2),(2,3)]\n--   [(1,3)]\nposicionesDiagonalesPrincipales :: Int -> Int -> [[(Int, Int)]]\nposicionesDiagonalesPrincipales m n =\n  [zip [i..m] [1..n] | i <- [m,m-1..1]] ++\n  [zip [1..m] [j..n] | j <- [2..n]]\n\n-- (todosIguales xs) se verifica si todos los elementos de xs son\n-- iguales. Por ejemplo,\n--    todosIguales [5,5,5]  ==  True\n--    todosIguales [5,4,5]  ==  False\ntodosIguales :: Eq a => [a] -> Bool\ntodosIguales []     = True\ntodosIguales (x:xs) = all (== x) xs\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nesToeplitz2 :: Eq a => Array (Int,Int) a -> Bool\nesToeplitz2 p = m == n &&\n               and [p!(i,j) == p!(i+1,j+1) |\n                    i <- [1..n-1], j <- [1..n-1]]\n  where (_,(m,n)) = bounds p\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> esToeplitz1 (listArray ((1,1),(2*10^3,2*10^3)) (repeat 1))\n--    True\n--    (2.26 secs, 2,211,553,888 bytes)\n--    \u03bb> esToeplitz2 (listArray ((1,1),(2*10^3,2*10^3)) (repeat 1))\n--    True\n--    (4.26 secs, 3,421,651,032 bytes)\n<\/pre>\n<p><a name=\"ej3\"><\/a><\/p>\n<h3>3. M\u00e1ximos locales<\/h3>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Un m\u00e1ximo local de una lista es un elemento de la lista que es mayor\n-- que su predecesor y que su sucesor en la lista. Por ejemplo, 5 es un\n-- m\u00e1ximo local de [3,2,5,3,7,7,1,6,2] ya que es mayor que 2 (su\n-- predecesor) y que 3 (su sucesor).\n--\n-- Definir la funci\u00f3n\n--    maximosLocales :: Ord a => [a] -> [a]\n-- tal que (maximosLocales xs) es la lista de los m\u00e1ximos locales de la\n-- lista xs. Por ejemplo,\n--    maximosLocales [3,2,5,3,7,7,1,6,2]  ==  [5,6]\n--    maximosLocales [1..100]             ==  []\n--    maximosLocales \"adbpmqexyz\"         ==  \"dpq\"\n-- ---------------------------------------------------------------------\n\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nmaximosLocales1 :: Ord a => [a] -> [a]\nmaximosLocales1 (x:y:z:xs)\n  | y > x && y > z = y : maximosLocales1 (z:xs)\n  | otherwise      = maximosLocales1 (y:z:xs)\nmaximosLocales1 _ = []\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nmaximosLocales2 :: Ord a => [a] -> [a]\nmaximosLocales2 xs =\n  [y | (x,y,z) <- zip3 xs (tail xs) (drop 2 xs), y > x, y > z]\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_maximosLocales :: [Int] -> Property\nprop_maximosLocales xs =\n  maximosLocales1 xs === maximosLocales2 xs\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_maximosLocales\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> last (maximosLocales1 (take (6*10^6) (cycle \"abc\")))\n--    'c'\n--    (3.26 secs, 1,904,464,984 bytes)\n--    \u03bb> last (maximosLocales2 (take (6*10^6) (cycle \"abc\")))\n--    'c'\n--    (2.79 secs, 1,616,465,088 bytes)\n<\/pre>\n<p>La elaboraci\u00f3n de las soluciones se explica en el siguiente v\u00eddeo:<\/p>\n<p><iframe loading=\"lazy\" width=\"560\" height=\"315\" src=\"https:\/\/www.youtube.com\/embed\/tPjkXB425Ug\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe><\/p>\n<p><a name=\"ej4\"><\/a><\/p>\n<h3>4. Lista cuadrada<\/h3>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Definir la funci\u00f3n\n--    listaCuadrada :: Int -> a -> [a] -> [[a]]\n-- tal que (listaCuadrada n x xs) es una lista de n listas de longitud n\n-- formadas con los elementos de xs completada con x, si no xs no tiene\n-- suficientes elementos. Por ejemplo,\n--    listaCuadrada 3 7 [0,3,5,2,4]  ==  [[0,3,5],[2,4,7],[7,7,7]]\n--    listaCuadrada 3 7 [0..]        ==  [[0,1,2],[3,4,5],[6,7,8]]\n--    listaCuadrada 2 'p' \"eva\"      ==  [\"ev\",\"ap\"]\n--    listaCuadrada 2 'p' ['a'..]    ==  [\"ab\",\"cd\"]\n-- ---------------------------------------------------------------------\n\n{-# OPTIONS_GHC -fno-warn-unused-imports #-}\n\nmodule Lista_cuadrada where\n\nimport Data.List.Split (chunksOf)\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nlistaCuadrada1 :: Int -> a -> [a] -> [[a]]\nlistaCuadrada1 n x xs =\n  take n (grupos n (xs ++ repeat x))\n\n-- (grupos n xs) es la lista obtenida agrupando los elementos de xs en\n-- grupos de n elementos, salvo el \u00faltimo que puede tener menos. Por\n-- ejemplo,\n--    grupos 2 [4,2,5,7,6]     ==  [[4,2],[5,7],[6]]\n--    take 3 (grupos 3 [1..])  ==  [[1,2,3],[4,5,6],[7,8,9]]\ngrupos :: Int -> [a] -> [[a]]\ngrupos _ [] = []\ngrupos n xs = take n xs : grupos n (drop n xs)\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nlistaCuadrada2 :: Int -> a -> [a] -> [[a]]\nlistaCuadrada2 n x xs =\n  take n (grupos2 n (xs ++ repeat x))\n\ngrupos2 :: Int -> [a] -> [[a]]\ngrupos2 _ [] = []\ngrupos2 n xs = ys : grupos n zs\n  where (ys,zs) = splitAt n xs\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nlistaCuadrada3 :: Int -> a -> [a] -> [[a]]\nlistaCuadrada3 n x xs =\n  take n (chunksOf n (xs ++ repeat x))\n\n-- Comprobaci\u00f3n de la equivalencia\n-- ===============================\n\n-- La propiedad es\nprop_listaCuadrada :: Int -> Int -> [Int] -> Bool\nprop_listaCuadrada n x xs =\n  all (== listaCuadrada1 n x xs)\n      [listaCuadrada2 n x xs,\n       listaCuadrada3 n x xs]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_listaCuadrada\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> length (listaCuadrada1 (10^4) 5 [1..])\n--    10000\n--    (2.02 secs, 12,801,918,616 bytes)\n--    \u03bb> length (listaCuadrada2 (10^4) 5 [1..])\n--    10000\n--    (1.89 secs, 12,803,198,576 bytes)\n--    \u03bb> length (listaCuadrada3 (10^4) 5 [1..])\n--    10000\n--    (1.85 secs, 12,801,518,728 bytes)\n<\/pre>\n<p>La elaboraci\u00f3n de las soluciones se explica en el siguiente v\u00eddeo:<\/p>\n<p><iframe loading=\"lazy\" width=\"560\" height=\"315\" src=\"https:\/\/www.youtube.com\/embed\/nJHiCebyZVE\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe><\/p>\n<p><a name=\"ej5\"><\/a><\/p>\n<h3>5. Segmentos de elementos consecutivos<\/h3>\n<pre lang=\"haskell\">\n-- ---------------------------------------------------------------------\n-- Definir la funci\u00f3n\n--    segmentos :: (Enum a, Eq a) => [a] -> [[a]]\n-- tal que (segmentos xss) es la lista de los segmentos de xss formados\n-- por elementos consecutivos. Por ejemplo,\n--    segmentos [1,2,5,6,4]     ==  [[1,2],[5,6],[4]]\n--    segmentos [1,2,3,4,7,8,9] ==  [[1,2,3,4],[7,8,9]]\n--    segmentos \"abbccddeeebc\"  ==  [\"ab\",\"bc\",\"cd\",\"de\",\"e\",\"e\",\"bc\"]\n-- ---------------------------------------------------------------------\n\n{-# OPTIONS_GHC -fno-warn-unused-imports #-}\n\nmodule Segmentos_consecutivos where\n\nimport Test.QuickCheck\n\n-- 1\u00aa soluci\u00f3n\n-- ===========\n\nsegmentos1 :: (Enum a, Eq a) => [a] -> [[a]]\nsegmentos1 []  = []\nsegmentos1 xs = ys : segmentos1 zs\n  where ys = inicial xs\n        n  = length ys\n        zs = drop n xs\n\n-- (inicial xs) es el segmento inicial de xs formado por elementos\n-- consecutivos. Por ejemplo,\n--    inicial [1,2,5,6,4]    ==  [1,2]\n--    inicial \"abccddeeebc\"  ==  \"abc\"\ninicial :: (Enum a, Eq a) => [a] -> [a]\ninicial []      = []\ninicial [x]     = [x]\ninicial (x:y:xs)\n  | succ x == y = x : inicial (y:xs)\n  | otherwise   = [x]\n\n-- 2\u00aa soluci\u00f3n\n-- ===========\n\nsegmentos2 :: (Enum a, Eq a) => [a] -> [[a]]\nsegmentos2 []  = []\nsegmentos2 xs = ys : segmentos2 zs\n  where (ys,zs) = inicialYresto xs\n\n-- (inicialYresto xs) es par formado por el segmento inicial de xs\n-- con elementos consecutivos junto con los restantes elementos. Por\n-- ejemplo,\n--    inicialYresto [1,2,5,6,4]    ==  ([1,2],[5,6,4])\n--    inicialYresto \"abccddeeebc\"  ==  (\"abc\",\"cddeeebc\")\ninicialYresto :: (Enum a, Eq a) => [a] -> ([a],[a])\ninicialYresto []      = ([],[])\ninicialYresto [x]     = ([x],[])\ninicialYresto (x:y:xs)\n  | succ x == y = (x:us,vs)\n  | otherwise   = ([x],y:xs)\n  where (us,vs) = inicialYresto (y:xs)\n\n-- 3\u00aa soluci\u00f3n\n-- ===========\n\nsegmentos3 :: (Enum a, Eq a) => [a] -> [[a]]\nsegmentos3 []  = []\nsegmentos3 [x] = [[x]]\nsegmentos3 (x:xs) | y == succ x = (x:y:ys):zs\n                  | otherwise   = [x] : (y:ys):zs\n  where ((y:ys):zs) = segmentos3 xs\n\n-- 4\u00aa soluci\u00f3n\n-- ===========\n\nsegmentos4 :: (Enum a, Eq a) => [a] -> [[a]]\nsegmentos4 []  = []\nsegmentos4 xs = ys : segmentos4 zs\n  where ys = inicial4 xs\n        n  = length ys\n        zs = drop n xs\n\ninicial4 :: (Enum a, Eq a) => [a] -> [a]\ninicial4 [] = []\ninicial4 (x:xs) =\n  map fst (takeWhile (\\(u,v) -> u == v) (zip (x:xs) [x..]))\n\n-- 5\u00aa soluci\u00f3n\n-- ===========\n\nsegmentos5 :: (Enum a, Eq a) => [a] -> [[a]]\nsegmentos5 []  = []\nsegmentos5 xs = ys : segmentos5 zs\n  where ys = inicial5 xs\n        n  = length ys\n        zs = drop n xs\n\ninicial5 :: (Enum a, Eq a) => [a] -> [a]\ninicial5 [] = []\ninicial5 (x:xs) =\n  map fst (takeWhile (uncurry (==)) (zip (x:xs) [x..]))\n\n-- Comprobaci\u00f3n de equivalencia\n-- ============================\n\n-- La propiedad es\nprop_segmentos :: [Int] -> Bool\nprop_segmentos xs =\n  all (== segmentos1 xs)\n      [segmentos2 xs,\n       segmentos3 xs,\n       segmentos4 xs,\n       segmentos5 xs]\n\n-- La comprobaci\u00f3n es\n--    \u03bb> quickCheck prop_segmentos\n--    +++ OK, passed 100 tests.\n\n-- Comparaci\u00f3n de eficiencia\n-- =========================\n\n-- La comparaci\u00f3n es\n--    \u03bb> length (segmentos1 (take (10^6) (cycle [1..10^3])))\n--    1000\n--    (0.69 secs, 416,742,208 bytes)\n--    \u03bb> length (segmentos2 (take (10^6) (cycle [1..10^3])))\n--    1000\n--    (0.66 secs, 528,861,976 bytes)\n--    \u03bb> length (segmentos3 (take (10^6) (cycle [1..10^3])))\n--    1000\n--    (2.35 secs, 1,016,276,896 bytes)\n--    \u03bb> length (segmentos4 (take (10^6) (cycle [1..10^3])))\n--    1000\n--    (0.27 secs, 409,438,368 bytes)\n--    \u03bb> length (segmentos5 (take (10^6) (cycle [1..10^3])))\n--    1000\n--    (0.13 secs, 401,510,360 bytes)\n--\n--    \u03bb> length (segmentos4 (take (10^7) (cycle [1..10^3])))\n--    10000\n--    (2.35 secs, 4,088,926,920 bytes)\n--    \u03bb> length (segmentos5 (take (10^7) (cycle [1..10^3])))\n--    10000\n--    (1.02 secs, 4,009,646,928 bytes)\n<\/pre>\n<p><iframe loading=\"lazy\" width=\"560\" height=\"315\" src=\"https:\/\/www.youtube.com\/embed\/qu11Uf8wF1k\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe><\/p>\n","protected":false},"excerpt":{"rendered":"<p>Esta semana he publicado en Exercitium las soluciones de los siguientes problemas: 1. Diagonales principales de una matriz. 2. Matrices de Toepliz 3. M\u00e1ximos locales 4. Lista cuadrada 5. Segmentos de elementos consecutivos A continuaci\u00f3n se muestran las soluciones.<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"jetpack_post_was_ever_published":false,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"footnotes":"","_jetpack_memberships_contains_paid_content":false},"categories":[337],"tags":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_likes_enabled":false,"_links":{"self":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7690"}],"collection":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/comments?post=7690"}],"version-history":[{"count":2,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7690\/revisions"}],"predecessor-version":[{"id":7692,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/posts\/7690\/revisions\/7692"}],"wp:attachment":[{"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/media?parent=7690"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/categories?post=7690"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.glc.us.es\/~jalonso\/vestigium\/wp-json\/wp\/v2\/tags?post=7690"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}