gettc 1.2.2

data/dist/config.yml

@@ -0,0 +1,2 @@
+username: gettc
+password: algorithm

data/dist/include/cpp/engine.rb

@@ -0,0 +1,90 @@
+require 'topcoder/types' 
+
+module TopCoder
+    class Type
+        def to_cpp
+            if self == TInt then
+                return 'int'
+            elsif self == TLong then
+                return 'int64'        
+            elsif self == TFloat then
+                return 'float'
+            elsif self == TDouble then
+                return 'double'
+            elsif self == TChar then
+                return 'char'
+            elsif self == TString then
+                return 'string'
+            elsif self == TBoolean then
+                return 'bool'
+            elsif is_a? TArray then
+                ret = 'vector<' << subtype.to_cpp
+                ret << ' ' if subtype.is_a? TArray
+                ret << '>'
+                return ret
+            else
+                return 'unknown'
+            end 
+        end
+        def dumb_cpp
+            if self == TInt then
+                return '0'
+            elsif self == TLong then
+                return '0'        
+            elsif self == TFloat then
+                return '0'
+            elsif self == TDouble then
+                return '0'
+            elsif self == TChar then
+                return "'$'"
+            elsif self == TString then
+                return '"$"'
+            elsif self == TBoolean then
+                return 'true'
+            elsif is_a? TArray then
+                return "#{to_cpp}()"
+            else
+                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 << name 
+            return ret
+        end
+    end
+    class CppEngine
+        attr_accessor :func, :vars
+        def initialize func, vars
+            @func = func
+            @vars = vars            
+        end
+        def declare
+            ret = @func.to_cpp
+            ret << '('
+                indent = ' ' * ret.size
+                temp = @vars.map do |var| var.to_cpp true end
+                ret << temp.join(",\n#{indent}")
+            ret << ')'
+            return ret
+        end
+        def input
+            temp = @vars.map do |var|
+                x = var.to_cpp
+                x << '; read(ifs, '
+                x << var.name
+                x << ');'
+            end
+            return temp.join " next(ifs);\n"
+        end
+        def output
+            ret = 'show(ofs, ' << @func.name << '('
+            temp = @vars.map do |var| var.name end
+            ret << temp.join(', ') << '));'
+        end
+    end
+end

data/dist/include/cpp/topcoder

@@ -0,0 +1,212 @@
+#ifndef GETTC_TOPCODER_H 
+#define GETTC_TOPCODER_H
+
+#include <algorithm>
+#include <exception>
+#include <string>
+#include <vector>
+#include <iostream>
+#include <sstream>
+#include <cmath>
+#include <cctype>
+
+typedef unsigned int uint;
+typedef long long int64;
+typedef unsigned long long uint64;
+    
+namespace TopCoder
+{
+    const int _CHUNK_SIZE = 65536;
+
+    class ParseException: public std::exception {
+    private:
+        std::string message;
+        void buildMessage(std::string const &required, char actual, 
+                          std::string const &rest) { 
+            std::ostringstream oss;
+            oss << required << " at: <" << rest << ">";
+            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(); }
+
+        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";
+            message = oss.str();
+        }
+    };
+
+    std::string _rest(std::istream &is) {
+        std::ostringstream oss;
+        char chunk[_CHUNK_SIZE];
+        while (is.good()) {
+            is.get(chunk, _CHUNK_SIZE);
+            oss << chunk;
+        } 
+        return oss.str();
+    }
+    void _spaces(std::istream &is) {
+        while (is.good()) {
+            int i = is.peek();
+            if (isspace(i)) is.ignore(1);
+            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, char &c) {
+        _expect(is, '\'');
+        is.get(c);
+        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 == '\\') {
+                char cc; is.get(cc);
+                oss << cc;
+            } 
+            else if (c == '"') {
+                s = oss.str();
+                return;
+            }
+            else oss << c;
+        }
+        throw ParseException('"');
+    }
+    void read(std::istream &is, bool &b) { 
+        _spaces(is);
+        std::ostringstream oss;
+        while (is.good()) {
+            int i = is.peek();
+            if (!isalpha(i)) {
+                break;
+            }
+            oss.put(i);
+            is.ignore(1);
+        } 
+        std::string s = oss.str();
+        std::transform(s.begin(), s.end(), s.begin(), ::tolower);
+        if (s == "true")  {
+            b = true;
+        } else if (s == "false") {
+            b = false;
+        } else {
+            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();
+        _expect(is, '['); 
+        _spaces(is);
+        int i = is.peek(); 
+        if (i == ']') {
+            is.ignore(1);
+            return;
+        }
+        while (is.good()) { 
+            T e; read(is, e); v.push_back(e);
+            _spaces(is); char c; is.get(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, 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 << ',';
+            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(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;
+        Iterator i1 = v1.begin(),
+                 i2 = v2.begin();
+        while (true) {
+            if (i1 == v1.end()) return i2 == v2.end();
+            if (i2 == v2.end()) return false;
+            if (!same(*i1++, *i2++)) return false;
+        }
+    }
+}
+
+#endif /* GETTC_TOPCODER_H */ 

data/dist/include/haskell/TopCoder.hs

@@ -0,0 +1,82 @@
+module TopCoder ( next
+                , parseChar
+                , parseString
+                , parseBool
+                , parseInt
+                , parseLong
+                , parseFloat
+                , parseDouble
+                , parseList
+                , Parser
+                , parse
+                , spaces
+                ) where
+
+import Text.Parsec
+import Text.Parsec.String (Parser)
+import Text.Parsec.Token
+import Data.Char
+
+next :: Parser ()
+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
+
+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)
+
+
+parseElems :: Read a => Parser a -> Parser [a]
+parseElems f = do x <- f
+                  spaces
+                  do next
+                     xs <- parseElems f
+                     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 

data/dist/include/haskell/engine.rb

@@ -0,0 +1,122 @@
+require 'topcoder/types' 
+class String
+    def uncapitalize
+        return self[0, 1].downcase + self[1..-1]
+    end
+end
+module TopCoder
+    class Type
+        def to_haskell
+            if self == TInt then
+                return 'Int'
+            elsif self == TLong then
+                return 'Integer'        
+            elsif self == TFloat then
+                return 'Float'
+            elsif self == TDouble then
+                return 'Double'
+            elsif self == TChar then
+                return 'Char'
+            elsif self == TString then
+                return 'String'
+            elsif self == TBoolean then
+                return 'Bool'
+            elsif is_a? TArray then
+                return '[' + subtype.to_haskell + ']'
+            else
+                return 'Unknown'
+            end 
+        end
+        def get_haskell_parser
+            if self == TInt then
+                return 'parseInt'
+            elsif self == TLong then
+                return 'parseLong'        
+            elsif self == TFloat then
+                return 'parseFloat'
+            elsif self == TDouble then
+                return 'parseDouble'
+            elsif self == TChar then
+                return 'parseChar'
+            elsif self == TString then
+                return 'parseString'
+            elsif self == TBoolean then
+                return 'parseBool'
+            elsif is_a? TArray then
+                return '(parseList ' + subtype.get_haskell_parser + ')'
+            else
+                return 'unknown'
+            end
+        end
+        def dumb_haskell
+            if self == TInt then
+                return '0'
+            elsif self == TLong then
+                return '0'        
+            elsif self == TFloat then
+                return '0'
+            elsif self == TDouble then
+                return '0'
+            elsif self == TChar then
+                return "'$'"
+            elsif self == TString then
+                return '"$"'
+            elsif self == TBoolean then
+                return 'True'
+            elsif is_a? TArray then
+                return '[]'
+            else
+                return 'Nil'
+            end
+        end
+    end
+    class HaskellEngine
+        attr_accessor :func, :vars
+        def initialize func, vars
+            @func = Signature.new func.type, func.name.uncapitalize
+            @vars = vars.map do |var|
+                Signature.new var.type, var.name.uncapitalize
+            end
+        end
+        def declare
+            ret = ''
+            ret << func.name << ' :: '
+
+            temp = vars.map do |var| var.type.to_haskell end
+            ret << temp.join(' -> ') << ' -> ' << func.type.to_haskell << "\n"
+
+            ret << func.name << ' '
+            temp = vars.map do |var| var.name end
+            ret << temp.join(' ') << ' = ' << func.type.dumb_haskell
+
+            return ret
+        end
+        def input
+            ret = 'getVars :: Parser ('
+            temp = @vars.map do |var| var.type.to_haskell end
+            ret << temp.join(', ') << ")\n"
+            temp = 'getVars = do '
+            ret << temp
+                indent = ' ' * temp.size
+                temp = @vars.map do |var|
+                    x = ''
+                    x << var.name
+                    x << ' <- spaces >> ' 
+                    x << var.type.get_haskell_parser
+                end
+            ret << temp.join(" ; next\n#{indent}") << "\n"
+            ret << indent << 'return ('
+                temp = @vars.map do |var| var.name end
+                ret << temp.join(', ')
+            ret << ')'
+            return ret
+        end
+        def output
+            ret = ''
+            ret << @func.name << ' '
+            temp = vars.map do |var| var.name end
+            ret << temp.join(' ')
+            return ret
+        end
+    end
+end