Notación polaca inversa

6 Comentarios

1. Haskell

   valor :: String -> Float valor cs = head $ valorAux [] (words cs) where valorAux :: [Float] -> [String] -> [Float] valorAux xs (y:ys) | y `elem` ["+","*","/","-"] = valorAux (opera y (take 2 xs) : (drop 2 xs)) ys | otherwise = valorAux (read y : xs) ys valorAux xs [] = xs opera :: String -> [Float] -> Float opera "+" (y:x:xs) = x + y opera "*" (y:x:xs) = x * y opera "-" (y:x:xs) = x - y opera "/" (y:x:xs) = x / y

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   valor :: String -> Float valor cs = head $ valorAux [] (words cs)   where     valorAux :: [Float] -> [String] -> [Float]     valorAux xs (y:ys)       | y `elem` ["+","*","/","-"] =            valorAux (opera y (take 2 xs) : (drop 2 xs)) ys       | otherwise = valorAux (read y : xs) ys     valorAux xs [] = xs   opera :: String -> [Float] -> Float opera "+" (y:x:xs) = x + y opera "*" (y:x:xs) = x * y opera "-" (y:x:xs) = x - y opera "/" (y:x:xs) = x / y

   Responder

2. Haskell

   import Data.Char valor :: String -> Float valor = rpn [] where rpn :: [Float] -> String -> Float rpn xs ys | null ys = head xs | isDigit y = rpn (read ns: xs) ts | otherwise = rpn (op y a b: ms) ts where (y:_) = ys (ns,rs) = span (not.isSpace) ys ts = dropWhile isSpace rs (a:b:ms) = xs op :: Char -> Float -> Float -> Float op '+' a b = b + a op '-' a b = b - a op '*' a b = b * a op '/' a b = b / a

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   import Data.Char   valor :: String -> Float valor = rpn []   where rpn :: [Float] -> String -> Float         rpn xs ys | null ys   = head xs                   | isDigit y = rpn (read ns: xs) ts                   | otherwise = rpn (op y a b: ms) ts           where (y:_)    = ys                 (ns,rs)  = span (not.isSpace) ys                 ts       = dropWhile isSpace rs                 (a:b:ms) = xs         op :: Char -> Float -> Float -> Float                     op '+' a b = b + a         op '-' a b = b - a         op '*' a b = b * a         op '/' a b = b / a

   Responder

3. Haskell

   valor :: String -> Float valor cs = aux [] cs 0 0 aux :: [Float] -> String -> Float -> Float -> Float aux v [] a t = head v aux [] [x] a t = rN x aux v (x:xs) a t | x == ' ' && t == 0 = aux (a:v) xs 0 0 | x == ' ' = aux v xs 0 0 | isInt x = aux v xs (10*a + rN x) 0 | otherwise = aux (rOp x (head v) (head $ tail v): tail (tail v)) xs 0 1 isInt :: Char -> Bool isInt x = x `elem` "0123456789" rOp :: Char -> Float -> Float -> Float rOp x b c | x == '+' = b+c | x == '-' = c-b | x == '*' = b*c | otherwise = c/b

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   valor :: String -> Float valor cs = aux [] cs 0 0   aux :: [Float] -> String -> Float -> Float -> Float aux v [] a t = head v aux [] [x] a t = rN x aux v (x:xs) a t   | x == ' ' && t == 0 = aux (a:v) xs 0 0   | x == ' ' = aux v xs 0 0   | isInt x = aux v xs (10*a + rN x) 0   | otherwise = aux (rOp x (head v) (head $ tail v): tail (tail v)) xs 0 1   isInt :: Char -> Bool isInt x = x `elem` "0123456789"   rOp :: Char -> Float -> Float -> Float rOp x b c | x == '+'  = b+c           | x == '-'  = c-b           | x == '*'  = b*c           | otherwise = c/b

   Responder

4. Haskell

   import Data.Char (isDigit) valor :: String -> Float valor cs = rpn (words cs) [] where rpn [] ss = head ss rpn (x:xs) ss | (isDigit.head) x = rpn xs (read x:ss) | otherwise = rpn xs (apply (op x) ss) data Op a = Inv | Unary (a -> a) | Binary (a -> a -> a) apply :: Op a -> [a] -> [a] apply Inv (x:y:xs) = y : x : xs apply (Unary f) (x:xs) = f x : xs apply (Binary f) (x:y:xs) = f y x : xs apply _ _ = error "Stack empty" op :: String -> Op Float op "+" = Binary (+) op "-" = Binary (-) op "*" = Binary (*) op "/" = Binary (/) op "neg" = Unary negate op "!" = Unary (\x -> product [1..x]) op "inv" = Inv op "del" = Binary const op o = error ("Operación no reconocida: " ++ o)

   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

   import Data.Char (isDigit)   valor :: String -> Float valor cs = rpn (words cs) []   where rpn [] ss = head ss         rpn (x:xs) ss | (isDigit.head) x  = rpn xs (read x:ss)                       | otherwise         = rpn xs (apply (op x) ss)   data Op a = Inv           | Unary (a -> a)           | Binary (a -> a -> a) apply :: Op a -> [a] -> [a] apply Inv (x:y:xs)        = y : x : xs apply (Unary f) (x:xs)    = f x : xs apply (Binary f) (x:y:xs) = f y x : xs apply _ _ = error "Stack empty" op :: String -> Op Float op "+"    = Binary (+) op "-"    = Binary (-) op "*"    = Binary (*) op "/"    = Binary (/) op "neg"  = Unary negate op "!"    = Unary (\x -> product [1..x]) op "inv"  = Inv op "del"  = Binary const op o      = error ("Operación no reconocida: " ++ o)

   Responder

5. Haskell

   valor :: String -> Float valor cs = aux [] cs 0 0 where aux v [] a t = head v aux [] [x] a t = rN x aux v (x:xs) a t | x == ' ' && t == 0 = aux (a:v) xs 0 0 | x == ' ' = aux v xs 0 0 | isInt x = aux v xs (10*a + rN x) 0 | otherwise = aux ((rOp x (head v) (head $ tail v)):(tail $ tail v)) xs 0 1 isInt x = elem x "0123456789" rOp x b c | x == '+' = b+c | x == '-' = c-b | x == '*' = b*c | otherwise = c/b rN x = fst $ head [ (a,b) | (a,b) <- zip [0..9] "0123456789", x == b]

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   valor :: String -> Float valor cs = aux [] cs 0 0   where aux v [] a t = head v         aux [] [x] a t = rN x         aux v (x:xs) a t           | x == ' ' && t == 0 = aux (a:v) xs 0 0           | x == ' ' = aux v xs 0 0           | isInt x = aux v xs (10*a + rN x) 0           | otherwise = aux ((rOp x (head v) (head $ tail v)):(tail $ tail v)) xs 0 1         isInt x = elem x "0123456789"         rOp x b c           | x == '+' = b+c           | x == '-' = c-b           | x == '*' = b*c           | otherwise = c/b         rN x = fst $ head [ (a,b) | (a,b) <- zip [0..9] "0123456789", x == b]

   Responder

6. Haskell

   valor :: String -> Float valor = auxv [] where auxv [n] "" = n auxv (n:m:ns) ('+':cs) = auxv (m+n:ns) cs auxv (n:m:ns) ('-':cs) = auxv (m-n:ns) cs auxv (n:m:ns) ('*':cs) = auxv (m*n:ns) cs auxv (n:m:ns) ('/':cs) = auxv (m/n:ns) cs auxv ns (c:cs) | isDigit c = auxv (read (takeWhile isDigit (c:cs)):ns) (dropWhile isDigit (c:cs)) | otherwise = auxv ns cs

   1 2 3 4 5 6 7 8 9 10 11 12

   valor :: String -> Float valor = auxv []   where     auxv [n]      ""       = n     auxv (n:m:ns) ('+':cs) = auxv (m+n:ns) cs     auxv (n:m:ns) ('-':cs) = auxv (m-n:ns) cs     auxv (n:m:ns) ('*':cs) = auxv (m*n:ns) cs     auxv (n:m:ns) ('/':cs) = auxv (m/n:ns) cs     auxv ns (c:cs)       | isDigit c = auxv (read (takeWhile isDigit (c:cs)):ns)                          (dropWhile isDigit (c:cs))       | otherwise = auxv ns cs

   Responder