febrero 2021 – Exercitium

Eliminaciones anotadas

PorJosé A. Alonso 26-febrero-20215-marzo-2021

Definir la función

   eliminaciones :: [a] -> [(a,Int,[a])]

1	eliminaciones :: [a] -> [(a,Int,[a])]

tal que (eliminaciones xs) es la lista de ternas (x,i,zs) tales que x es un elemento de xs, i es la posición de x en xs y zs es la lista de los restantes elementos de xs. Por ejemplo,

   λ> eliminaciones [5,7,6,5]
   [(5,0,[7,6,5]),(7,1,[5,6,5]),(6,2,[5,7,5]),(5,3,[5,7,6])]

1 2	λ> eliminaciones [5,7,6,5] [(5,0,[7,6,5]),(7,1,[5,6,5]),(6,2,[5,7,5]),(5,3,[5,7,6])]

Soluciones

import Test.QuickCheck (quickCheck)

-- 1ª solución
eliminaciones :: [a] -> [(a,Int,[a])]
eliminaciones xs = [(z,i,zs) | ((z,zs),i) <- zip (aux xs) [0..]]
  where aux []       = []
        aux [x]      = [(x,[])]
        aux (x:y:zs) = (x,y:zs) : [(v,x:vs) | (v,vs) <- aux (y:zs)]

-- 2ª solución
eliminaciones2 :: [a] -> [(a,Int,[a])]
eliminaciones2 xs =
  [(v,i,us++vs) | i <- [0..length xs - 1],
                  let (us,v:vs) = splitAt i xs]

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_equivalencia :: [Int] -> Bool
prop_equivalencia xs =
  eliminaciones xs == eliminaciones2 xs

-- La comprobación es
--    λ> quickCheck prop_equivalencia
--    +++ OK, passed 100 tests.

import Test.QuickCheck (quickCheck)

-- 1ª solución

eliminaciones :: [a] -> [(a,Int,[a])]

eliminaciones xs = [(z,i,zs) | ((z,zs),i) <- zip (aux xs) [0..]]

where aux [] = []

aux [x] = [(x,[])]

aux (x:y:zs) = (x,y:zs) : [(v,x:vs) | (v,vs) <- aux (y:zs)]

-- 2ª solución

eliminaciones2 :: [a] -> [(a,Int,[a])]

eliminaciones2 xs =

[(v,i,us++vs) | i <- [0..length xs - 1],

let (us,v:vs) = splitAt i xs]

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_equivalencia :: [Int] -> Bool

prop_equivalencia xs =

eliminaciones xs == eliminaciones2 xs

-- La comprobación es

-- λ> quickCheck prop_equivalencia

-- +++ OK, passed 100 tests.

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Ternas crecientes de primos con el mayor igual a la suma de los menores

PorJosé A. Alonso 25-febrero-20214-marzo-2021

Definir la función

   ternasPrimas :: [(Integer,Integer,Integer)]

1	ternasPrimas :: [(Integer,Integer,Integer)]

tal que sus elementos son las ternas crecientes de primos con el mayor igual a la suma de los menores. Por ejemplo,

   ternasPrimas  ==  (2,3,5)
   ternasPrimas !! 34567  ==  (2,5393909,5393911)

1 2	ternasPrimas == (2,3,5) ternasPrimas !! 34567 == (2,5393909,5393911)

Soluciones

import Data.Numbers.Primes (primes)

ternasPrimas :: [(Integer,Integer,Integer)]
ternasPrimas = [(2,a,b) | (a,b) <- zip (primes) (tail (primes)),
                          a + 2 == b]

import Data.Numbers.Primes (primes)

ternasPrimas :: [(Integer,Integer,Integer)]

ternasPrimas = [(2,a,b) | (a,b) <- zip (primes) (tail (primes)),

a + 2 == b]

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Máximo de las rotaciones

PorJosé A. Alonso 24-febrero-20213-marzo-2021

Las rotaciones del número 3252 son [3252, 2523, 5232, 2325] y el mayor de dichos números es 5232.

Definir la función

   maximoRotaciones :: Integer -> Integer

1	maximoRotaciones :: Integer -> Integer

tal que (maximoRotaciones n) es el mayor número obtenido rotando los dígitos de n. Por ejemplo,

   maximoRotaciones 3252    ==  5232
   maximoRotaciones 913942  ==  942913
   maximoRotaciones (234 + 10^(10^6)) `div` (10^(10^6))  ==  4

maximoRotaciones 3252 == 5232

maximoRotaciones 913942 == 942913

maximoRotaciones (234 + 10^(10^6)) `div` (10^(10^6)) == 4

Soluciones

import Data.List (inits, tails)

-- 1ª solución
-- ===========

maximoRotaciones :: Integer -> Integer
maximoRotaciones = maximum . rotacionesNumero

-- (rotacionesNumero n) es la lista de las rotaciones obtenidas desplazando
-- el primer dígito de n al final. Por ejemplo,
--    rotacionesNumero 325  ==  [325,253,532]
rotacionesNumero :: Integer -> [Integer]
rotacionesNumero = map read . rotaciones . show

-- (rotaciones xs) es la lista de las rotaciones obtenidas desplazando
-- el primer elemento xs al final. Por ejemplo,
--    rotaciones [2,3,5]  ==  [[2,3,5],[3,5,2],[5,2,3]]
rotaciones :: [a] -> [[a]]
rotaciones xs = take (length xs) (iterate rota xs)

-- (rota xs) es la lista añadiendo el primer elemento de xs al
-- final. Por ejemplo,
--    rota [3,2,5,7]  ==  [2,5,7,3]
rota :: [a] -> [a]
rota (x:xs) = xs ++ [x]

-- 2ª solución
-- ===========

maximoRotaciones2 :: Integer -> Integer
maximoRotaciones2 n =
  maximum (rotacionesDigito n (maximoDigito n))

-- (maximoDigito n) es el máximo de los dígitos de n. Por ejemplo,
--    maximoDigito 291394  ==  9
maximoDigito :: Integer -> Integer
maximoDigito n =
  read [maximum (show n)]

-- (rotacionesDigito n k) es la lista de las rotaciones de n cuyo primer
-- dígito es k. Por ejemplo,
--    rotacionesDigito 291394 9  ==  [913942,942913]
rotacionesDigito :: Integer -> Integer -> [Integer]
rotacionesDigito n k =
  [read (vs ++ us) | (us,vs) <- particiones (show n) (head (show k))]

-- (particiones xs y) es la lista de las particiones de xs en dos partes
-- tales que el primer elemento de la segunda parte es y. Por
-- ejemplo,
--    particiones [2,9,1,3,9,4] 9   == [([2],[9,1,3,9,4]),([2,9,1,3],[9,4])]
--    particiones [2,9,1,3,9,4] 3   == [([2,9,1],[3,9,4])]
--    particiones [2,9,1,3,9,4] 7   == []
--    particiones "Particiones" 'i' == [("Part","iciones"),("Partic","iones")]
particiones :: Eq a => [a] -> a -> [([a],[a])]
particiones xs y =
  [(prefijoSufijo xs zs,zs) | zs <- sufijos xs y]

-- (sufijos xs y) es la lista de los sufijos de xs que empiezan por
-- y. Por ejemplo,
--   λ> sufijos "particiones" 'i'
--   ["iciones","iones"]
sufijos :: Eq a => [a] -> a -> [[a]]
sufijos xs y = filter ((== y) . head) (init (tails xs))

-- (prefijoSufijo xs zs) es el prefijo de xs que junto con el sufijo zs
-- forma la lista xs. Por ejemplo,
--   λ> prefijoSufijo "particiones" "iciones"
--   "part"
prefijoSufijo :: [a] -> [a] -> [a]
prefijoSufijo xs zs = (inits xs) !! (length xs - length zs)

-- Comprobación de equivalencia
-- ============================

-- La propiedad es
prop_equivalencia :: Integer -> Property
prop_equivalencia n =
  n > 0 ==>
  maximoRotaciones n == maximoRotaciones2 n

-- La comprobación es
--    λ> quickCheck prop_equivalencia
--    +++ OK, passed 100 tests.

-- Comparación de eficiencia
-- =========================

-- La comparación es
--    λ> maximoRotaciones (product [1..2000]) `mod` (10^20)
--    64970515522882052348
--    (4.59 secs, 13,275,801,696 bytes)
--    λ> maximoRotaciones2 (product [1..2000]) `mod` (10^20)
--    64970515522882052348
--    (0.41 secs, 1,132,544,240 bytes)
--
--    λ> read (take 9 (show (maximoRotaciones (234 + 10^(10^4))))) :: Integer
--    410000000
--    (12.53 secs, 36,326,102,416 bytes)
--    λ> read (take 9 (show (maximoRotaciones2 (234 + 10^(10^4))))) :: Integer
--    410000000
--    (0.03 secs, 6,227,024 bytes)

100

101

import Data.List (inits, tails)

-- 1ª solución

-- ===========

maximoRotaciones :: Integer -> Integer

maximoRotaciones = maximum . rotacionesNumero

-- (rotacionesNumero n) es la lista de las rotaciones obtenidas desplazando

-- el primer dígito de n al final. Por ejemplo,

-- rotacionesNumero 325 == [325,253,532]

rotacionesNumero :: Integer -> [Integer]

rotacionesNumero = map read . rotaciones . show

-- (rotaciones xs) es la lista de las rotaciones obtenidas desplazando

-- el primer elemento xs al final. Por ejemplo,

-- rotaciones [2,3,5] == [[2,3,5],[3,5,2],[5,2,3]]

rotaciones :: [a] -> [[a]]

rotaciones xs = take (length xs) (iterate rota xs)

-- (rota xs) es la lista añadiendo el primer elemento de xs al

-- final. Por ejemplo,

-- rota [3,2,5,7] == [2,5,7,3]

rota :: [a] -> [a]

rota (x:xs) = xs ++ [x]

-- 2ª solución

-- ===========

maximoRotaciones2 :: Integer -> Integer

maximoRotaciones2 n =

maximum (rotacionesDigito n (maximoDigito n))

-- (maximoDigito n) es el máximo de los dígitos de n. Por ejemplo,

-- maximoDigito 291394 == 9

maximoDigito :: Integer -> Integer

maximoDigito n =

read [maximum (show n)]

-- (rotacionesDigito n k) es la lista de las rotaciones de n cuyo primer

-- dígito es k. Por ejemplo,

-- rotacionesDigito 291394 9 == [913942,942913]

rotacionesDigito :: Integer -> Integer -> [Integer]

rotacionesDigito n k =

[read (vs ++ us) | (us,vs) <- particiones (show n) (head (show k))]

-- (particiones xs y) es la lista de las particiones de xs en dos partes

-- tales que el primer elemento de la segunda parte es y. Por

-- ejemplo,

-- particiones [2,9,1,3,9,4] 9 == [([2],[9,1,3,9,4]),([2,9,1,3],[9,4])]

-- particiones [2,9,1,3,9,4] 3 == [([2,9,1],[3,9,4])]

-- particiones [2,9,1,3,9,4] 7 == []

-- particiones "Particiones" 'i' == [("Part","iciones"),("Partic","iones")]

particiones :: Eq a => [a] -> a -> [([a],[a])]

particiones xs y =

[(prefijoSufijo xs zs,zs) | zs <- sufijos xs y]

-- (sufijos xs y) es la lista de los sufijos de xs que empiezan por

-- y. Por ejemplo,

-- λ> sufijos "particiones" 'i'

-- ["iciones","iones"]

sufijos :: Eq a => [a] -> a -> [[a]]

sufijos xs y = filter ((== y) . head) (init (tails xs))

-- (prefijoSufijo xs zs) es el prefijo de xs que junto con el sufijo zs

-- forma la lista xs. Por ejemplo,

-- λ> prefijoSufijo "particiones" "iciones"

-- "part"

prefijoSufijo :: [a] -> [a] -> [a]

prefijoSufijo xs zs = (inits xs) !! (length xs - length zs)

-- Comprobación de equivalencia

-- ============================

-- La propiedad es

prop_equivalencia :: Integer -> Property

prop_equivalencia n =

n > 0 ==>

maximoRotaciones n == maximoRotaciones2 n

-- La comprobación es

-- λ> quickCheck prop_equivalencia

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

-- =========================

-- La comparación es

-- λ> maximoRotaciones (product [1..2000]) `mod` (10^20)

-- 64970515522882052348

-- (4.59 secs, 13,275,801,696 bytes)

-- λ> maximoRotaciones2 (product [1..2000]) `mod` (10^20)

-- 64970515522882052348

-- (0.41 secs, 1,132,544,240 bytes)

-- λ> read (take 9 (show (maximoRotaciones (234 + 10^(10^4))))) :: Integer

-- 410000000

-- (12.53 secs, 36,326,102,416 bytes)

-- λ> read (take 9 (show (maximoRotaciones2 (234 + 10^(10^4))))) :: Integer

-- 410000000

-- (0.03 secs, 6,227,024 bytes)

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Particiones por un elemento

PorJosé A. Alonso 23-febrero-20212-marzo-2021

Definir la función

   particiones :: Eq a => [a] -> a -> [([a],[a])]

1	particiones :: Eq a => [a] -> a -> [([a],[a])]

tal que (particiones xs y) es la lista de las particiones de xs en dos partes tales que el primer elemento de la segunda parte es y. Por ejemplo,

   particiones [2,9,1,3,9,4] 9   == [([2],[9,1,3,9,4]),([2,9,1,3],[9,4])]
   particiones [2,9,1,3,9,4] 3   == [([2,9,1],[3,9,4])]
   particiones [2,9,1,3,9,4] 7   == []
   particiones "Particiones" 'i' == [("Part","iciones"),("Partic","iones")]

particiones [2,9,1,3,9,4] 9 == [([2],[9,1,3,9,4]),([2,9,1,3],[9,4])]

particiones [2,9,1,3,9,4] 3 == [([2,9,1],[3,9,4])]

particiones [2,9,1,3,9,4] 7 == []

particiones "Particiones" 'i' == [("Part","iciones"),("Partic","iones")]

Soluciones

import Data.List (tails, inits)

-- 1ª solución
-- ===========

particiones :: Eq a => [a] -> a -> [([a],[a])]
particiones [] _ = []
particiones xs y
  | null vs = []
  | otherwise = (us,vs) : [(us ++ y:us', vs')
                          | (us',vs') <- particiones (tail vs) y ]
  where (us,vs) = span (/=y) xs

-- 2ª solución
-- ===========

particiones2 :: Eq a => [a] -> a -> [([a],[a])]
particiones2 xs y =
  [(ys,z:zs) | (ys,z:zs) <- listaPares xs, z == y]

-- (listaPares xs) es la lista de los pares que resultan al dividir la
-- lista xs en dos partes. Por ejemplo,
--    λ> listaPares [2,9,1,3,9,4]
--    [([],[2,9,1,3,9,4]),([2],[9,1,3,9,4]),([2,9],[1,3,9,4]),([2,9,1],[3,9,4]),
--    ([2,9,1,3],[9,4]),([2,9,1,3,9],[4])]
listaPares :: [a] -> [([a],[a])]
listaPares xs = init (zip (inits xs) (tails xs))

-- 3ª solución
-- ===========

particiones3 :: Eq a => [a] -> a -> [([a],[a])]
particiones3 xs y =
  [(prefijoSufijo xs zs,zs) | zs <- sufijos xs y]

-- (sufijos xs y) es la lista de los sufijos de xs que empiezan por
-- y. Por ejemplo,
--   λ> sufijos "particiones" 'i'
--   ["iciones","iones"]
sufijos :: Eq a => [a] -> a -> [[a]]
sufijos xs y = filter ((== y) . head) (init (tails xs))

-- (prefijoSufijo xs zs) es el prefijo de xs que junto con el sufijo zs
-- forma la lista xs. Por ejemplo,
--   λ> prefijoSufijo "particiones" "iciones"
--   "part"
prefijoSufijo :: [a] -> [a] -> [a]
prefijoSufijo xs zs = (inits xs) !! (length xs - length zs)

-- Comprobación de la equivalencia
-- ===============================

-- La propiedad es
prop_equivalencia :: [Int] -> Int -> Bool
prop_equivalencia xs y =
  particiones xs y'  == particiones2 xs y' &&
  particiones2 xs y' == particiones3 xs y'
  where y' = y `mod` length xs

-- La comprobación es
--    λ> quickCheck prop_equivalencia
--    +++ OK, passed 100 tests.

-- Comparación de eficiencia
-- =========================

-- La comparación es
--    λ> length (particiones (take (10^5) (cycle [1..9])) 5)
--    11111
--    (9.10 secs, 13,375,324,416 bytes)
--    λ> length (particiones2 (take (10^5) (cycle [1..9])) 5)
--    11111
--    (0.08 secs, 44,107,672 bytes)
--    λ> length (particiones3 (take (10^5) (cycle [1..9])) 5)
--    11111
--    (0.07 secs, 21,524,936 bytes)
--
--    λ> length (particiones2 (take (10^7) (cycle [1..9])) 5)
--    1111111
--    (3.93 secs, 4,400,105,800 bytes)
--    λ> length (particiones3 (take (10^7) (cycle [1..9])) 5)
--    1111111
--    (1.88 secs, 2,142,328,800 bytes)

import Data.List (tails, inits)

-- 1ª solución

-- ===========

particiones :: Eq a => [a] -> a -> [([a],[a])]

particiones [] _ = []

particiones xs y

| null vs = []

| otherwise = (us,vs) : [(us ++ y:us', vs')

| (us',vs') <- particiones (tail vs) y ]

where (us,vs) = span (/=y) xs

-- 2ª solución

-- ===========

particiones2 :: Eq a => [a] -> a -> [([a],[a])]

particiones2 xs y =

[(ys,z:zs) | (ys,z:zs) <- listaPares xs, z == y]

-- (listaPares xs) es la lista de los pares que resultan al dividir la

-- lista xs en dos partes. Por ejemplo,

-- λ> listaPares [2,9,1,3,9,4]

-- [([],[2,9,1,3,9,4]),([2],[9,1,3,9,4]),([2,9],[1,3,9,4]),([2,9,1],[3,9,4]),

-- ([2,9,1,3],[9,4]),([2,9,1,3,9],[4])]

listaPares :: [a] -> [([a],[a])]

listaPares xs = init (zip (inits xs) (tails xs))

-- 3ª solución

-- ===========

particiones3 :: Eq a => [a] -> a -> [([a],[a])]

particiones3 xs y =

[(prefijoSufijo xs zs,zs) | zs <- sufijos xs y]

-- (sufijos xs y) es la lista de los sufijos de xs que empiezan por

-- y. Por ejemplo,

-- λ> sufijos "particiones" 'i'

-- ["iciones","iones"]

sufijos :: Eq a => [a] -> a -> [[a]]

sufijos xs y = filter ((== y) . head) (init (tails xs))

-- (prefijoSufijo xs zs) es el prefijo de xs que junto con el sufijo zs

-- forma la lista xs. Por ejemplo,

-- λ> prefijoSufijo "particiones" "iciones"

-- "part"

prefijoSufijo :: [a] -> [a] -> [a]

prefijoSufijo xs zs = (inits xs) !! (length xs - length zs)

-- Comprobación de la equivalencia

-- ===============================

-- La propiedad es

prop_equivalencia :: [Int] -> Int -> Bool

prop_equivalencia xs y =

particiones xs y' == particiones2 xs y' &&

particiones2 xs y' == particiones3 xs y'

where y' = y `mod` length xs

-- La comprobación es

-- λ> quickCheck prop_equivalencia

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

-- =========================

-- La comparación es

-- λ> length (particiones (take (10^5) (cycle [1..9])) 5)

-- 11111

-- (9.10 secs, 13,375,324,416 bytes)

-- λ> length (particiones2 (take (10^5) (cycle [1..9])) 5)

-- 11111

-- (0.08 secs, 44,107,672 bytes)

-- λ> length (particiones3 (take (10^5) (cycle [1..9])) 5)

-- 11111

-- (0.07 secs, 21,524,936 bytes)

-- λ> length (particiones2 (take (10^7) (cycle [1..9])) 5)

-- 1111111

-- (3.93 secs, 4,400,105,800 bytes)

-- λ> length (particiones3 (take (10^7) (cycle [1..9])) 5)

-- 1111111

-- (1.88 secs, 2,142,328,800 bytes)

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Sumas de potencias que son cuadrados perfectos

PorJosé A. Alonso 22-febrero-20211-marzo-2021

El 2º problema de la ONEM (Olimpíada Nacional Escolar de Matemática) de Mayo del 2020 dice

Determinar si existen enteros positivos a, b y c, no necesariamente distintos, tales que $a+b+c=2020$ y $2^a + 2^b + 2^c$ es un cuadrado perfecto.

Definir la función

   soluciones :: Integer -> Integer -> [(Integer,Integer,Integer)]

1	soluciones :: Integer -> Integer -> [(Integer,Integer,Integer)]

tales que (soluciones k n) es la lista de las ternas no decrecientes (a,b,c) tales que que a+b+c=n y k^a + k^b + k^c es un cuadrado perfecto. Por ejemplo,

   soluciones 2 19  ==  [(2,6,11),(2,7,10),(4,7,8),(5,5,9),(6,6,7)]
   soluciones 3 19  ==  []
   take 2 (soluciones 2 2020)  ==  [(2,674,1344),(4,674,1342)]

soluciones 2 19 == [(2,6,11),(2,7,10),(4,7,8),(5,5,9),(6,6,7)]

soluciones 3 19 == []

take 2 (soluciones 2 2020) == [(2,674,1344),(4,674,1342)]

Soluciones

soluciones :: Integer -> Integer -> [(Integer,Integer,Integer)]
soluciones k n =
  [(a,b,c) | a <- [1..n `div` 3],
             b <- [a..n-a],
             let c = n-a-b,
             c >= b,
             esCuadradoPerfecto (k^a + k^b + k^c)]

-- (esCuadradoPerfecto x) se verifica si x es un cuadrado perfecto. Por
-- ejemplo,
--    esCuadradoPerfecto 16  ==  True
--    esCuadradoPerfecto 27  ==  False
esCuadradoPerfecto :: Integer -> Bool
esCuadradoPerfecto x =
  (raizEntera x)^2 == x

-- (raizEntera x) es el mayor entero cuyo cuadrado es menor o igual que
-- x. Por ejemplo,
--    raizEntera 16  ==  4
--    raizEntera 27  ==  5
raizEntera :: Integer -> Integer
raizEntera x = aux (1,x)
    where aux (a,b) | d == x    = c
                    | c == a    = c
                    | d < x     = aux (c,b)
                    | otherwise = aux (a,c)
              where c = (a+b) `div` 2
                    d = c^2

soluciones :: Integer -> Integer -> [(Integer,Integer,Integer)]

soluciones k n =

[(a,b,c) | a <- [1..n `div` 3],

b <- [a..n-a],

let c = n-a-b,

c >= b,

esCuadradoPerfecto (k^a + k^b + k^c)]

-- (esCuadradoPerfecto x) se verifica si x es un cuadrado perfecto. Por

-- ejemplo,

-- esCuadradoPerfecto 16 == True

-- esCuadradoPerfecto 27 == False

esCuadradoPerfecto :: Integer -> Bool

esCuadradoPerfecto x =

(raizEntera x)^2 == x

-- (raizEntera x) es el mayor entero cuyo cuadrado es menor o igual que

-- x. Por ejemplo,

-- raizEntera 16 == 4

-- raizEntera 27 == 5

raizEntera :: Integer -> Integer

raizEntera x = aux (1,x)

where aux (a,b) | d == x = c

| c == a = c

| d < x = aux (c,b)

| otherwise = aux (a,c)

where c = (a+b) `div` 2

d = c^2

Nuevas soluciones

En los comentarios se pueden escribir nuevas soluciones.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

Meses: febrero 2021

Eliminaciones anotadas

Soluciones

Nuevas soluciones

Ternas crecientes de primos con el mayor igual a la suma de los menores

Soluciones

Nuevas soluciones

Máximo de las rotaciones

Soluciones

Nuevas soluciones

Particiones por un elemento

Soluciones

Nuevas soluciones

Sumas de potencias que son cuadrados perfectos

Soluciones

Nuevas soluciones

Entradas recientes

Buscar

Correo electrónico