marzo 2021 – Página 5

Espirales

PorJosé A. Alonso 3-marzo-202110-marzo-2021

Definir la función

   espiral :: Int -> [[Int]]

1	espiral :: Int -> [[Int]]

tal que (espiral n) es la espiral de orden n (es decir, con n filas y n columnas). Por ejemplo,

   λ> mapM_ print (espiral 5)
   [1,1,1,1,1]
   [0,0,0,0,1]
   [1,1,1,0,1]
   [1,0,0,0,1]
   [1,1,1,1,1]
   λ> mapM_ print (espiral 6)
   [1,1,1,1,1,1]
   [0,0,0,0,0,1]
   [1,1,1,1,0,1]
   [1,0,0,1,0,1]
   [1,0,0,0,0,1]
   [1,1,1,1,1,1]
   λ> mapM_ print (espiral 7)
   [1,1,1,1,1,1,1]
   [0,0,0,0,0,0,1]
   [1,1,1,1,1,0,1]
   [1,0,0,0,1,0,1]
   [1,0,1,1,1,0,1]
   [1,0,0,0,0,0,1]
   [1,1,1,1,1,1,1]
   λ> mapM_ print (espiral 8)
   [1,1,1,1,1,1,1,1]
   [0,0,0,0,0,0,0,1]
   [1,1,1,1,1,1,0,1]
   [1,0,0,0,0,1,0,1]
   [1,0,1,0,0,1,0,1]
   [1,0,1,1,1,1,0,1]
   [1,0,0,0,0,0,0,1]
   [1,1,1,1,1,1,1,1]

λ> mapM_ print (espiral 5)

[1,1,1,1,1]

[0,0,0,0,1]

[1,1,1,0,1]

[1,0,0,0,1]

[1,1,1,1,1]

λ> mapM_ print (espiral 6)

[1,1,1,1,1,1]

[0,0,0,0,0,1]

[1,1,1,1,0,1]

[1,0,0,1,0,1]

[1,0,0,0,0,1]

[1,1,1,1,1,1]

λ> mapM_ print (espiral 7)

[1,1,1,1,1,1,1]

[0,0,0,0,0,0,1]

[1,1,1,1,1,0,1]

[1,0,0,0,1,0,1]

[1,0,1,1,1,0,1]

[1,0,0,0,0,0,1]

[1,1,1,1,1,1,1]

λ> mapM_ print (espiral 8)

[1,1,1,1,1,1,1,1]

[0,0,0,0,0,0,0,1]

[1,1,1,1,1,1,0,1]

[1,0,0,0,0,1,0,1]

[1,0,1,0,0,1,0,1]

[1,0,1,1,1,1,0,1]

[1,0,0,0,0,0,0,1]

[1,1,1,1,1,1,1,1]

Nota: La serpiente (formada por los 1) nunca se puede tocar a ella misma.

Soluciones

import Data.List (transpose)

espiral :: Int -> [[Int]]
espiral n = espiralAux n n

espiralAux :: Int -> Int -> [[Int]]
espiralAux 0 _ = []
espiralAux 1 1 = [[1]]
espiralAux n m = primeraFila n : segundaFila n : filasDesdeTercera n m

-- (primeraFila n) es la primera fila de la espiral de orden n. Por
-- ejemplo,
--    λ> primeraFila 5
--    [1,1,1,1,1]
primeraFila :: Int -> [Int]
primeraFila n = replicate n 1

-- (segundaFila n) es la segunda de la espiral de orden n. Por
-- ejemplo,
--    λ> segundaFila 5
--    [0,0,0,0,1]
segundaFila :: Int -> [Int]
segundaFila n = replicate (n-1) 0 ++ [1]

-- (filasDesdeTercera n m), cuando n = m, es la lista de las filas de la
-- espiral de orden n a partir de la tercera. Por ejemplo,
--    λ> mapM_ print (filasDesdeTercera 5 5)
--    [1,1,1,0,1]
--    [1,0,0,0,1]
--    [1,1,1,1,1]
filasDesdeTercera :: Int -> Int -> [[Int]]
filasDesdeTercera n m = map reverse (transpose (espiralAux (m-2) n))

import Data.List (transpose)

espiral :: Int -> [[Int]]

espiral n = espiralAux n n

espiralAux :: Int -> Int -> [[Int]]

espiralAux 0 _ = []

espiralAux 1 1 = [[1]]

espiralAux n m = primeraFila n : segundaFila n : filasDesdeTercera n m

-- (primeraFila n) es la primera fila de la espiral de orden n. Por

-- ejemplo,

-- λ> primeraFila 5

-- [1,1,1,1,1]

primeraFila :: Int -> [Int]

primeraFila n = replicate n 1

-- (segundaFila n) es la segunda de la espiral de orden n. Por

-- ejemplo,

-- λ> segundaFila 5

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

segundaFila :: Int -> [Int]

segundaFila n = replicate (n-1) 0 ++ [1]

-- (filasDesdeTercera n m), cuando n = m, es la lista de las filas de la

-- espiral de orden n a partir de la tercera. Por ejemplo,

-- λ> mapM_ print (filasDesdeTercera 5 5)

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

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

-- [1,1,1,1,1]

filasDesdeTercera :: Int -> Int -> [[Int]]

filasDesdeTercera n m = map reverse (transpose (espiralAux (m-2) n))

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ínima diferencia de las sumas de las biparticiones de las N primeras potencias de dos

PorJosé A. Alonso 2-marzo-20219-marzo-2021

Se consideran las N primeras potencias de 2 (donde N es un número par). Por ejemplo, para N = 4, las potencias de 2 son 1, 2, 4 y 8. Las biparticiones de dichas potencias en dos conjuntos de igual tamaño son

   ([1,2],[4,8]), ([1,4],[2,8]), ([1,8],[2,4])

1	([1,2],[4,8]), ([1,4],[2,8]), ([1,8],[2,4])

Las sumas de los elementos de las biparticiones son

   (3,12), (5,10), (9,6)

1	(3,12), (5,10), (9,6)

Los valores absolutos de las diferencias de dichas sumas son

   9, 5, 3

9, 5, 3

El mínimo de dichas diferencias es 3.

Definir la función

  minimaDiferencia :: Integer -> Integer

1	minimaDiferencia :: Integer -> Integer

tal que (minimaDiferencia n) es la mínima diferencia de las sumas las biparticiones de las n (donde n es un número par) primeras potencias de dos conjuntos con igual número de elementos. Por ejemplo,

   minimaDiferencia 4  ==  3
   minimaDiferencia 6  ==  7
   minimaDiferencia (10^9) `mod` (10^9)  ==  787109375

minimaDiferencia 4 == 3

minimaDiferencia 6 == 7

minimaDiferencia (10^9) `mod` (10^9) == 787109375

Soluciones

import Test.QuickCheck
import Data.List ((\\))

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

minimaDiferencia :: Integer -> Integer
minimaDiferencia n =
  minimum [abs (sum xs - sum ys) | (xs,ys) <- particiones n]

-- (particiones n) es la lista de las particiones de las n (donde n es
-- un número par) de las n primeras potencias de 2 en dos conjuntos de
-- igual tamaño. Por ejemplo,
--   λ> particiones 4
--   [([1,2],[4,8]),([1,4],[2,8]),([1,8],[2,4]),
--    ([2,4],[1,8]),([2,8],[1,4]),([4,8],[1,2])]
particiones :: Integer -> [([Integer],[Integer])]
particiones n =
  [(as,xs \\ as) | as <- kSubconjuntos xs (n `div` 2)]
  where xs = [2^k | k <- [0..n-1]]

-- (kSubconjuntos xs k) es la lista de los subconjuntos de xs con k
-- elementos. Por ejemplo,
--    λ> kSubconjuntos "bcde" 2
--    ["bc","bd","be","cd","ce","de"]
--    λ> kSubconjuntos "bcde" 3
--    ["bcd","bce","bde","cde"]
--    λ> kSubconjuntos "abcde" 3
--    ["abc","abd","abe","acd","ace","ade","bcd","bce","bde","cde"]
kSubconjuntos :: [a] -> Integer -> [[a]]
kSubconjuntos _ 0      = [[]]
kSubconjuntos [] _     = []
kSubconjuntos (x:xs) k =
  [x:ys | ys <- kSubconjuntos xs (k-1)] ++ kSubconjuntos xs k

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

-- Nota: La suma de las primeras (n-1) potencias de 2 es
--    sum [2^i | i <- [0..n-2]] = 2^(n-1) - 1
-- que es menor que la n-ésima potencia de 2 (es decir, 2^(n-1) porque
-- se empieza a contar en 0). Por tanto, para que la diferencia de las
-- suma sea mínima hay que agrupar la última (2^(n-1) con las menores
-- (es decir, desde 0 hasta n/2-2).

minimaDiferencia2 :: Integer -> Integer
minimaDiferencia2 n =
  2^(n-1) + sum [2^i | i <- [0..n `div` 2 - 2]] -
  sum [2^i | i <- [n `div` 2 - 1.. n-2]]

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

-- Nota: Sea m = n/2 - 2. Entonces la suma de la mayor con las menores
-- es
--    s1 = 2^(n-1) + sum [2^i | i <- [0..m]]
--       = 2^(n-1) + (2^(m+1)-1)
-- y, puesto que la suma de las n primeras potencias es 2^n-1, la suma
-- de las restantes es
--    s2 = (2^n-1) - s1

minimaDiferencia3 :: Integer -> Integer
minimaDiferencia3 n = s1 - s2
  where m = n `div` 2 - 2
        s1 = 2^(n-1) + (2^(m+1)-1)
        s2 = (2^n-1) - s1

-- 4ª solución
-- ===========

-- Nota: Con la notación de la solución anterior, la mínima diferencia es
--    s1 - s2
--    = s1 - ((2^n-1) - s1)
--    = 2*s1 - (2^n-1)
--    = 2*(2^(n-1) + (2^(m+1)-1)) - (2^n-1)
--    = 2^n + 2^(m+2) - 2 - 2^n + 1
--    = 2^(m+2) - 1

minimaDiferencia4 :: Integer -> Integer
minimaDiferencia4 n = 2^(m+2) - 1
  where m = n `div` 2 - 2

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

-- La comparación es
--    λ> minimaDiferencia 22
--    2047
--    (7.75 secs, 6,597,330,816 bytes)
--    λ> minimaDiferencia2 22
--    2047
--    (0.00 secs, 126,344 bytes)
--    λ> minimaDiferencia3 22
--    2047
--    (0.01 secs, 107,192 bytes)
--    λ> minimaDiferencia4 22
--    2047
--    (0.01 secs, 102,544 bytes)
--
--    λ> minimaDiferencia2 (10^5) `mod` (10^50)
--    9602443968201967760613102289456131085235835109375
--    (8.18 secs, 2,915,200,064 bytes)
--    λ> minimaDiferencia3 (10^5) `mod` (10^50)
--    9602443968201967760613102289456131085235835109375
--    (0.01 secs, 293,640 bytes)
--    λ> minimaDiferencia4 (10^5) `mod` (10^50)
--    9602443968201967760613102289456131085235835109375
--    (0.03 secs, 167,176 bytes)
--
--    λ> minimaDiferencia3 (10^8) `mod` (10^50)
--    30521751870548886367615394702753936894129787109375
--    (2.08 secs, 149,075,824 bytes)
--    λ> minimaDiferencia4 (10^8) `mod` (10^50)
--    30521751870548886367615394702753936894129787109375
--    (0.41 secs, 24,929,696 bytes)

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

-- Como la primera sólo calcula hasta 22, se compara la primera con la
-- cuarta para dichos valores.
prop_equivalencia1 :: Bool
prop_equivalencia1 =
  and [minimaDiferencia n == minimaDiferencia4 n | n <- [0,2..22]]

-- La comprobación es
--    λ> prop_equivalencia1
--    True

-- La propiedad de la equivalencia de las definiciones 2, 3 y 4 es
prop_equivalencia :: Integer -> Bool
prop_equivalencia n =
  all (== (minimaDiferencia2 n'))
      [minimaDiferencia3 n',
       minimaDiferencia4 n']
  where n' = 2 + abs n

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

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

import Test.QuickCheck

import Data.List ((\\))

-- 1ª solución

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

minimaDiferencia :: Integer -> Integer

minimaDiferencia n =

minimum [abs (sum xs - sum ys) | (xs,ys) <- particiones n]

-- (particiones n) es la lista de las particiones de las n (donde n es

-- un número par) de las n primeras potencias de 2 en dos conjuntos de

-- igual tamaño. Por ejemplo,

-- λ> particiones 4

-- [([1,2],[4,8]),([1,4],[2,8]),([1,8],[2,4]),

-- ([2,4],[1,8]),([2,8],[1,4]),([4,8],[1,2])]

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

particiones n =

[(as,xs \\ as) | as <- kSubconjuntos xs (n `div` 2)]

where xs = [2^k | k <- [0..n-1]]

-- (kSubconjuntos xs k) es la lista de los subconjuntos de xs con k

-- elementos. Por ejemplo,

-- λ> kSubconjuntos "bcde" 2

-- ["bc","bd","be","cd","ce","de"]

-- λ> kSubconjuntos "bcde" 3

-- ["bcd","bce","bde","cde"]

-- λ> kSubconjuntos "abcde" 3

-- ["abc","abd","abe","acd","ace","ade","bcd","bce","bde","cde"]

kSubconjuntos :: [a] -> Integer -> [[a]]

kSubconjuntos _ 0 = [[]]

kSubconjuntos [] _ = []

kSubconjuntos (x:xs) k =

[x:ys | ys <- kSubconjuntos xs (k-1)] ++ kSubconjuntos xs k

-- 2ª solución

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

-- Nota: La suma de las primeras (n-1) potencias de 2 es

-- sum [2^i | i <- [0..n-2]] = 2^(n-1) - 1

-- que es menor que la n-ésima potencia de 2 (es decir, 2^(n-1) porque

-- se empieza a contar en 0). Por tanto, para que la diferencia de las

-- suma sea mínima hay que agrupar la última (2^(n-1) con las menores

-- (es decir, desde 0 hasta n/2-2).

minimaDiferencia2 :: Integer -> Integer

minimaDiferencia2 n =

2^(n-1) + sum [2^i | i <- [0..n `div` 2 - 2]] -

sum [2^i | i <- [n `div` 2 - 1.. n-2]]

-- 3ª solución

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

-- Nota: Sea m = n/2 - 2. Entonces la suma de la mayor con las menores

-- es

-- s1 = 2^(n-1) + sum [2^i | i <- [0..m]]

-- = 2^(n-1) + (2^(m+1)-1)

-- y, puesto que la suma de las n primeras potencias es 2^n-1, la suma

-- de las restantes es

-- s2 = (2^n-1) - s1

minimaDiferencia3 :: Integer -> Integer

minimaDiferencia3 n = s1 - s2

where m = n `div` 2 - 2

s1 = 2^(n-1) + (2^(m+1)-1)

s2 = (2^n-1) - s1

-- 4ª solución

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

-- Nota: Con la notación de la solución anterior, la mínima diferencia es

-- s1 - s2

-- = s1 - ((2^n-1) - s1)

-- = 2*s1 - (2^n-1)

-- = 2*(2^(n-1) + (2^(m+1)-1)) - (2^n-1)

-- = 2^n + 2^(m+2) - 2 - 2^n + 1

-- = 2^(m+2) - 1

minimaDiferencia4 :: Integer -> Integer

minimaDiferencia4 n = 2^(m+2) - 1

where m = n `div` 2 - 2

-- Comparación de eficiencia

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

-- La comparación es

-- λ> minimaDiferencia 22

-- 2047

-- (7.75 secs, 6,597,330,816 bytes)

-- λ> minimaDiferencia2 22

-- 2047

-- (0.00 secs, 126,344 bytes)

-- λ> minimaDiferencia3 22

-- 2047

-- (0.01 secs, 107,192 bytes)

-- λ> minimaDiferencia4 22

-- 2047

-- (0.01 secs, 102,544 bytes)

-- λ> minimaDiferencia2 (10^5) `mod` (10^50)

-- 9602443968201967760613102289456131085235835109375

-- (8.18 secs, 2,915,200,064 bytes)

-- λ> minimaDiferencia3 (10^5) `mod` (10^50)

-- 9602443968201967760613102289456131085235835109375

-- (0.01 secs, 293,640 bytes)

-- λ> minimaDiferencia4 (10^5) `mod` (10^50)

-- 9602443968201967760613102289456131085235835109375

-- (0.03 secs, 167,176 bytes)

-- λ> minimaDiferencia3 (10^8) `mod` (10^50)

-- 30521751870548886367615394702753936894129787109375

-- (2.08 secs, 149,075,824 bytes)

-- λ> minimaDiferencia4 (10^8) `mod` (10^50)

-- 30521751870548886367615394702753936894129787109375

-- (0.41 secs, 24,929,696 bytes)

-- Comprobación de equivalencia

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

-- Como la primera sólo calcula hasta 22, se compara la primera con la

-- cuarta para dichos valores.

prop_equivalencia1 :: Bool

prop_equivalencia1 =

and [minimaDiferencia n == minimaDiferencia4 n | n <- [0,2..22]]

-- La comprobación es

-- λ> prop_equivalencia1

-- True

-- La propiedad de la equivalencia de las definiciones 2, 3 y 4 es

prop_equivalencia :: Integer -> Bool

prop_equivalencia n =

all (== (minimaDiferencia2 n'))

[minimaDiferencia3 n',

minimaDiferencia4 n']

where n' = 2 + abs n

-- 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>

Índice del menor elemento a eliminar para que la suma sea divisible por K

PorJosé A. Alonso 1-marzo-20218-marzo-2021

Definir la función

   indice :: [Int] -> Int -> Maybe Int

1	indice :: [Int] -> Int -> Maybe Int

tal que (indice xs k) es el índice del menor elemento a eliminar de la lista de enteros positivos xs para que la suma de los restantes sea divisible por k o Nothing, si no existe dicho elemento. Por ejemplo,

   indice [1,8,4,1] 2         ==  Just 2
   indice [4,6,7,5,7] 11      ==  Just 2
   indice [4,6,7,5,7] 12      ==  Just 3
   indice [4,6,7,5,7] 13      ==  Nothing
   indice [1..10^7] 7         ==  Just 5
   indice [10^7,10^7-1..1] 7  ==  Just 9999994

indice [1,8,4,1] 2 == Just 2

indice [4,6,7,5,7] 11 == Just 2

indice [4,6,7,5,7] 12 == Just 3

indice [4,6,7,5,7] 13 == Nothing

indice [1..10^7] 7 == Just 5

indice [10^7,10^7-1..1] 7 == Just 9999994

Soluciones

import Test.QuickCheck
import Data.List (sort)
import Data.Maybe (listToMaybe)

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

indice :: [Int] -> Int -> Maybe Int
indice xs k
  | null ys   = Nothing
  | otherwise = Just (head ys)
  where ys = [i | (_,i,zs) <- sort (eliminaciones xs),
                  sum zs `mod` k == 0]

-- (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])]
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
-- ===========

indice2 :: [Int] -> Int -> Maybe Int
indice2 xs k
  | null ys   = Nothing
  | otherwise = Just (head ys)
  where d = sum xs `mod` k
        ys = [i | (x,i) <- sort (zip xs [0..]),
                  x `mod` k == d]

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

indice3 :: [Int] -> Int -> Maybe Int
indice3 xs k = listToMaybe ys
  where d = sum xs `mod` k
        ys = [i | (x,i) <- sort (zip xs [0..]),
                  x `mod` k == d]

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

-- La propiedad es
prop_equivalencia :: [Int] -> Int -> Bool
prop_equivalencia xs k =
  indice  xs' k' == indice2 xs' k' &&
  indice2 xs' k' == indice3 xs' k'
  where xs' = map ((+1) . abs) xs
        k'  = 1 + abs k

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

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

-- La comparación es
--    λ> indice [1..5000] 7
--    Just 2
--    (2.82 secs, 2,458,555,104 bytes)
--    λ> indice2 [1..5000] 7
--    Just 2
--    (0.01 secs, 1,991,232 bytes)
--    λ> indice3 [1..5000] 7
--    Just 2
--    (0.01 secs, 1,991,072 bytes)

import Test.QuickCheck

import Data.List (sort)

import Data.Maybe (listToMaybe)

-- 1ª solución

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

indice :: [Int] -> Int -> Maybe Int

indice xs k

| null ys = Nothing

| otherwise = Just (head ys)

where ys = [i | (_,i,zs) <- sort (eliminaciones xs),

sum zs `mod` k == 0]

-- (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])]

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

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

indice2 :: [Int] -> Int -> Maybe Int

indice2 xs k

| null ys = Nothing

| otherwise = Just (head ys)

where d = sum xs `mod` k

ys = [i | (x,i) <- sort (zip xs [0..]),

x `mod` k == d]

-- 3ª solución

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

indice3 :: [Int] -> Int -> Maybe Int

indice3 xs k = listToMaybe ys

where d = sum xs `mod` k

ys = [i | (x,i) <- sort (zip xs [0..]),

x `mod` k == d]

-- Comprobación de la equivalencia

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

-- La propiedad es

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

prop_equivalencia xs k =

indice xs' k' == indice2 xs' k' &&

indice2 xs' k' == indice3 xs' k'

where xs' = map ((+1) . abs) xs

k' = 1 + abs k

-- La comprobación es

-- λ> quickCheck prop_equivalencia

-- +++ OK, passed 100 tests.

-- Comparación de eficiencia

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

-- La comparación es

-- λ> indice [1..5000] 7

-- Just 2

-- (2.82 secs, 2,458,555,104 bytes)

-- λ> indice2 [1..5000] 7

-- Just 2

-- (0.01 secs, 1,991,232 bytes)

-- λ> indice3 [1..5000] 7

-- Just 2

-- (0.01 secs, 1,991,072 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>

Meses: marzo 2021

Espirales

Soluciones

Nuevas soluciones

Mínima diferencia de las sumas de las biparticiones de las N primeras potencias de dos

Soluciones

Nuevas soluciones

Índice del menor elemento a eliminar para que la suma sea divisible por K

Soluciones

Nuevas soluciones

Entradas recientes

Buscar

Correo electrónico