Recorrido del robot

PorJosé A. Alonso 31-enero-20187-febrero-2018

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

   type Punto = (Int,Int)

1	type Punto = (Int,Int)

y los movimientos de un robot mediante el tipo

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

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

1	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)

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)

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 Comentarios

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)

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)

Responder

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

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

Responder

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)

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)

Responder

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

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

Responder

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

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

Responder

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

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

Responder

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)

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)

Responder

Recorrido del robot

Soluciones

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico

Soluciones

Se puede imprimir o compartir con

7 Comentarios

Escribe tu soluciónCancel reply

Entradas recientes

Buscar

Correo electrónico