gettc 1.5 → 1.6

data/core/test/gettc/types_test.rb

@@ -0,0 +1,24 @@
+require "test/unit"
+require "topcoder/types"
+include TopCoder
+
+class TypesTest < Test::Unit::TestCase
+    def test_parse_type
+        assert_raise UnrecognizedType do array = TArray.new 123 end
+        assert_raise UnrecognizedType do type = parse_type "" end
+        assert_raise UnrecognizedType do type = parse_type " " end
+        assert_raise UnrecognizedType do type = parse_type "[]" end       
+        assert_raise UnrecognizedType do type = parse_type "vector" end       
+        assert_raise UnrecognizedType do type = parse_type "vector[]" end       
+        assert_equal TBoolean, parse_type("boolean")
+        assert_equal TInt, parse_type("int")
+        assert_equal TLong, parse_type("long")
+        assert_equal TFloat, parse_type("float")
+        assert_equal TDouble, parse_type("double")
+        assert_equal TChar, parse_type("char")
+        assert_equal TString, parse_type("String")
+        assert_equal TArray.new(TBoolean), parse_type("boolean[]")
+        assert_equal TArray.new(TInt), parse_type("int[]")
+        assert_equal TArray.new(TArray.new(TString)), parse_type("String[][]")
+    end
+end

data/dist/config.yml

@@ -1,2 +1,3 @@
 username: gettc
 password: algorithm
+version: 1.6

data/dist/include/cpp/engine.rb

@@ -1,58 +1,58 @@
-require 'topcoder/types' 
+require "gettc/types"
 
-module TopCoder
+module Gettc
     class Type
         def to_cpp
             if self == TInt then
-                return 'int'
+                return "int"
             elsif self == TLong then
-                return 'int64'        
+                return "int64"        
             elsif self == TFloat then
-                return 'float'
+                return "float"
             elsif self == TDouble then
-                return 'double'
+                return "double"
             elsif self == TChar then
-                return 'char'
+                return "char"
             elsif self == TString then
-                return 'string'
+                return "string"
             elsif self == TBoolean then
-                return 'bool'
+                return "bool"
             elsif is_a? TArray then
-                ret = 'vector<' << subtype.to_cpp
-                ret << ' ' if subtype.is_a? TArray
-                ret << '>'
+                ret = "vector<" << subtype.to_cpp
+                ret << " " if subtype.is_a? TArray
+                ret << ">"
                 return ret
             else
-                return 'unknown'
+                return "unknown"
             end 
         end
         def dumb_cpp
             if self == TInt then
-                return '0'
+                return "0"
             elsif self == TLong then
-                return '0'        
+                return "0"        
             elsif self == TFloat then
-                return '0'
+                return "0"
             elsif self == TDouble then
-                return '0'
+                return "0"
             elsif self == TChar then
-                return "'$'"
+                return "\"$\""
             elsif self == TString then
-                return '"$"'
+                return "\"$\""
             elsif self == TBoolean then
-                return 'true'
+                return "true"
             elsif is_a? TArray then
                 return "#{to_cpp}()"
             else
-                return 'Nil'
+                return "Nil"
             end
         end
     end
     class Signature
         def to_cpp declaring = false
             ret = type.to_cpp
-            ret << ' '
-            ret << 'const &' if declaring and type.obj?
+            ret << " "
+            ret << "const &" if declaring and type.obj?
             ret << name 
             return ret
         end
@@ -64,27 +64,27 @@ module TopCoder
             @vars = vars            
         end
         def declare
-            ret = @func.to_cpp
-            ret << '('
-                indent = ' ' * ret.size
+            ret = "    " + @func.to_cpp
+            ret << "("
+                indent = " " * ret.size
                 temp = @vars.map do |var| var.to_cpp true end
                 ret << temp.join(",\n#{indent}")
-            ret << ')'
+            ret << ")"
             return ret
         end
         def input
             temp = @vars.map do |var|
                 x = var.to_cpp
-                x << '; read(ifs, '
+                x << "; tc::read(ifs, "
                 x << var.name
-                x << ');'
+                x << ");"
             end
-            return temp.join " next(ifs);\n"
+            return temp.join " tc::next(ifs);\n"
         end
         def output
-            ret = 'show(ofs, ' << @func.name << '('
+            ret = "tc::show(ofs, solver." << @func.name << "("
             temp = @vars.map do |var| var.name end
-            ret << temp.join(', ') << '));'
+            ret << temp.join(", ") << "));"
         end
     end
 end

data/dist/include/cpp/topcoder

@@ -14,8 +14,7 @@ typedef unsigned int uint;
 typedef long long int64;
 typedef unsigned long long uint64;
     
-namespace TopCoder
-{
+namespace TopCoder {
     const int _CHUNK_SIZE = 65536;
 
     class ParseException: public std::exception {
@@ -28,27 +27,34 @@ namespace TopCoder
             oss << " (got '" << actual << "')";
             message = oss.str();
         }
+
     public:
         ParseException() : message("ParseException occurred") {}
         ParseException(std::string const &message) : message(message) {}
         ~ParseException() throw () {}
-        virtual const char* what() const throw() { return message.c_str(); }
+
+        virtual const char* what() const throw() { 
+            return message.c_str(); 
+        }
 
         ParseException(std::string const &required, char actual, 
                        std::string const &rest) { 
             buildMessage(required, actual, rest);
         }
+
         ParseException(char expected, char actual, 
                        std::string const &rest) { 
             std::ostringstream oss;
             oss << "Expect '" << expected << "'";
             buildMessage(oss.str(), actual, rest);
         }
+
         ParseException(std::string const &required, std::string const &rest) {
             std::ostringstream oss;
             oss << required << " at: <" << rest << ">";
             message = oss.str();
         }
+
         ParseException(char expected) {
             std::ostringstream oss;
             oss << "Expect '" << expected << " before end of stream";
@@ -65,6 +71,7 @@ namespace TopCoder
         } 
         return oss.str();
     }
+
     void _spaces(std::istream &is) {
         while (is.good()) {
             int i = is.peek();
@@ -72,43 +79,69 @@ namespace TopCoder
             else break;
         } 
     } 
+
     void _expect(std::istream &is, char expected) {
         _spaces(is); char actual = is.peek();
         if (expected != actual) 
             throw ParseException(expected, actual, _rest(is));
         is.ignore(1);
     }
+
     void next(std::istream &is) {
         _expect(is, ',');
     } 
 
-    void read(std::istream &is, int &i) { is >> i; }
-    void read(std::istream &is, int64 &l) { is >> l; }
-    void read(std::istream &is, float &f) { is >> f; }
-    void read(std::istream &is, double &d) { is >> d; }
+    void read(std::istream &is, int &i) { 
+        is >> i; 
+    }
+
+    void read(std::istream &is, int64 &l) { 
+        is >> l; 
+    }
+
+    void read(std::istream &is, float &f) { 
+        is >> f; 
+    }
+
+    void read(std::istream &is, double &d) { 
+        is >> d; 
+    }
+
     void read(std::istream &is, char &c) {
         _expect(is, '\'');
         is.get(c);
-        if (c == '\'') c = 0;
-                  else _expect(is, '\'');
+        if (c == '\'') {
+            c = 0;
+        } else {
+            _expect(is, '\'');
+        }
     }
+
     void read(std::istream &is, std::string &s) {
         _expect(is, '"');
         std::ostringstream oss;    
         while (is.good()) {
             char c; is.get(c);
-            if (c == '\\') {
+            if (c == '"') {
+                std::streampos pos = is.tellg();
+                _spaces(is);
+                if (is.eof()) {
+                    s = oss.str();
+                    return;
+                }
                 char cc; is.get(cc);
-                oss << cc;
-            } 
-            else if (c == '"') {
-                s = oss.str();
-                return;
+                if (cc == ',' || cc == ']') {
+                    s = oss.str();
+                    is.unget();
+                    return;
+                }
+                is.seekg(pos);
             }
-            else oss << c;
+            oss << c;
         }
         throw ParseException('"');
     }
+
     void read(std::istream &is, bool &b) { 
         _spaces(is);
         std::ostringstream oss;
@@ -130,6 +163,7 @@ namespace TopCoder
             throw ParseException("Expect a boolean value (true or false)", _rest(is));
         }
     }
+
     template <typename T>
     void read(std::istream &is, std::vector<T> &v) {
         v.clear();
@@ -143,59 +177,89 @@ namespace TopCoder
         while (is.good()) { 
             T e; read(is, e); v.push_back(e);
             _spaces(is); char c; is.get(c);
-            if (c == ']') return;
-            if (c != ',') 
+            if (c == ']') {
+                return;
+            }
+            if (c != ',') {
                 throw ParseException("Expect ',' or ']'", c, _rest(is));
+            }
         } 
         throw ParseException(']');
     } 
 
-    void show(std::ostream &os, int i) { os << i; }
-    void show(std::ostream &os, int64 l) { os << l; }
+    void show(std::ostream &os, int i) { 
+        os << i; 
+    }
+
+    void show(std::ostream &os, int64 l) { 
+        os << l; 
+    }
+
     void show(std::ostream &os, float f) {
         os.precision(8);
         os << f; 
     }
+
     void show(std::ostream &os, double d) {
         os.precision(16);
         os << d; 
     }
+
     void show(std::ostream &os, char c) {
         os << '\'' << c << '\'';
     }
+
     void show(std::ostream &os, std::string const &s) {
         os << '"' << s << '"';
     }
+
     void show(std::ostream &os, bool b) {
         os << (b ? "true" : "false");
     }
+
     template <typename T>
     void show(std::ostream &os, std::vector<T> const &v) {
         typedef typename std::vector<T>::const_iterator Iterator;
         bool first = true;
         os << '[';
         for (Iterator it = v.begin(); it != v.end(); ++it) {            
-            if (!first) os << ',';
+            if (!first) {
+                os << ',';
+            }
             show(os, *it);
             first = false;
         }
         os << ']';
     }
 
-    bool same(int i, int j) { return i == j; }
-    bool same(int64 i, int64 j) { return i == j; }
-    bool same(char i, char j) { return i == j; }
-    bool same(std::string const &x, std::string const &y) { return x == y; }
+    bool same(int i, int j) { 
+        return i == j; 
+    }
+
+    bool same(int64 i, int64 j) { 
+        return i == j; 
+    }
+
+    bool same(char i, char j) { 
+        return i == j; 
+    }
+
+    bool same(std::string const &x, std::string const &y) { 
+        return x == y; 
+    }
+
     bool same(float x, float y) {
         float p = x * (1.0 - 1e-5);
         float q = x * (1.0 + 1e-5);
         return y >= std::min(p, q) && y <= std::max(p, q);
     }
+
     bool same(double x, double y) {
         double p = x * (1.0 - 1e-9);
         double q = x * (1.0 + 1e-9);
         return y >= std::min(p, q) && y <= std::max(p, q);
     } 
+
     template <typename T>
     bool same(std::vector<T> const &v1, std::vector<T> const &v2) {
         typedef typename std::vector<T>::const_iterator Iterator;

data/dist/include/haskell/TopCoder.hs

@@ -16,67 +16,86 @@ import Text.Parsec
 import Text.Parsec.String (Parser)
 import Text.Parsec.Token
 import Data.Char
+import Data.Maybe
+
 
 next :: Parser ()
-next = do char ','
-          return ()
+next = do 
+    char ','
+    return ()
 
-parseChar :: Parser Char
-parseChar = do char '\''
-               ret <- anyChar
-               char '\''
-               return ret
 
-parseString :: Parser String
-parseString = do char '\"'
-                 ret <- many1 (noneOf "\"")
-                 char '\"'
-                 return ret
+parseChar :: Parser Char
+parseChar = do 
+    char '\''
+    ret <- anyChar
+    char '\''
+    return ret
 
 parseBool :: Parser Bool
-parseBool = do s <- many1 letter
-               return ((map toLower s) == "true")
-
-parseInt :: Parser Int
-parseInt = do char '-'
-              n <- parseInt
-              return (-n)
-       <|> do cs <- many1 digit
-              return (read cs)
- 
-parseLong :: Parser Integer
-parseLong = do char '-'
-               n <- parseLong
-               return (-n)
-        <|> do cs <- many1 digit
-               return (read cs)
-
-parseFloat :: Parser Float
-parseFloat = do char '-'
-                x <- parseFloat
-                return (-x)
-         <|> do cs <- many1 (digit <|> char '.')
-                return (read cs)
-
-parseDouble :: Parser Double
-parseDouble = do char '-'
-                 x <- parseDouble
-                 return (-x)
-          <|> do cs <- many1 (digit <|> char '.')
-                 return (read cs)
+parseBool = do 
+    s <- many1 letter
+    case map toLower s of
+        "true" -> return True
+        "false" -> return False
+        otherwise -> fail "expect true or false"
+
+
+maybeNegative :: Num a => Parser a -> Parser a
+maybeNegative parser = (do
+    char '-'
+    n <- parser
+    return (-n)) <|> parser
+
+parseIntegral :: (Integral a, Read a) => Parser a
+parseIntegral = maybeNegative ((many1 digit) >>= (return . read))
+
+parseInt = parseIntegral :: Parser Int
+parseLong = parseIntegral :: Parser Integer
+
+parseReal :: (RealFloat a, Read a) => Parser a
+parseReal = maybeNegative ((many1 (digit <|> char '.')) >>= (return . read))
+
+parseFloat = parseReal :: Parser Float
+parseDouble = parseReal :: Parser Double
+
+
+
+expect :: Char -> Parser ()
+expect c = do
+    cc <- optionMaybe (char c) 
+    if (isJust cc) 
+        then return ()
+        else fail "disappointing"
+
+parseClosingQuote :: Parser Char
+parseClosingQuote = do 
+    char '"' >> spaces
+    choice [eof, expect ',', expect ']']
+    return '"'
+
+parseString :: Parser String
+parseString = do 
+    char '"'
+    ret <- manyTill anyChar (try (lookAhead parseClosingQuote))
+    char '"'
+    return ret
 
 
 parseElems :: Read a => Parser a -> Parser [a]
-parseElems f = do x <- f
-                  spaces
-                  do next
-                     xs <- parseElems f
-                     return (x:xs)
-                   <|> return [x] 
-               <|> return []
+parseElems parser = (do
+    spaces
+    x <- parser
+    spaces
+    (do 
+        next
+        xs <- parseElems parser
+        return (x:xs)) <|> return [x]) <|> return []
+
 
 parseList :: Read a => Parser a -> Parser [a]
-parseList f = do spaces >> char '['
-                 xs <- parseElems (spaces >> f)
-                 spaces >> char ']'
-                 return xs 
+parseList parser = do 
+    spaces >> char '[' >> spaces
+    xs <- parseElems parser
+    spaces >> char ']'
+    return xs