at_coder_friends 0.6.2 → 0.6.3

data/lib/at_coder_friends/parser/input_type.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Parser
+    # parses input data types and updates input definitons
+    module InputType
+      module_function
+
+      NUMBER_PAT = /\A[+-]?[0-9]+\z/.freeze
+      TYPE_TBL = [
+        [:number, NUMBER_PAT],
+        [:decimal, /\A[+-]?[0-9]+(\.[0-9]+)?\z/]
+      ].freeze
+
+      def process(pbm)
+        parse(pbm.formats_src, pbm.samples)
+      end
+
+      def parse(inpdefs, smps)
+        lines = max_smp(smps)&.split("\n")
+        lines && match_smp(inpdefs, lines)
+      end
+
+      def max_smp(smps)
+        smps
+          .select { |smp| smp.ext == :in }
+          .max_by { |smp| smp.txt.size }
+          &.txt
+      end
+
+      def match_smp(inpdefs, lines)
+        vars = {}
+        inpdefs.each do |inpdef|
+          break unless  (k = get_line_cnt(inpdef))
+
+          k, parsed = parse_line_cnt(k, vars)
+          rows = lines.shift(k).map { |line| line.split(/[#{inpdef.delim} ]/) }
+          break if rows.empty?
+
+          inpdef.container == :single &&
+            vars.merge!(inpdef.names.zip(rows[0]).to_h)
+          inpdef.cols = detect_cols_type(rows)
+          break unless parsed
+        end
+        inpdefs
+      end
+
+      def get_line_cnt(inpdef)
+        case inpdef.size.size
+        when 0
+          1
+        when 1
+          inpdef.container == :harray ? 1 : inpdef.size[0]
+        when 2
+          inpdef.size[0]
+        end
+      end
+
+      def parse_line_cnt(k, vars)
+        if k.is_a?(Integer)
+          [k, true]
+        elsif k =~ NUMBER_PAT
+          [k.to_i, true]
+        elsif vars[k] =~ NUMBER_PAT
+          [vars[k].to_i, true]
+        elsif vars[(k2 = k.gsub(/-1\z/, ''))] =~ NUMBER_PAT
+          [vars[k2].to_i - 1, true]
+        else
+          [1, false]
+        end
+      end
+
+      def detect_cols_type(rows)
+        cols = fill_transpose(rows).map(&:compact)
+        cols.map { |col| detect_col_type(col) }
+      end
+
+      def fill_transpose(arr)
+        Array.new(arr.map(&:size).max) { |i| arr.map { |e| e[i] } }
+      end
+
+      def detect_col_type(arr)
+        ret = :string
+        TYPE_TBL.any? do |type, pat|
+          arr.all? { |v| v =~ pat } && ret = type
+        end
+        ret
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/main.rb

@@ -10,6 +10,7 @@ module AtCoderFriends
         Sections.process(pbm)
         SampleData.process(pbm)
         InputFormat.process(pbm)
+        InputType.process(pbm)
         Constraints.process(pbm)
         Modulo.process(pbm)
         Interactive.process(pbm)

data/lib/at_coder_friends/problem.rb

@@ -18,13 +18,84 @@ module AtCoderFriends
 
     SampleData = Struct.new(:no, :ext, :txt)
 
-    InputFormat = Struct.new(:container, :item, :names, :size) do
-      def initialize(container, item, names, size = [])
-        super(container, item, names, size)
+    # holds information about input format
+    class InputFormat
+      ITEM_RANK = { number: 1, decimal: 2, string: 3 }.freeze
+
+      attr_reader :container, :names, :size, :delim
+      attr_accessor :cols
+
+      def initialize(
+        container: nil,
+        item: nil,
+        names: [],
+        size: [],
+        delim: '',
+        cols: []
+      )
+        @container = container
+        @item = item
+        @names = names
+        @size = size
+        @delim = delim
+        @cols = cols
       end
 
       def to_s
-        "#{container} #{item} #{names} #{size}"
+        if container == :unknown
+          "#{container} #{item}"
+        else
+          "#{container} #{item}(#{cols}) #{names} #{size} #{delim}"
+        end
+      end
+
+      def item
+        @item || cols.max_by { |k| ITEM_RANK[k] } || :number
+      end
+
+      def vars
+        tmp = @item && [@item] || cols
+        names.zip(tmp).map { |(name, col)| [name, col || :number] }
+      end
+
+      def components
+        @components ||=
+          case container
+          when :varray_matrix
+            varray_matrix_components
+          when :matrix_varray
+            matrix_varray_components
+          end
+      end
+
+      def varray_matrix_components
+        [
+          self.class.new(
+            container: :varray,
+            names: names[0..-2], size: size[0..0],
+            delim: delim, cols: cols[0..-2]
+          ),
+          self.class.new(
+            container: :matrix, item: @item,
+            names: names[-1..-1], size: size,
+            delim: delim, cols: cols[-1..-1] || []
+          )
+        ]
+      end
+
+      def matrix_varray_components
+        [
+          self.class.new(
+            container: :matrix, item: @item,
+            names: names[0..0], size: size,
+            delim: delim, cols: cols[0..0]
+          ),
+          self.class.new(
+            container: :varray,
+            names: names[1..-1], size: size[0..0],
+            delim: delim, cols: cols[1..-1] || []
+          )
+        ]
       end
     end
 
@@ -35,14 +106,14 @@ module AtCoderFriends
     SourceCode = Struct.new(:ext, :txt)
 
     attr_reader :q, :samples, :sources, :options
-    attr_accessor :page, :sections, :formats, :constants
+    attr_accessor :page, :sections, :formats_src, :constants
 
     def initialize(q, page = Mechanize::Page.new)
       @q = q
       @page = page
       @sections = {}
       @samples = []
-      @formats = []
+      @formats_src = []
       @constants = []
       @options = Options.new
       @sources = []
@@ -57,6 +128,10 @@ module AtCoderFriends
       @body_content ||= page.search('body')[0]&.content
     end
 
+    def formats
+      @formats ||= formats_src.reject { |f| f.container == :unknown }
+    end
+
     def add_smp(no, ext, txt)
       @samples << SampleData.new(no, ext, txt)
     end

data/lib/at_coder_friends/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AtCoderFriends
-  VERSION = '0.6.2'
+  VERSION = '0.6.3'
 end

data/lib/at_coder_friends.rb

@@ -20,11 +20,13 @@ require 'at_coder_friends/parser/introduction_wrapper'
 require 'at_coder_friends/parser/sections'
 require 'at_coder_friends/parser/sample_data'
 require 'at_coder_friends/parser/input_format'
+require 'at_coder_friends/parser/input_type'
 require 'at_coder_friends/parser/constraints'
 require 'at_coder_friends/parser/modulo'
 require 'at_coder_friends/parser/interactive'
 require 'at_coder_friends/parser/binary'
 require 'at_coder_friends/parser/main'
+require 'at_coder_friends/generator/base'
 require 'at_coder_friends/generator/cxx_builtin'
 require 'at_coder_friends/generator/ruby_builtin'
 require 'at_coder_friends/generator/main'

data/tasks/regression/check_const.rake

@@ -23,23 +23,23 @@ module AtCoderFriends
     }.freeze
 
     def collect(tgt)
-      File.open(const_log('collect', tgt), 'w') do |f|
+      open_const_report('collect', tgt) do |f|
         local_pbm_list.each do |contest, q, url|
           page = agent.get(url)
           body = page.body.force_encoding('utf-8')
           ms = body.scan(CONST_PAT[tgt.to_sym])
           ms.each do |m|
-            s = m[0].delete("\r\n\t\"")
-            f.puts [contest, q, s].join("\t")
+            s = m[0].delete("\r\n")
+            f.puts [contest, q, tsv_escape(s)].join("\t")
           end
         end
       end
     end
 
     def check_mod
-      File.open(const_log('check', 'mod'), 'w') do |f|
+      open_const_report('check', 'mod') do |f|
         local_pbm_list.each do |contest, q, url|
-          pbm = scraping_agent(nil, contest).fetch_problem(q, url)
+          pbm = local_scraping_agent(nil, contest).fetch_problem(q, url)
           Parser::Sections.process(pbm)
           Parser::Modulo.process(pbm)
           pbm.constants.each do |cnst|
@@ -50,9 +50,9 @@ module AtCoderFriends
     end
 
     def check_max
-      File.open(const_log('check', 'max'), 'w') do |f|
+      open_const_report('check', 'max') do |f|
         local_pbm_list.each do |contest, q, url|
-          pbm = scraping_agent(nil, contest).fetch_problem(q, url)
+          pbm = local_scraping_agent(nil, contest).fetch_problem(q, url)
           Parser::Sections.process(pbm)
           Parser::Constraints.process(pbm)
           pbm.constants.each do |cns|
@@ -70,10 +70,10 @@ module AtCoderFriends
     def load_merge_list(tgt)
       tbl = {}
       %w[collect check]
-        .map { |act| const_log(act, tgt) }
+        .map { |act| load_const_report(act, tgt) }
         .each
-        .with_index(1) do |file, n|
-          list_from_file(file)
+        .with_index(1) do |data, n|
+          data
             .group_by { |contest, q, _| "#{contest}\t#{q}" }
             .map { |key, grp| [key, grp.map { |row| row[2] }.join("\n")] }
             .each do |key, txt|
@@ -85,18 +85,19 @@ module AtCoderFriends
     end
 
     def save_merge_list(tgt, tbl)
-      File.open(const_log('merge', tgt), 'w') do |f|
+      open_const_report('merge', tgt) do |f|
         tbl.sort.each do |k, h|
           f.puts [k, h['v1'], h['v2']].join("\t")
         end
       end
     end
 
-    def const_log(act, tgt)
-      log_path("#{act}_#{tgt}.txt")
+    def open_const_report(act, tgt)
+      open_report("#{act}_#{tgt}.txt") { |f| yield f }
     end
 
-    def list_from_file(file)
+    def load_const_report(act, tgt)
+      file = report_path("#{act}_#{tgt}.txt")
       Encoding.default_external = 'utf-8'
       CSV.read(file, col_sep: "\t", headers: false)
     end

data/tasks/regression/check_diff.rake

@@ -12,11 +12,11 @@ module AtCoderFriends
       rmdir_force(emit_dir)
 
       local_pbm_list.each do |contest, q, url|
-        pbm = scraping_agent(emit_dir, contest).fetch_problem(q, url)
+        pbm = local_scraping_agent(emit_dir, contest).fetch_problem(q, url)
         pipeline(pbm)
       end
 
-      diff_log = log_path('check_diff.txt')
+      diff_log = report_path('check_diff.txt')
       system("diff -r --exclude=.git #{EMIT_ORG_DIR} #{emit_dir} > #{diff_log}")
     end
   end

data/tasks/regression/check_fmt.rake

@@ -8,28 +8,31 @@ module AtCoderFriends
     module_function
 
     def check_fmt
-      File.open(log_path('check_fmt.txt'), 'w') do |f|
-        local_pbm_list.sort.each do |contest, q, url|
-          pbm = scraping_agent(nil, contest).fetch_problem(q, url)
-          Parser::Sections.process(pbm)
-          fmt = Parser::InputFormat.find_fmt(pbm)
-          next unless fmt && !fmt.empty?
+      open_report('check_fmt.txt') do |f|
+        local_pbm_list.each do |contest, q, url|
+          next unless (res = process_fmt(contest, q, url))
 
-          n_fmt = Parser::InputFormat.normalize_fmt(fmt).join("\n")
-          Parser::InputFormat.process(pbm)
-          res = pbm.formats.map(&:to_s).join("\n")
           f.puts [
-            contest, q,
-            tsv_escape(fmt),
-            tsv_escape(n_fmt),
-            tsv_escape(res)
+            contest, q, *res.map { |s| tsv_escape(s) }
           ].join("\t")
         end
       end
     end
 
-    def tsv_escape(str)
-      '"' + str.gsub('"', '""').gsub("\t", ' ') + '"'
+    def process_fmt(contest, q, url)
+      pbm = local_scraping_agent(nil, contest).fetch_problem(q, url)
+      Parser::Sections.process(pbm)
+      Parser::SampleData.process(pbm)
+      fmt1 = Parser::InputFormat.find_fmt(pbm)
+      return unless fmt1 && !fmt1.empty?
+
+      fmt2 = Parser::InputFormat.normalize_fmt(fmt1).join("\n")
+      Parser::InputFormat.process(pbm)
+      Parser::InputType.process(pbm)
+      inpdefs = pbm.formats_src
+      fmt3 = inpdefs.map(&:to_s).join("\n")
+      fmt4 = inpdefs.any? { |inpdef| inpdef.cols.empty? } ? '○' : ''
+      [fmt1, fmt2, fmt3, fmt4]
     end
   end
 end

data/tasks/regression/check_parse.rake

@@ -10,7 +10,7 @@ module AtCoderFriends
 
     def check_parse
       list = local_pbm_list.map do |contest, q, url|
-        pbm = scraping_agent(nil, contest).fetch_problem(q, url)
+        pbm = local_scraping_agent(nil, contest).fetch_problem(q, url)
         Parser::Main.process(pbm)
         flags = [
           !fmt?(pbm),
@@ -24,7 +24,7 @@ module AtCoderFriends
 
     def check_bin
       list = local_pbm_list.map do |contest, q, url|
-        pbm = scraping_agent(nil, contest).fetch_problem(q, url)
+        pbm = local_scraping_agent(nil, contest).fetch_problem(q, url)
         Parser::Main.process(pbm)
         flags = [pbm.options.binary_values]
         [contest, q, flags]
@@ -38,11 +38,10 @@ module AtCoderFriends
     end
 
     def report(list, file)
-      File.open(log_path(file), 'w') do |f|
+      open_report(file) do |f|
         list
           .select { |_, _, flags| flags.any? }
           .map { |c, q, flags| [c, q, flags.map { |flg| f_to_s(flg) }] }
-          .sort
           .each { |args| f.puts args.flatten.join("\t") }
       end
     end

data/tasks/regression/list_handler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'csv'
+
+module AtCoderFriends
+  # tasks for regression
+  module Regression
+    module_function
+
+    CONTEST_LIST_URL = 'https://kenkoooo.com/atcoder/resources/contests.json'
+    ACF_HOME = File.expand_path(File.join(__dir__, '..', '..'))
+    REGRESSION_HOME = File.join(ACF_HOME, 'regression')
+    PAGES_DIR = File.join(REGRESSION_HOME, 'pages')
+    EMIT_ORG_DIR = File.join(REGRESSION_HOME, 'emit_org')
+    EMIT_DIR_FMT = File.join(REGRESSION_HOME, 'emit_%<now>s')
+
+    def contest_id_list
+      uri = URI.parse(CONTEST_LIST_URL)
+      json = Net::HTTP.get(uri)
+      contests = JSON.parse(json)
+      puts "Total #{contests.size} contests"
+      contests.map { |h| h['id'] }
+    end
+
+    def local_pbm_list
+      Dir.glob(PAGES_DIR + '/**/*.html').map do |pbm_path|
+        contest = File.basename(File.dirname(pbm_path))
+        q = File.basename(pbm_path, '.html')
+        url = "file://#{pbm_path}"
+        [contest, q, url]
+      end.sort # .take(10)
+    end
+
+    def pbm_list_from_file(file)
+      dat = File.join(REGRESSION_HOME, file)
+      CSV.read(dat, col_sep: "\t", headers: false).map do |contest, q|
+        pbm_path = File.join(PAGES_DIR, contest, "#{q}.html")
+        url = "file://#{pbm_path}"
+        [contest, q, url]
+      end
+    end
+  end
+end

data/tasks/regression/regression.rb

@@ -1,56 +1,26 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
-require 'json'
-require 'csv'
 require 'mechanize'
 require 'at_coder_friends'
+require_relative 'list_handler'
+require_relative 'report_handler'
 
 module AtCoderFriends
   # tasks for regression
   module Regression
     module_function
 
-    CONTEST_LIST_URL = 'https://kenkoooo.com/atcoder/resources/contests.json'
-    ACF_HOME = File.expand_path(File.join(__dir__, '..', '..'))
-    REGRESSION_HOME = File.join(ACF_HOME, 'regression')
-    PAGES_DIR = File.join(REGRESSION_HOME, 'pages')
-    EMIT_ORG_DIR = File.join(REGRESSION_HOME, 'emit_org')
-    EMIT_DIR_FMT = File.join(REGRESSION_HOME, 'emit_%<now>s')
-
-    def contest_id_list
-      uri = URI.parse(CONTEST_LIST_URL)
-      json = Net::HTTP.get(uri)
-      contests = JSON.parse(json)
-      puts "Total #{contests.size} contests"
-      contests.map { |h| h['id'] }
-    end
-
-    def local_pbm_list
-      Dir.glob(PAGES_DIR + '/**/*.html').map do |pbm_path|
-        contest = File.basename(File.dirname(pbm_path))
-        q = File.basename(pbm_path, '.html')
-        url = "file://#{pbm_path}"
-        [contest, q, url]
-      end
-    end
-
-    def pbm_list_from_file(file)
-      dat = File.join(REGRESSION_HOME, file)
-      CSV.read(dat, col_sep: "\t", headers: false).map do |contest, q|
-        pbm_path = File.join(PAGES_DIR, contest, "#{q}.html")
-        url = "file://#{pbm_path}"
-        [contest, q, url]
-      end
-    end
-
     def scraping_agent(root, contest)
       root ||= REGRESSION_HOME
       @ctx = Context.new({}, File.join(root, contest))
       @ctx.scraping_agent
     end
 
+    def local_scraping_agent(root, contest)
+      scraping_agent(root, contest)
+        .tap { |sa| sa.agent.pre_connect_hooks.clear }
+    end
+
     def agent
       @agent ||= Mechanize.new
     end
@@ -64,9 +34,5 @@ module AtCoderFriends
     def rmdir_force(dir)
       FileUtils.rm_r(dir) if Dir.exist?(dir)
     end
-
-    def log_path(file)
-      File.join(REGRESSION_HOME, file)
-    end
   end
 end

data/tasks/regression/report_handler.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  # tasks for regression
+  module Regression
+    module_function
+
+    def open_report(file)
+      File.open(report_path(file), 'wb') { |f| yield f }
+    end
+
+    def report_path(file)
+      File.join(REGRESSION_HOME, file)
+    end
+
+    def tsv_escape(str)
+      '"' + str.gsub('"', '""').gsub("\t", ' ') + '"'
+    end
+  end
+end

data/tasks/regression/section_list.rake

@@ -26,7 +26,7 @@ module AtCoderFriends
     end
 
     def save_section_list(list)
-      File.open(log_path('section_list.txt'), 'w') do |f|
+      open_report('section_list.txt') do |f|
         list.group_by(&:title).each do |k, vs|
           f.puts [k, vs.size, vs[0].contest, vs[0].q].join("\t")
         end

data/templates/{cxx_builtin_interactive.cxx → cxx_builtin.cxx.erb}

@@ -1,6 +1,8 @@
-// /*** URL ***/
+// <%= pbm.url %>
 
-#include <cstdio>
+<%
+if pbm.options.interactive
+%>#include <cstdio>
 #include <vector>
 #include <string>
 
@@ -52,8 +54,37 @@ void input() {
 #ifdef DEBUG
   scanf("%s", source);
 #endif
+}<%
+else
+%>#include <cstdio>
+
+using namespace std;
+
+#define REP(i,n)   for(int i=0; i<(int)(n); i++)
+#define FOR(i,b,e) for(int i=(b); i<=(int)(e); i++)
+
+/*** CONSTS ***/
+
+/*** DCLS ***/
+
+void solve() {
+<%
+if (vs = pbm.options.binary_values)
+%>  bool cond = false;
+  puts(cond ? "<%= vs[0] %>" : "<%= vs[1] %>");<%
+else
+%>  int ans = 0;
+  printf("%d\n", ans);<%
+end
+%>
 }
 
+void input() {
+  /*** INPUTS ***/
+}<%
+end
+%>
+
 int main() {
   input();
   solve();

data/templates/{ruby_builtin_interactive.rb → ruby_builtin.rb.erb}

@@ -1,6 +1,8 @@
-# ### URL ###
+# <%= pbm.url %>
 
-def query(*args)
+<%
+if pbm.options.interactive
+%>def query(*args)
   puts "? #{args.join(' ')}"
   STDOUT.flush
   if $DEBUG
@@ -31,4 +33,17 @@ if $DEBUG
   puts "query results:"
   @responses.each { |res| puts res }
   puts "----------------------------------------"
+end<%
+else
+%>### CONSTS ###
+
+### DCLS ###
+
+<%
+if (vs = pbm.options.binary_values)
+%>puts cond ? '<%= vs[0] %>' : '<%= vs[1] %>'<%
+else
+%>puts ans<%
+end
 end
+%>