gettc 1.10 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be356b29f63fbb870ee7ffca99f1bcc3d0bcd52e
-  data.tar.gz: 47c2abcafbe216880d20d01a6d11c0731bda6c66
+  metadata.gz: 1b7ea56d04d293fac9836322b3bd90bb3c0e19b3
+  data.tar.gz: 2e2b323f24c59f0976c1f73b9a822ccbd7e82a9e
 SHA512:
-  metadata.gz: 2e057827784adaa9d9f2e8b55c299f0a3e67aa72945409d5540fd610a38168819c2e960af5f6a3d9c6065c9947e377b2e58fcd98419498cd686ae8bf2b5b2f4f
-  data.tar.gz: 7c2bcb3dd3f338056b204f2d4f3d0505b949b7f58616a1bb5adbec67c1c21a2ef9e290b090658f6494feb1a04356c555fcce82b6fcea7d38db5e496d1b2d433b
+  metadata.gz: ce0bf1a1b452710291a014d2b52fa10af2170c2a6cff2e9d2602ce8affa75df61b08b198377be00102cc5f2c032ca50537e0aa330e92e8263594ef491f22061f
+  data.tar.gz: 18c9c44a6b39463d2d797e055614740dc72715ad4556436fee2062aa3588cd56aa10476375c2ed79b3da01c722b7f9c9c63d6c2609115712ed338656310fb56a

data/bin/gettc

@@ -1,90 +1,81 @@
 #! /usr/bin/env ruby
 
-require "gettc" 
+require "gettc"
 include Gettc
 
 require "rubygems"
-require "fileutils" 
-require "yaml" 
-
-def init
-    $config_d = ENV.fetch "GETTC_HOME", File.expand_path("~/.gettc")
-    gem_d = Gem.loaded_specs["gettc"]
-    if gem_d.nil? then
-        $root_d = File.join File.dirname(__FILE__), "../"
-    else
-        $root_d = gem_d.full_gem_path
-    end
-end
+require "fileutils"
+require "yaml"
 
 def replace_config
-    FileUtils.mkdir $config_d
-    default_d = File.join $root_d, "dist/."
-    FileUtils.cp_r default_d, $config_d        
+  FileUtils.mkdir($config_dir)
+  FileUtils.cp_r(File.join($root_dir, "dist/."), $config_dir)
 end
 
 def load_config
-    replace_config unless Dir.exists? $config_d
-    config = YAML.load_file File.join($config_d, 'config.yml')
+  replace_config unless Dir.exists?($config_dir)
+  config = YAML.load_file(File.join($config_dir, "config.yml"))
 
-    version = config["version"]
-    unless version.nil? then
-        version = Gem::Version.new version
-    end
+  version = config["version"]
+  version = Gem::Version.new(version) unless version.nil?
 
-    if version.nil? or version < Gem::Version.new(VERSION) then
-        FileUtils.rm_rf $config_d
-        replace_config
-    end
+  if version.nil? || version < Gem::Version.new(VERSION)
+    FileUtils.rm_rf($config_dir)
+    replace_config
+  end
 
-    account = Account.new config["username"], config["password"]
-    return account
-end 
+  $account = Account.new(config["username"], config["password"])
+end
+
+def init
+  $config_dir = ENV.fetch("GETTC_HOME", File.expand_path("~/.gettc"))
+  gem_d = Gem.loaded_specs["gettc"]
+  $root_dir = gem_d ? gem_d.full_gem_path : File.join(File.dirname(__FILE__), "../")
+
+  load_config
+  $downloader = Downloader.new($account)
+  $parser = Parser.new($downloader)
+  $generator = Generator.new($config_dir, Dir.getwd)
+end
+
+def gettc(id)
+  problem = $parser.parse(id)
+  puts "#{problem.name} was used for #{problem.source}."
+  $generator.generate(problem)
+
+  puts "All done. Start solving with:"
+  puts "    $ cd #{problem.name}/solve/<your_language>"
+  puts "    $ make demo"
+rescue TemplateError => err
+  puts err
+end
 
 def main
-    prog = File.basename __FILE__
-    usage = <<-eos.strip
+  prog = File.basename(__FILE__)
+  usage = <<-eos.strip
 gettc <id>: Generate a solution for the TopCoder problem with that ID, eg 11138.
 gettc version: Print version string.
 gettc reset: Bring all settings to default state.
-    eos
-    if ARGV.empty?  
-        puts usage 
-        return
-    end
-    command = ARGV[0]
-    if command == "version"
-        puts VERSION
-    elsif command == "reset"
-        FileUtils.rm_rf $config_d
-        replace_config
-    else
-        id = ARGV[0].to_i
-        puts "You have given ID = #{id}" 
-    begin
-        account = load_config 
-        robot = Downloader.new account
-        parser = Parser.new robot
-        generator = Generator.new $config_d, Dir.getwd
-        
-        print "Downloading problem to raw HTML ... "
-        html = robot.download_problem id
-        puts "Done"
-        
-        print "Parsing problem from raw HTML ... "
-        prob = parser.parse html
-        puts "Done"
-        
-        print "Generating problem directory for #{prob.name} ... "
-        generator.generate prob
-        puts "Done"
-    rescue TemplateError => terr
-        puts terr
-    rescue StandardError => err
-        puts err
-        exit -1
-    end        
-    end
+  eos
+
+  if ARGV.empty?
+    puts usage
+    return
+  end
+
+  command = ARGV[0]
+  case command
+  when "version"
+    puts VERSION
+  when "reset"
+    FileUtils.rm_rf($config_dir)
+    replace_config
+  else
+    gettc(command.to_i)
+  end
+rescue StandardError => err
+  puts err
+  exit -1
 end
 
 init

data/dist/config.yml

@@ -1,3 +1,3 @@
 username: gettc
 password: algorithm
-version: 1.10
+version: 2.0

data/dist/include/cpp/engine.rb

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

data/dist/include/cpp/topcoder

@@ -13,264 +13,264 @@
 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);
+  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();
     }
 
-    void next(std::istream &is) {
-        _expect(is, ',');
-    } 
+  public:
+    ParseException() : message("ParseException occurred") {}
+    ParseException(std::string const &message) : message(message) {}
+    ~ParseException() throw () {}
 
-    void read(std::istream &is, int &i) { 
-        is >> i; 
+    virtual const char* what() const throw() { 
+      return message.c_str(); 
     }
 
-    void read(std::istream &is, int64 &l) { 
-        is >> l; 
+    ParseException(std::string const &required, char actual, 
+             std::string const &rest) { 
+      buildMessage(required, actual, rest);
     }
 
-    void read(std::istream &is, float &f) { 
-        is >> f; 
+    ParseException(char expected, char actual, 
+             std::string const &rest) { 
+      std::ostringstream oss;
+      oss << "Expect '" << expected << "'";
+      buildMessage(oss.str(), actual, rest);
     }
 
-    void read(std::istream &is, double &d) { 
-        is >> d; 
+    ParseException(std::string const &required, std::string const &rest) {
+      std::ostringstream oss;
+      oss << required << " at: <" << rest << ">";
+      message = oss.str();
     }
 
-    void read(std::istream &is, char &c) {
-        _spaces(is); char ch; is.get(ch);
-        if (ch == '\'') {
-            is.get(c);
-            _expect(is, '\'');
-        } else {
-            c = ch;
-        }
-    }
-
-    void read(std::istream &is, std::string &s) {
-        _expect(is, '"');
-        std::ostringstream oss;    
-        while (is.good()) {
-            char c; is.get(c);
-            if (c == '"') {
-                std::streampos pos = is.tellg();
-                _spaces(is);
-                if (is.eof()) {
-                    s = oss.str();
-                    return;
-                }
-                char cc; is.get(cc);
-                if (cc == ',' || cc == ']') {
-                    s = oss.str();
-                    is.unget();
-                    return;
-                }
-                is.seekg(pos);
-            }
-            oss << c;
-        }
-        throw ParseException('"');
+    ParseException(char expected) {
+      std::ostringstream oss;
+      oss << "Expect '" << expected << " before end of stream";
+      message = oss.str();
     }
-
-    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));
-        }
+  };
+
+  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) {
+    _spaces(is); char ch; is.get(ch);
+    if (ch == '\'') {
+      is.get(c);
+      _expect(is, '\'');
+    } else {
+      c = ch;
     }
-
-    template <typename T>
-    void read(std::istream &is, std::vector<T> &v) {
-        v.clear();
-        _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 == '"') {
+        std::streampos pos = is.tellg();
         _spaces(is);
-        int i = is.peek(); 
-        if (i == ']') {
-            is.ignore(1);
-            return;
+        if (is.eof()) {
+          s = oss.str();
+          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;
+        char cc; is.get(cc);
+        if (cc == ',' || cc == ']') {
+          s = oss.str();
+          is.unget();
+          return;
         }
-        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; 
+        is.seekg(pos);
+      }
+      oss << c;
     }
-
-    bool same(std::string const &x, std::string const &y) { 
-        return x == y; 
+    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));
     }
-
-    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);
+  }
+
+  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;
     }
-
-    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);
+    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));
+      }
     } 
-
-    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;
-        }
+    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 */