0votos

costo bus en Haskell

por josejuan hace 3 años

Para cualquier nº de autobuses y trayectos, permitiendo diversos parámetros y calculando el reparto óptimo entre autobuses y trayectos para minimizar el precio total, por persona, ...

desarrollar en java, teniendo en cuenta los sistemas condicionales simples y compuestos. por favor ligero que son para el dia 10 de Mayo. :)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
{-# LANGUAGE RecordWildCards #-} 
 
import Data.List 
import Data.Function 
 
data Autobús = Autobús { autobús_nombre             :: String 
                       , precio_por_persona_y_km    :: Double 
                       , mínimo_personas            :: Int } deriving (Eq, Ord) 
instance Show Autobús where show = autobús_nombre 
 
data Trayecto = Trayecto { trayecto_nombre          :: String 
                         , kilómetros               :: Double 
                         , personas                 :: Int } deriving (Eq, Ord) 
instance Show Trayecto where show = trayecto_nombre 
 
-- Dado un autobús y un trayecto calcula el importe total del mismo 
importe_autobús_trayecto :: Autobús -> Trayecto -> Double 
importe_autobús_trayecto (Autobús {..}) (Trayecto {..}) = precio_por_persona_y_km * kilómetros * fromIntegral (max personas mínimo_personas) 
 
-- Dado un autobús y un trayecto calcula el importe por persona 
importe_por_persona :: Autobús -> Trayecto -> Double 
importe_por_persona a t@(Trayecto {..}) = importe_autobús_trayecto a t / fromIntegral personas 
 
-- Dada una lista de autobuses, una de trayectos y una función a minimizar, obtiene la mejor distribución 
distribuir_para_minimizar :: ([(Autobús, Trayecto)] -> Double) -> [Autobús] -> [Trayecto] -> [(Autobús, Trayecto)] 
distribuir_para_minimizar f xs ys = head $ sortBy (compare `on` f) $ map (`zip` ys) (permutations xs) 
 
-- Dada una lista de autobuses y una de trayectos, obtiene la distribución con menor precio máximo por autobús 
distribuir_para_menor_precio_bus_máximo :: [Autobús] -> [Trayecto] -> [(Autobús, Trayecto)] 
distribuir_para_menor_precio_bus_máximo = distribuir_para_minimizar (maximum . map (uncurry importe_autobús_trayecto)) 
 
-- Dada una lista de autobuses y una de trayectos, obtiene la distribución con menor precio máximo por persona 
distribuir_para_menor_precio_pax_máximo :: [Autobús] -> [Trayecto] -> [(Autobús, Trayecto)] 
distribuir_para_menor_precio_pax_máximo = distribuir_para_minimizar (maximum . map (uncurry importe_por_persona)) 
 
main = do 
 
    let autobuses = [ Autobús "A" 1000 20 
                    , Autobús "B" 2000 20 
                    , Autobús "C" 3000 20 ] 
 
    let trayectos = [ Trayecto "Madrid"     100 55 
                    , Trayecto "Toledo"     150 10 
                    , Trayecto "Salamanca"  200 25 ] 
 
    mapM_ (print . (\(a,t) -> (a,t,importe_por_persona a t))) $ 
        sort $ distribuir_para_menor_precio_pax_máximo autobuses trayectos 
 
{- 
 
(A,Toledo,300000.0) 
(B,Salamanca,400000.0) 
(C,Madrid,300000.0) 
 
-} 

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.