at_coder_friends 0.5.2 → 0.6.0

data/lib/at_coder_friends/generator/ruby_builtin.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Generator
+    # generates C++ source code from problem description
+    class RubyBuiltin
+      ACF_HOME = File.realpath(File.join(__dir__, '..', '..', '..'))
+      TMPL_DIR = File.join(ACF_HOME, 'templates')
+      DEFAULT_TMPL = File.join(TMPL_DIR, 'ruby_builtin_default.rb')
+      INTERACTIVE_TMPL = File.join(TMPL_DIR, 'ruby_builtin_interactive.rb')
+
+      attr_reader :cfg, :pbm
+
+      def initialize(cfg = nil)
+        @cfg = cfg || {}
+      end
+
+      def process(pbm)
+        src = generate(pbm)
+        pbm.add_src(:rb, src)
+      end
+
+      def generate(pbm)
+        @pbm = pbm
+        File
+          .read(select_template)
+          .gsub('### URL ###', pbm.url)
+          .gsub('### DCLS ###', gen_decls.join("\n"))
+          .gsub('### OUTPUT ###', gen_output)
+      end
+
+      def select_template(interactive = pbm.options.interactive)
+        interactive ? interactive_template : default_template
+      end
+
+      def default_template
+        cfg['default_template'] || DEFAULT_TMPL
+      end
+
+      def interactive_template
+        cfg['interactive_template'] || INTERACTIVE_TMPL
+      end
+
+      def gen_decls(inpdefs = pbm.formats)
+        inpdefs.map { |inpdef| gen_decl(inpdef) }.flatten
+      end
+
+      def gen_decl(inpdef)
+        case inpdef.container
+        when :single
+          gen_single_decl(inpdef)
+        when :harray
+          gen_harray_decl(inpdef)
+        when :varray
+          if inpdef.names.size == 1
+            gen_varray_1_decl(inpdef)
+          else
+            gen_varray_n_decl(inpdef)
+          end
+        when :matrix
+          gen_matrix_decl(inpdef)
+        end
+      end
+
+      def gen_single_decl(inpdef)
+        names = inpdef.names
+        dcl = names.join(', ')
+        expr = gen_expr(inpdef.item, names.size > 1)
+        "#{dcl} = #{expr}"
+      end
+
+      def gen_harray_decl(inpdef)
+        v = inpdef.names[0]
+        dcl = "#{v}s"
+        expr = gen_expr(inpdef.item, true)
+        "#{dcl} = #{expr}"
+      end
+
+      def gen_varray_1_decl(inpdef)
+        v = inpdef.names[0]
+        sz = inpdef.size[0]
+        dcl = "#{v}s"
+        expr = gen_expr(inpdef.item, false)
+        "#{dcl} = Array.new(#{sz}) { #{expr} }"
+      end
+
+      def gen_varray_n_decl(inpdef)
+        names = inpdef.names
+        sz = inpdef.size[0]
+        dcl = names.map { |v| "#{v}s[i]" }.join(', ')
+        expr = gen_expr(inpdef.item, true)
+        ret = []
+        ret += names.map { |v| "#{v}s = Array.new(#{sz})" }
+        ret << "#{sz}.times do |i|"
+        ret << "  #{dcl} = #{expr}"
+        ret << 'end'
+        ret
+      end
+
+      def gen_matrix_decl(inpdef)
+        v = inpdef.names[0]
+        sz = inpdef.size[0]
+        decl = "#{v}ss"
+        expr = gen_expr(inpdef.item, true)
+        "#{decl} = Array.new(#{sz}) { #{expr} }"
+      end
+
+      def gen_expr(item, split)
+        case item
+        when :number
+          split ? 'gets.split.map(&:to_i)' : 'gets.to_i'
+        when :string
+          split ? 'gets.chomp.split' : 'gets.chomp'
+        when :char
+          'gets.chomp'
+        end
+      end
+
+      def gen_output(vs = pbm.options.binary_values)
+        if vs
+          "puts cond ? '#{vs[0]}' : '#{vs[1]}'"
+        else
+          'puts ans'
+        end
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/binary.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Parser
+    # detect binary problem
+    module Binary
+      module_function
+
+      def process(pbm)
+        vs = exp_values(pbm)
+        return unless vs.size == 2
+        return if vs.any? { |v| v.include?("\n") }
+        return if vs.any? { |v| v =~ /^[0-9\s]*$/ }
+
+        out_fmt = ouput_format(pbm)
+        re1, re2 = vs.map { |v| Regexp.escape(v) }
+
+        pbm.options.binary_values =
+          if out_fmt =~ /#{re1}.+#{re2}/m
+            vs
+          elsif out_fmt =~ /#{re2}.+#{re1}/m
+            vs.reverse
+          end
+      end
+
+      def exp_values(pbm)
+        pbm
+          .samples
+          .select { |smp| smp.ext == :exp }
+          .map { |smp| smp.txt.chomp }
+          .uniq
+      end
+
+      def ouput_format(pbm)
+        pbm.sections[Problem::SECTION_OUT_FMT]&.content || ''
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/constraints.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Parser
+    # parses constraints
+    module Constraints
+      module_function
+
+      SECTIONS = [
+        Problem::SECTION_IN_FMT,
+        Problem::SECTION_IO_FMT,
+        Problem::SECTION_CONSTRAINTS
+      ].freeze
+
+      def process(pbm)
+        str = SECTIONS.reduce('') do |m, key|
+          m + (pbm.sections[key]&.content || '')
+        end
+        constraints = parse(str)
+        pbm.constraints = constraints
+      end
+
+      def parse(str)
+        str
+          .gsub(/[,\\(){}|]/, '')
+          .gsub(/(≤|leq?)/i, '≦')
+          .scan(/([\da-z_]+)\s*≦\s*(\d+)(?:\^(\d+))?/i)
+          .map do |v, sz, k|
+            sz = sz.to_i
+            sz **= k.to_i if k
+            Problem::Constraint.new(v, :max, sz)
+          end
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/{format_parser.rb → input_format.rb}

@@ -2,28 +2,11 @@
 
 module AtCoderFriends
   module Parser
-    # parses input data format and generates input definitons
-    module FormatParser
-      module_function
-
-      # Iterates through elements of an array
-      class Iterator
-        def initialize(array)
-          @array = array
-          @i = 0
-        end
-
-        def next?
-          @i < @array.size
-        end
-
-        def next
-          ret = @array[@i]
-          @i += 1
-          ret
-        end
-      end
-
+    module InputFormatConstants
+      SECTIONS = [
+        Problem::SECTION_IN_FMT,
+        Problem::SECTION_IO_FMT
+      ].freeze
       PARSERS = [
         {
           container: :harray,
@@ -77,18 +60,47 @@ module AtCoderFriends
           size: ->(_) { [] }
         }
       ].freeze
+    end
+
+    # parses input data format and generates input definitons
+    module InputFormat
+      include InputFormatConstants
+
+      module_function
+
+      # Iterates through elements of an array
+      class Iterator
+        def initialize(array)
+          @array = array
+          @i = 0
+        end
+
+        def next?
+          @i < @array.size
+        end
+
+        def next
+          ret = @array[@i]
+          @i += 1
+          ret
+        end
+      end
 
       def process(pbm)
-        defs = parse(pbm.fmt, pbm.smps)
-        pbm.defs = defs
+        str =
+          SECTIONS
+          .map { |key| pbm.sections[key]&.code_block }
+          .find(&:itself) || ''
+        inpdefs = parse(str, pbm.samples)
+        pbm.formats = inpdefs
       end
 
-      def parse(fmt, smps)
-        lines = normalize(fmt)
-        defs = parse_fmt(lines)
+      def parse(str, smps)
+        lines = normalize(str)
+        inpdefs = parse_fmt(lines)
         smpx = max_smp(smps)
-        smpx && match_smp!(defs, smpx)
-        defs
+        smpx && match_smp!(inpdefs, smpx)
+        inpdefs
       end
 
       def normalize(fmt)
@@ -125,7 +137,7 @@ module AtCoderFriends
               break unless pat2 && pat2 =~ cur
             end
             size = parser[:size].call(prv)
-            y << InputDef.new(container, item, names, size)
+            y << Problem::InputFormat.new(container, item, names, size)
           end
         end.to_a
       end

data/lib/at_coder_friends/parser/interactive.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Parser
+    # detect interactive problem
+    module Interactive
+      module_function
+
+      INTERACTIVE_PAT = '(インタラクティブ|interactive|リアクティブ|reactive)'
+      FLUSH_PAT = 'flush'
+
+      def process(pbm)
+        pbm.options.interactive = false
+
+        body = pbm.page_body
+        f_int = body =~ /#{INTERACTIVE_PAT}/i
+        f_flush = body =~ /#{FLUSH_PAT}/i
+        f_io = pbm.sections[Problem::SECTION_IO_FMT]
+        f_tbl =
+          pbm
+          .sections[Problem::SECTION_IO_SMP]
+          &.find_element(%w[table])
+        return unless [f_int, f_flush, f_io, f_tbl].count(&:itself) > 1
+
+        pbm.options.interactive = true
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/main.rb

@@ -7,9 +7,12 @@ module AtCoderFriends
       module_function
 
       def process(pbm)
-        PageParser.process(pbm)
-        FormatParser.process(pbm)
-        ConstraintsParser.process(pbm)
+        Sections.process(pbm)
+        SampleData.process(pbm)
+        InputFormat.process(pbm)
+        Constraints.process(pbm)
+        Interactive.process(pbm)
+        Binary.process(pbm)
       end
     end
   end

data/lib/at_coder_friends/parser/sample_data.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'English'
+
+module AtCoderFriends
+  module Parser
+    # parses sample data and sets to problem
+    module SampleData
+      module_function
+
+      def process(pbm)
+        pbm.sections.each do |key, section|
+          ext =
+            if key =~ Problem::SECTION_IN_SMP_PAT
+              :in
+            elsif key =~ Problem::SECTION_OUT_SMP_PAT
+              :exp
+            end
+          ext && pbm.add_smp($LAST_MATCH_INFO[:no], ext, section.code_block)
+        end
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/section_wrapper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module AtCoderFriends
+  module Parser
+    # holds section in problrem page
+    class SectionWrapper
+      attr_reader :h
+
+      def initialize(h)
+        @h = h
+      end
+
+      def siblings
+        @siblings ||= begin
+          ret = []
+          nx = h.next
+          while nx && nx.name != h.name
+            ret << nx
+            nx = nx.next
+          end
+          ret
+        end
+      end
+
+      def content
+        @content ||= begin
+          siblings.reduce('') { |m, node| m + node.content.gsub("\r\n", "\n") }
+        end
+      end
+
+      def find_element(tags)
+        siblings.each do |node|
+          tags.each do |tag|
+            elem = node.name == tag ? node : node.search(tag)[0]
+            return elem if elem
+          end
+        end
+        nil
+      end
+
+      def code_block
+        @code_block ||= begin
+          elem = find_element(%w[pre blockquote])
+          (elem&.content || '').lstrip.gsub("\r\n", "\n")
+        end
+      end
+    end
+  end
+end

data/lib/at_coder_friends/parser/{page_parser.rb → sections.rb}

@@ -2,27 +2,39 @@
 
 module AtCoderFriends
   module Parser
-    # parses problem page and collect problem information
-    module PageParser
-      module_function
-
-      SECTION_TYPES = [
+    module SectionsConstants
+      SECTION_DEFS = [
         {
-          key: 'constraints',
+          key: Problem::SECTION_CONSTRAINTS,
           patterns: [
             '^制約$',
+            '^入力制限$',
             '^Constraints$'
           ]
         },
         {
-          key: 'input format',
+          key: Problem::SECTION_IN_FMT,
           patterns: [
-            '^入出?力(形式)?$',
-            '^Inputs?\s*(,|and)?\s*(Outputs?)?\s*(Format)?$'
+            '^入力(形式)?$',
+            '^Inputs?\s*(Format)?$'
           ]
         },
         {
-          key: 'sample input %<no>s',
+          key: Problem::SECTION_OUT_FMT,
+          patterns: [
+            '^出力(形式)?$',
+            '^Outputs?\s*(Format)?$'
+          ]
+        },
+        {
+          key: Problem::SECTION_IO_FMT,
+          patterns: [
+            '^入出力(形式)?$',
+            '^Input\s*(and)?\s*Output\s*(Format)?$'
+          ]
+        },
+        {
+          key: Problem::SECTION_IN_SMP,
           patterns: [
             '^入力例\s*(?<no>\d+)?$',
             '^入力\s*(?<no>\d+)$',
@@ -32,7 +44,7 @@ module AtCoderFriends
           ]
         },
         {
-          key: 'sample output %<no>s',
+          key: Problem::SECTION_OUT_SMP,
           patterns: [
             '^出力例\s*(?<no>\d+)?$',
             '^出力\s*(?<no>\d+)$',
@@ -42,33 +54,46 @@ module AtCoderFriends
             '^Output\s*(?<no>\d+)$',
             '^Output\s*for\s*(the)?\s*Sample\s*Input\s*(?<no>\d+)?$'
           ]
+        },
+        {
+          key: Problem::SECTION_IO_SMP,
+          patterns: [
+            '^入出力の?例\s*(\d+)?$',
+            '^サンプル\s*(\d+)?$',
+            '^Sample\s*Input\s*(and)?\s*Output\s*(\d+)?$',
+            '^Samples?\s*(\d+)?$'
+          ]
         }
       ].freeze
+    end
+
+    # parses problem page and builds section table
+    module Sections
+      include SectionsConstants
+
+      module_function
 
       def process(pbm)
         sections = collect_sections(pbm.page)
-        apply_sections(pbm, sections)
+        pbm.sections = sections
       end
 
       def collect_sections(page)
-        sections = {}
-        %w[h2 h3].each do |tag|
+        %w[h2 h3].each_with_object({}) do |tag, sections|
           page
             .search(tag)
             .each do |h|
               key = find_key(h)
-              key && sections[key] ||= parse_section(h)
+              key && sections[key] ||= SectionWrapper.new(h)
             end
         end
-        sections
       end
 
       def find_key(h)
         title = normalize(h.content)
-        SECTION_TYPES.each do |grp|
+        SECTION_DEFS.each do |grp|
           grp[:patterns].each do |pat|
-            m = title.match(/#{pat}/i)
-            next unless m
+            next unless (m = title.match(/#{pat}/i))
 
             no = m.names.include?('no') && m['no'] || '1'
             return format(grp[:key], no: no)
@@ -77,37 +102,6 @@ module AtCoderFriends
         nil
       end
 
-      def parse_section(h)
-        text = ''
-        pre = nil
-        nx = h.next
-        while nx && nx.name != h.name
-          text += nx.content.gsub("\r\n", "\n")
-          %w[pre blockquote].each do |tag|
-            pre ||= (nx.name == tag ? nx : nx.search(tag)[0])
-          end
-          nx = nx.next
-        end
-        code = (pre&.text || '').lstrip.gsub("\r\n", "\n")
-        [text, code]
-      end
-
-      def apply_sections(pbm, sections)
-        sections.each do |key, (text, code)|
-          case key
-          when 'constraints'
-            pbm.desc += text
-          when 'input format'
-            pbm.desc += text
-            pbm.fmt = code
-          when /^sample input (?<no>\d+)$/
-            pbm.add_smp($LAST_MATCH_INFO[:no], :in, code)
-          when /^sample output (?<no>\d+)$/
-            pbm.add_smp($LAST_MATCH_INFO[:no], :exp, code)
-          end
-        end
-      end
-
       def normalize(s)
         s
           .tr('　０-９Ａ-Ｚａ-ｚ', ' 0-9A-Za-z')