Menu Close

Recorrido del robot

Los puntos de una retícula se representan mediante pares de enteros

   type Punto = (Int,Int)

y los movimientos de un robot mediante el tipo

   data Movimiento = N Int
                   | S Int
                   | E Int
                   | O Int

donde (N x) significa que se mueve x unidades en la dirección norte y análogamente para las restantes direcciones (S es sur, E es este y O es oeste).

Definir la función

   posicion :: [Movimiento] -> Punto

tal que (posicion ms) es la posición final de un robot que inicialmente está en el el punto (0,0) y realiza los movimientos ms. Por ejemplo,

   posicion [N 3]                           ==  (0,3)
   posicion [N 3, E 5]                      ==  (5,3)
   posicion [N 3, E 5, S 1]                 ==  (5,2)
   posicion [N 3, E 5, S 1, O 4]            ==  (1,2)
   posicion [N 3, E 5, S 1, O 4, N 3]       ==  (1,5)
   posicion [N 3, E 5, S 1, O 4, N 3, S 3]  ==  (1,2)

Soluciones

type Punto = (Int,Int)
 
data Movimiento = N Int
                | S Int
                | E Int
                | O Int
 
-- 1ª solución                
posicion :: [Movimiento] -> Punto
posicion ms = aux ms (0,0)
  where aux [] p = p
        aux (N x:ms) (a,b) = aux ms (a,b+x)
        aux (S x:ms) (a,b) = aux ms (a,b-x)
        aux (E x:ms) (a,b) = aux ms (a+x,b)
        aux (O x:ms) (a,b) = aux ms (a-x,b)
 
-- 2ª solución
posicion2 :: [Movimiento] -> Punto
posicion2 []       = (0,0)
posicion2 (N x:ms) = suma (0 ,x)  (posicion2 ms)
posicion2 (S x:ms) = suma (0 ,-x) (posicion2 ms)
posicion2 (E x:ms) = suma (x ,0)  (posicion2 ms)
posicion2 (O x:ms) = suma (-x,0)  (posicion2 ms)
 
suma :: Punto -> Punto -> Punto
suma (x,y) (a,b) = (x+a,y+b)
 
-- 3ª solución
posicion3 :: [Movimiento] -> Punto
posicion3 []     = (0,0)
posicion3 (m:ms) = case m of
                     N x -> (a,b+x)
                     S x -> (a,b-x)
                     E x -> (a+x,b)
                     O x -> (a-x,b)
  where (a,b) = posicion3 ms
 
-- 4ª solución
posicion4 :: [Movimiento] -> Punto
posicion4 = foldl aux (0,0)
  where
    aux (x,y) (N j) = (x,y+j)
    aux (x,y) (S j) = (x,y-j)
    aux (x,y) (E i) = (x+i,y)
    aux (x,y) (O i) = (x-i,y)
 
--- 5ª solución
posicion5 :: [Movimiento] -> Punto
posicion5 xs = (sum hs, sum vs)
  where
    (hs,vs)   = unzip (map aux xs)
    aux (N j) = (0,j)
    aux (S j) = (0,-j)
    aux (E i) = (i,0)
    aux (O i) = (-i,0)

7 soluciones de “Recorrido del robot

  1. alerodrod5
    type Punto = (Int,Int)
     
    data Movimiento = N Int
                    | S Int
                    | E Int
                    | O Int
     
    posicion :: [Movimiento] -> Punto
    posicion []     = (0,0)
    posicion [N x]  = (0,x)
    posicion [S x]  = (0,-x)
    posicion [E x]  = (x,0)
    posicion [O x]  = (-x,0)
    posicion (x:xs) = suma (posicion [x]) (posicion xs)
      where suma (x,y) (a,b) = (x+a,y+b)
  2. jaibengue
    type Punto = (Int,Int)
     
    data Movimiento = N Int
                    | S Int
                    | E Int
                    | O Int
     
    (+-+) :: Punto -> Punto  -> Punto
    (+-+) (a,b) (c,d) = (a+c,b+d)
     
    posicion :: [Movimiento] -> Punto
    posicion []     = (0,0)
    posicion (N d:movs) = (0,d) +-+ posicion movs
    posicion (S d:movs) = (0,-d) +-+ posicion movs
    posicion (E d:movs) = (d,0) +-+ posicion movs
    posicion (O d:movs) = (-d,0) +-+ posicion movs
  3. angruicam1
    import Data.List (foldl')
     
    type Punto = (Int,Int)
     
    data Movimiento = N Int
                    | S Int
                    | E Int
                    | O Int
     
    posicion :: [Movimiento] -> Punto
    posicion =
      foldl' (flip (((a,b) (c,d) -> (a+c,b+d)) . movimiento)) (0,0)
     
    -- (movimiento m) es el punto correspondiente al movimiento m. Por
    -- ejemplo,
    --    movimiento (N 5)  ==  (0,5)
    --    movimiento (S 5)  ==  (0,-5)
    --    movimiento (E 5)  ==  (5,0)
    --    movimiento (O 5)  ==  (-5,0)
    movimiento :: Movimiento -> Punto
    movimiento (N x) = (0,x)
    movimiento (S x) = (0,-x)
    movimiento (E x) = (x,0)
    movimiento (O x) = (-x,0)
  4. jaiturrod
    type Punto = (Int,Int)
     
    data Movimiento = N Int
                    | S Int
                    | E Int
                    | O Int
     
    posicion :: [Movimiento] -> Punto
    posicion xs = (x,y)
      where y = sum [valoresVerticales t | t <- xs]
            x = sum [valoresHorizontales t | t <- xs]
     
    valoresVerticales :: Movimiento -> Int
    valoresVerticales (N x) = x
    valoresVerticales (S x) = -x
    valoresVerticales (E x) = 0
    valoresVerticales (O x) = 0
     
    valoresHorizontales :: Movimiento -> Int
    valoresHorizontales (N x) = 0
    valoresHorizontales (S x) = 0
    valoresHorizontales (E x) = x
    valoresHorizontales (O x) = -x
  5. antnavoro
    posicion :: [Movimiento] -> Punto
    posicion xs = (sum (map f xs), sum (map f' xs))
      where f (E a)  = a
            f (O a)  = -a
            f _      = 0
            f' (N a) = a
            f' (S a) = -a
            f' _     = 0
  6. antgongar
    posicion :: [Movimiento] -> Punto
    posicion []     = (0,0)
    posicion (m:ms) = case m of
                        N x -> (a,b+x)
                        S x -> (a,b-x)
                        E x -> (a+x,b)
                        O x -> (a-x,b)
      where (a,b) = posicion ms
  7. Chema Cortés
    posicion :: [Movimiento] -> Punto
    posicion = foldl aux (0,0)
      where
        aux (x,y) (N j) = (x,y+j)
        aux (x,y) (S j) = (x,y-j)
        aux (x,y) (E i) = (x+i,y)
        aux (x,y) (O i) = (x-i,y)
     
     
    posicion2 :: [Movimiento] -> Punto
    posicion2 xs = let (hs,vs) = unzip (map aux xs)
                   in (sum hs, sum vs)
      where
        aux (N j) = (0,j)
        aux (S j) = (0,-j)
        aux (E i) = (i,0)
        aux (O i) = (-i,0)

Escribe tu solución

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