Mayor resto

PorJosé A. Alonso 26-octubre-20152-noviembre-2015

El resultado de dividir un número n por un divisor d es un cociente q y un resto r.

Definir la función

   mayorResto :: Int -> Int -> (Int,[Int])

1	mayorResto :: Int -> Int -> (Int,[Int])

tal que (mayorResto n d) es el par (m,xs) tal que m es el mayor resto de dividir n entre x (con 1 ≤ x < d) y xs es la lista de números x menores que d tales que el resto de n entre x es m. Por ejemplo,

   mayorResto 20 10  ==  (6,[7])
   mayorResto 50 8   ==  (2,[3,4,6])

1 2	mayorResto 20 10 == (6,[7]) mayorResto 50 8 == (2,[3,4,6])

Nota: Se supone que d es mayor que 1.

Soluciones

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m, [x | x <- [1..d-1], n `rem` x == m])
    where m = maximum [n `rem` x | x <- [1..d-1]]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m, [x | x <- [1..d-1], n `rem` x == m])

where m = maximum [n `rem` x | x <- [1..d-1]]

Referencia

El ejercio está basado en el problema Largest possible remainder publicado el 16 de octubre de 2015 en «Programming paraxis».

19 Comentarios

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = foldr aux (0, []) [1..d-1]
    where aux x (m,xs) | r == m     = (m, x:xs)
                       | r > m      = (r, [x])
                       | otherwise  = (m, xs)
            where r = n `rem` x

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = foldr aux (0, []) [1..d-1]

where aux x (m,xs) | r == m = (m, x:xs)

| r > m = (r, [x])

| otherwise = (m, xs)

where r = n `rem` x

Responder

Para el caso especial de d == 1 esta solución es incorrecta.

La solución corregida:

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = foldr aux (0, [1]) [2..d-1]
    where aux x (m,xs) | r == m     = (m, x:xs)
                       | r > m      = (r, [x])
                       | otherwise  = (m, xs)
            where r = n `rem` x

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = foldr aux (0, [1]) [2..d-1]

where aux x (m,xs) | r == m = (m, x:xs)

| r > m = (r, [x])

| otherwise = (m, xs)

where r = n `rem` x

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [rem n x | x <- [1..d], x /= d]
          xs = [x | x <- [1..d], x /= d, rem n x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [rem n x | x <- [1..d], x /= d]

xs = [x | x <- [1..d], x /= d, rem n x == m]

Responder

Definicion mejorada, modificando el generador y eliminando una condicion ( x /= d )

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [rem n x | x <- [1..d], x /= d]
          xs = [x | x <- [1..(d-1)], rem n x == m]

Definicion mejorada, modificando el generador y eliminando una condicion ( x /= d )

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [rem n x | x <- [1..d], x /= d]

xs = [x | x <- [1..(d-1)], rem n x == m]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [rem n x | x <- [1..d-1], x /= d]
          xs = [x | x <- [1..d-1], rem n x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [rem n x | x <- [1..d-1], x /= d]

xs = [x | x <- [1..d-1], rem n x == m]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n 1 = (0,[1])
mayorResto n d = (m, [x | x <- [1..d], x < d, n `rem` x == m])
    where m = maximum [n `rem` x | x <- [1..d], x < d]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n 1 = (0,[1])

mayorResto n d = (m, [x | x <- [1..d], x < d, n `rem` x == m])

where m = maximum [n `rem` x | x <- [1..d], x < d]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [mod n x | x <- [1..d-1]]
          xs = [x | x <- [1..d-1], mod n x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [mod n x | x <- [1..d-1]]

xs = [x | x <- [1..d-1], mod n x == m]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m, xs)
    where m  = maximum [rem n x | x <- [1..d-1]]
          xs = [x | x <- [1..d-1], rem n x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m, xs)

where m = maximum [rem n x | x <- [1..d-1]]

xs = [x | x <- [1..d-1], rem n x == m]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [mod n x | (n,x) <- zip (repeat n) [1..d-1]]
          xs = [x | x <- [1..d-1], mod n x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [mod n x | (n,x) <- zip (repeat n) [1..d-1]]

xs = [x | x <- [1..d-1], mod n x == m]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (resto n d, dividendos n d)

dividendos n d = [x | x <- [1..d-1] , rem n x == resto n d]

resto n d = maximum (map (rem n) [1..d] )

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (resto n d, dividendos n d)

dividendos n d = [x | x <- [1..d-1] , rem n x == resto n d]

resto n d = maximum (map (rem n) [1..d] )

Responder

Mucho más eficiente al cambiar las variables por constantes cuyas variables coinciden con las de (mayoResto n d), en vez de usar funciones con variables propias.

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (a, b)
    where b = [x | x <- [1..d-1], rem n x == a]
          a = maximum (map (rem n) [1..d-1])

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (a, b)

where b = [x | x <- [1..d-1], rem n x == a]

a = maximum (map (rem n) [1..d-1])

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (resto, [x | x <- [1..d-1], mod n x == resto])
    where resto = maximum [mod n b | b <- [1..d-1]]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (resto, [x | x <- [1..d-1], mod n x == resto])

where resto = maximum [mod n b | b <- [1..d-1]]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [mod n x | x <- [1..d-1]]
          xs = [x | x <- [1..d-1], mod n x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [mod n x | x <- [1..d-1]]

xs = [x | x <- [1..d-1], mod n x == m]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [n `rem` x | x <- [1..d-1]]
          xs = [x | x <- [1..d-1], n `rem` x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [n `rem` x | x <- [1..d-1]]

xs = [x | x <- [1..d-1], n `rem` x == m]

Responder

guache dice:

26-octubre-2015 a las 23:29

Haskell

mayorResto :: Int -> Int -> (Int,[Int]) mayorResto n d = (m,[x | x <- [1..d-1], mod n x == m]) where m = maximum [mod n x | x <- [1..d-1]]

1
2
3

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,[x | x <- [1..d-1], mod n x == m])
where m = maximum [mod n x | x <- [1..d-1]]

Responder

-- Para d > n+1 es obvio que el mayor resto son todos los j > n
-- Si es d > n/2 entonces el máximo se obtiene directamente y es único
--                  cabe la tentación de generalizar a d > n/i con i=2,3,4... para n=50 falla :(
mayorResto n d | d > n + 1        = (n, [n + 1.. d - 1])
               | n == 2 && d == 3 = (0, [1, 2])
               | d > n2           = (n `mod` n2, [n2])
               | otherwise        = otroMayorResto n d
 where n2 = n `div` 2 + 1

-- Para d > n+1 es obvio que el mayor resto son todos los j > n

-- Si es d > n/2 entonces el máximo se obtiene directamente y es único

-- cabe la tentación de generalizar a d > n/i con i=2,3,4... para n=50 falla :(

mayorResto n d | d > n + 1 = (n, [n + 1.. d - 1])

| n == 2 && d == 3 = (0, [1, 2])

| d > n2 = (n `mod` n2, [n2])

| otherwise = otroMayorResto n d

where n2 = n `div` 2 + 1

Responder

josllagam dice:

28-octubre-2015 a las 00:07

Haskell

mayorResto :: Int -> Int -> (Int,[Int]) mayorResto n d = (m,[x| x <- [1..d-1], mod n x == m]) where m = maximum [mod n x| x <- [1..d-1]]

1
2
3

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,[x| x <- [1..d-1], mod n x == m])
where m = maximum [mod n x| x <- [1..d-1]]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = (m,xs)
    where m  = maximum [n `mod` x | x <- [1..d-1]]
          xs = [x | x <- [1..d-1], n `mod` x == m]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d = (m,xs)

where m = maximum [n `mod` x | x <- [1..d-1]]

xs = [x | x <- [1..d-1], n `mod` x == m]

Responder

mayorResto :: Int -> Int -> (Int,[Int])
mayorResto n d = 
    (mayorResto' n d , [x | x <- [1..d-1] , mod n x == mayorResto' n d])
    where mayorResto' n d = maximum [mod n x | x <- [1..d-1]]

mayorResto :: Int -> Int -> (Int,[Int])

mayorResto n d =

(mayorResto' n d , [x | x <- [1..d-1] , mod n x == mayorResto' n d])

where mayorResto' n d = maximum [mod n x | x <- [1..d-1]]

Responder

Mayor resto

Soluciones

Referencia

19 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Referencia

Se puede imprimir o compartir con

19 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico