Número de viajeros en el autobús

Un autobús inicia su recorrido con 0 viajeros. El número de viajeros que se suben y bajan en cada parada se representa por un par (x,y) donde x es el número de las que suben e y el de las que bajan. Un recorrido del autobús se representa por una lista de pares representando los números de viajeros que suben o bajan en cada parada.

Definir la función

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

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

tal que (nViajerosEnBus ps) es el número de viajeros en el autobús tras el recorrido ps. Por ejemplo,

  nViajerosEnBus []                                        ==  0
  nViajerosEnBus [(10,0),(3,5),(5,8)]                      ==  5
  nViajerosEnBus [(3,0),(9,1),(4,10),(12,2),(6,1),(7,10)]  ==  17
  nViajerosEnBus [(3,0),(9,1),(4,8),(12,2),(6,1),(7,8)]    ==  21

nViajerosEnBus [] == 0

nViajerosEnBus [(10,0),(3,5),(5,8)] == 5

nViajerosEnBus [(3,0),(9,1),(4,10),(12,2),(6,1),(7,10)] == 17

nViajerosEnBus [(3,0),(9,1),(4,8),(12,2),(6,1),(7,8)] == 21

Soluciones

import Data.List (foldl')

-- 1ª solución (por comprensión)
nViajerosEnBus1 :: [(Int, Int)] -> Int
nViajerosEnBus1 ps = sum [a - b | (a,b) <- ps]

-- 2ª solucioń (por recursión)
nViajerosEnBus2 :: [(Int, Int)] -> Int
nViajerosEnBus2 []         = 0
nViajerosEnBus2 ((a,b):ps) = a - b + nViajerosEnBus2 ps

-- 3ª solución (por recursión con acumulador)
nViajerosEnBus3 :: [(Int, Int)] -> Int
nViajerosEnBus3 = aux 0
  where aux n []         = n
        aux n ((a,b):xs) = aux (n+a-b) xs

-- 4ª solución (por plegado por la derecha):
nViajerosEnBus4 :: [(Int, Int)] -> Int
nViajerosEnBus4 = foldr (\(a,b) n -> a-b+n) 0

-- 5ª solución (por plegado por la derecha):
nViajerosEnBus5 :: [(Int, Int)] -> Int
nViajerosEnBus5 = foldl' (\n (a,b) -> a-b+n) 0

-- 6ª solución (con map)
nViajerosEnBus6 :: [(Int, Int)] -> Int
nViajerosEnBus6 xs = sum (map (\(x,y) -> x-y) xs)

-- 7ª solución (por composición y sin argumentos) 
nViajerosEnBus7 :: [(Int, Int)] -> Int
nViajerosEnBus7 = sum . map (uncurry (-))

import Data.List (foldl')

-- 1ª solución (por comprensión)

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

nViajerosEnBus1 ps = sum [a - b | (a,b) <- ps]

-- 2ª solucioń (por recursión)

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

nViajerosEnBus2 [] = 0

nViajerosEnBus2 ((a,b):ps) = a - b + nViajerosEnBus2 ps

-- 3ª solución (por recursión con acumulador)

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

nViajerosEnBus3 = aux 0

where aux n [] = n

aux n ((a,b):xs) = aux (n+a-b) xs

-- 4ª solución (por plegado por la derecha):

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

nViajerosEnBus4 = foldr (\(a,b) n -> a-b+n) 0

-- 5ª solución (por plegado por la derecha):

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

nViajerosEnBus5 = foldl' (\n (a,b) -> a-b+n) 0

-- 6ª solución (con map)

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

nViajerosEnBus6 xs = sum (map (\(x,y) -> x-y) xs)

-- 7ª solución (por composición y sin argumentos)

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

nViajerosEnBus7 = sum . map (uncurry (-))

8 Comentarios

nViajerosEnBus :: [(Int, Int)] -> Int
nViajerosEnBus ps = sum (map fst ps) - sum (map snd ps)

1 2	nViajerosEnBus :: [(Int, Int)] -> Int nViajerosEnBus ps = sum (map fst ps) - sum (map snd ps)

Responder

nViajerosEnBus :: [(Int, Int)] -> Int
nViajerosEnBus ps = sum [x-y | (x,y) <- ps]

1 2	nViajerosEnBus :: [(Int, Int)] -> Int nViajerosEnBus ps = sum [x-y \| (x,y) <- ps]

Responder

import Data.List (foldl’)

nViajerosEnBus :: [(Int,Int)] -> Int
nViajerosEnBus = foldl’ f 0
  where f a (c,d) = a + c - d

import Data.List (foldl’)

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

nViajerosEnBus = foldl’ f 0

where f a (c,d) = a + c - d

Responder

Asignarle su tipo a la función auxiliar f consigue una mejora en la eficiencia tal que así:

import Data.List (foldl')

nViajerosEnBus :: [(Int,Int)] -> Int
nViajerosEnBus = foldl' f 0
  where f :: Int -> (Int,Int) -> Int
        f a (c,d) = a + c - d

-- Comparación de la eficiencia
-- λ> nViajerosEnBus $ replicate (10^7) (2,1)
-- 10000000
-- (7.16 secs, 1,920,118,520 bytes)
-- λ> nViajerosEnBus2 $ replicate (10^7) (2,1)
-- 10000000
-- (7.52 secs, 2,080,117,512 bytes)

import Data.List (foldl')

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

nViajerosEnBus = foldl' f 0

where f :: Int -> (Int,Int) -> Int

f a (c,d) = a + c - d

-- Comparación de la eficiencia

-- λ> nViajerosEnBus $ replicate (10^7) (2,1)

-- 10000000

-- (7.16 secs, 1,920,118,520 bytes)

-- λ> nViajerosEnBus2 $ replicate (10^7) (2,1)

-- 10000000

-- (7.52 secs, 2,080,117,512 bytes)

Responder

nViajerosEnBus :: [(Int,Int)] -> Int
nViajerosEnBus xs = (sum . fst) x - (sum . snd) x
  where x = unzip xs

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

nViajerosEnBus xs = (sum . fst) x - (sum . snd) x

where x = unzip xs

Responder

nViajerosEnBus :: [(Int, Int)] -> Int
nViajerosEnBus []     = 0
nViajerosEnBus (x:xs) = (fst x - snd x) + nViajerosEnBus xs

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

nViajerosEnBus [] = 0

nViajerosEnBus (x:xs) = (fst x - snd x) + nViajerosEnBus xs

Responder

nViajerosEnBus :: [(Int, Int)] -> Int
nViajerosEnBus []         = 0
nViajerosEnBus ((a,b):ps) = a - b + nViajerosEnBus ps

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

nViajerosEnBus [] = 0

nViajerosEnBus ((a,b):ps) = a - b + nViajerosEnBus ps

Responder

nViajerosEnBus :: [(Int, Int)] -> Int
nViajerosEnBus = sum . map (uncurry (-))

1 2	nViajerosEnBus :: [(Int, Int)] -> Int nViajerosEnBus = sum . map (uncurry (-))

Responder

Número de viajeros en el autobús

Soluciones

8 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

8 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico