Menu Close

Mínima suma borrando todas las ocurrencias de un dígito

Para la lista [23,12,77,82], las sumas obtenidas eliminando todas las ocurrencias de uno de sus dígitos son

+ Eliminando el 1: 23 +  2 + 77 + 82 = 184
+ Eliminando el 2:  3 + 1  + 77 + 8  =  89
+ Eliminando el 3: 2  + 12 + 77 + 82 = 173
+ Eliminando el 7: 23 + 12      + 82 = 117
+ Eliminando el 8: 23 + 12 + 77 +  2 = 114

El mínimo de las sumas es 89 (que se obtiene eliminando todas las ocurrencias del dígito 2).

Definir la función

   minimaSumaEliminandoDigito :: [Integer] -> Integer

tal que (minimaSumaEliminandoDigito xs) es el mínimo de las sumas obtenidas eliminando todas las ocurrencias de uno de los dígitos de xs. Por ejemplo,

   minimaSumaEliminandoDigito [23,12,77,82]  ==  89
   minimaSumaEliminandoDigito [2312,7,4,82]  ==  50

Soluciones

import Data.List ((\\), nub)
 
minimaSumaEliminandoDigito :: [Int] -> Int
minimaSumaEliminandoDigito xs =
  minimum [sumaSinDigito k xs | k <- digitosLista xs]
 
-- (digitosLista xs) es una lista, sin repeticiones, de los dígitos de
-- xs. Por ejemplo,
--    digitosLista [23,12,74,82]  ==  [2,3,1,7,4,8]
digitosLista :: [Int] -> [Int]
digitosLista = nub . concatMap digitos
 
-- (digitos x) es la lista de los dígitos de x. Por ejemplo,
--    digitos 3252  ==  [3,2,5,2]
digitos :: Int -> [Int]
digitos x = [read [c] | c <- show x]
 
-- (sumaSinDigito k xs) es la suma de los números de xs en los que se han
-- borrado todas las ocurrencias del dígito k. Por ejemplo,
--    sumaSinDigito 2 [23,12,22,82]  ==  12
sumaSinDigito :: Int -> [Int] -> Int
sumaSinDigito k xs = sum (listaSinDigito k xs)
 
-- (listaSinDigito k xs) es la lista de los números de xs en los que se han
-- borrado todas las ocurrencias del dígito k. Por ejemplo,
--    listaSinDigito 2 [23,12,22,82]  ==  [3,1,8]
listaSinDigito :: Int -> [Int] -> [Int]
listaSinDigito k xs =
  [read cs | x <- xs
           , let cs = filter (/=c) (show x)
           , not (null cs)]
  where [c] = show k

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>

4 soluciones de “Mínima suma borrando todas las ocurrencias de un dígito

  1. Rubén Muñoz Mkrtchian
    import Data.List ((\))
     
    minimaSumaEliminandoDigito :: [Integer] -> Integer
    minimaSumaEliminandoDigito xs = minimum [sum (eliminaDigitoLista k xs) | k <- [0..9]]
     
    -- eliminaDigitoLista k xs elimina el dígito k de cada elemento de la lista xs.
     
    eliminaDigitoLista :: Integer -> [Integer] -> [Integer]
    eliminaDigitoLista k xs = map (eliminaDigito k) xs
     
    -- eliminaDigito k n elimina el dígito k del número n.
     
    eliminaDigito :: Integer -> Integer -> Integer
    eliminaDigito k n = aux (fromIntegral (length a - 1)) a
      where a = b \ replicate (length b) k
            b = digitos n
     
    -- aux k xs transforma la lista xs en un número entero.
     
    aux :: Integer -> [Integer] -> Integer
    aux k [] = 0
    aux k (x:xs) = x * 10^k + aux (k-1) xs
     
    -- digitos n es la lista formada por los dígitos de n.
     
    digitos :: Integer -> [Integer]
    digitos n = [read [x] | x <- show n]
  2. Juan María Jiménez Jiménez
     
    import Data.List
     
    digitos :: Integer -> [Integer]
    digitos n = [ read [c] | c <- show n]
     
    -- eliminaOcurrencia es una funcion que elimina las ocurrencias de un digito "o" , en un numero n.
     
    eliminaOcurrencia :: Integer -> Integer -> Integer
    eliminaOcurrencia _ 0 = 0
    eliminaOcurrencia o n | aux == [] = 0
                          | otherwise = read (aux)
      where aux = (concat (map (show) (filter (/= o) (digitos n))))
     
    --listasSinOcurrencias de una lista xs nos devuelve todas las combinaciones posibles eliminando una ocurrencia de cada uno de los numeros que la componen:
    -- λ> listasSinOcurrencias [23,12,77,82]
    -- [[3,1,77,8],[2,12,77,82],[23,2,77,82],[23,12,0,82],[23,12,77,2]]
     
    listasSinOcurrencias :: [Integer] -> [[Integer]]
    listasSinOcurrencias xs = [ map (eliminaOcurrencia n) xs | n<-ns]
      where ns = nub (concat (map (digitos) xs))
     
    minimaSumaEliminandoDigito :: [Integer] -> Integer
    minimaSumaEliminandoDigito xs = minimum (map (sum) (listasSinOcurrencias xs))
  3. Joaquín Infante Rodríguez
     
    import Data.List
     
     
    digitos :: Integer -> [Integer]
    digitos n = [read [x] | x<-show n]
     
    digitosLista :: [Integer] -> [Integer]
    digitosLista [] = []
    digitosLista (x:xs) = nub (sort (digitos x ++ digitosLista xs))
     
    listaNumeroC :: [Integer] -> Integer
    listaNumeroC xs = sum [x*10^y | (x,y)<- zip xs [y | y<-reverse [0..genericLength xs-1]]]
     
    eliminandoDigito :: Integer -> [Integer] -> [Integer]
    eliminandoDigito n [] = []
    eliminandoDigito n (x:xs) | elem n (digitos x) = (listaNumeroC ((digitos x) \ (intersect (digitos x) [n]))) : (eliminandoDigito n xs)
                              | otherwise          = x : eliminandoDigito n xs
     
    sumaEliminandoDigito :: Integer -> [Integer] -> Integer
    sumaEliminandoDigito n xs = sum (eliminandoDigito n xs)
     
    sumasEliminandoDigito :: [Integer] -> [Integer]
    sumasEliminandoDigito []     = []
    sumasEliminandoDigito [x]    = [x]
    sumasEliminandoDigito xs     = [sumaEliminandoDigito n xs | n<-digitosLista xs]
     
     
    minimaSumaEliminandoDigito :: [Integer] -> Integer
    minimaSumaEliminandoDigito xs = minimum (sumasEliminandoDigito xs)
  4. Mercedes Vega Gallo
    import Data.List
     
    minimaSumaEliminandoDigito :: [Integer] -> Integer
    minimaSumaEliminandoDigito xs = minimum [eliminar k xs|k<-(lista xs)] 
     
     
    -- La función "numlista x" nos devuelve una lista formada por los dígitos del
    -- número en el orden en que aparecen.
    numlista :: Integer -> [Integer]
    numlista 0 = []
    numlista x =  numlista (div x 10)++ [mod x 10]
     
    -- La función "contiene k x" se verifica si el número x contiene el dígito k.
    contiene :: Integer -> Integer -> Bool
    contiene k x = elem k (numlista x)
     
    -- La función "elimino k x" nos devuelve una lista formada por los dígitos de x
    -- distintos de k en el orden en que aparecen.                      
    elimino :: Integer-> Integer -> [Integer]
    elimino k x = filter (/=k) (numlista x)
     
    -- La función "origen xs" transforma la lista xs en un número.
    origen :: [Integer] -> Integer
    origen xs = sum [a*b |(a,b)<-zip (reverse xs)  (map (10^) [0..])]
     
    -- La función "eliminar k xs" nos devuelve el resultado de sumar todos los
    -- elementos de la lista eliminando k.
    eliminar :: Integer -> [Integer] -> Integer
    eliminar k xs = sum (map p xs)
                   where p a|contiene k a = origen (elimino k a)
                            |otherwise = a
     
    -- La función "lista xs" nos devuelve una lista de los números (una sola cifra)
    -- que aparecen en xs por orden.
    lista :: [Integer] -> [Integer]
    lista xs = sort (nub (concat (map (numlista) xs)))

Leave a Reply

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