cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r250:f064c4426ba6` public

parent | child

Description:

merge algo-bm

Commit status:

[Not Reviewed]

References:

merge algo

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r250:f064c4426ba6 - Tue, 12 Jun 2018 09:37:31 - 4 files changed: 119 inserted, 8 deleted

check_similar created 755 ¶ +93

@@ -0,0 +1,93
	1	+ #!/usr/bin/env ruby
	2	+
	3	+ def config
	4	+ Grader::Configuration.get_instance
	5	+ end
	6	+
	7	+ def display_manual
	8	+ puts <<USAGE
	9	+ Check similarity between submission
	10	+ using: check_similar sub1 sub2
	11	+ -- or --
	12	+ check_similar problem_name
	13	+ sub1 and sub2 are submission IDs to be checked
	14	+ problem_name will check all submissions of the problem wit problem short name is 'problem_name'
	15	+
	16	+ The output are given as
	17	+ sub1.login, sub1.id, sub1.point, sub2.login, sub2.id, sub2.point, similarity
	18	+
	19	+ USAGE
	20	+ end
	21	+
	22	+ def process_options_and_stop_file
	23	+
	24	+ # Process 'help' option
	25	+ if (ARGV.length == 0) or ((ARGV.length==1) and (/help/.match(ARGV[0])))
	26	+ display_manual
	27	+ exit(0)
	28	+ end
	29	+
	30	+ #default options
	31	+ options = {
	32	+ :dry_run => false,
	33	+ }
	34	+
	35	+
	36	+ if ARGV.length == 2
	37	+ options[:sub1] = ARGV[0].to_i
	38	+ options[:sub2] = ARGV[1].to_i
	39	+ elsif ARGV.length == 1
	40	+ options[:problem] = ARGV[0]
	41	+ end
	42	+
	43	+
	44	+ return options
	45	+ end
	46	+
	47	+ def compare(sub1,sub2,full = sub1.problem.full_score)
	48	+ dis = @jarow.getDistance(sub1.source, sub2.source)
	49	+ puts [sub1.user.login,"##{sub1.id}",(sub1.points * 100.0 / full).to_i,
	50	+ sub2.user.login,"##{sub2.id}",(sub2.points * 100.0 / full).to_i,
	51	+ "#{dis * 100}%"].join(',')
	52	+ end
	53	+
	54	+ #########################################
	55	+ # main program
	56	+ #########################################
	57	+
	58	+ options = process_options_and_stop_file
	59	+
	60	+ # load grader environment
	61	+ GRADER_ENV = 'grading'
	62	+ require File.join(File.dirname(__FILE__),'config/environment')
	63	+
	64	+ # boot rails, to be able to use the active record
	65	+ RAILS_ENV = config.rails_env
	66	+ require RAILS_ROOT + '/config/environment'
	67	+
	68	+ # load comparator
	69	+ require 'fuzzystringmatch'
	70	+ @jarow = FuzzyStringMatch::JaroWinkler.create( :native )
	71	+
	72	+ if options[:problem]
	73	+ p = Problem.where(name: options[:problem]).first
	74	+ unless p
	75	+ puts "cannot find problem #{options[:problem]}"
	76	+ exit(0)
	77	+ end
	78	+ subs = Submission.where(problem: p)
	79	+ full_score = p.full_score.to_i
	80	+ subs.each.with_index do \|s1,i\|
	81	+ puts "processing #{i+1} out of #{subs.length}"
	82	+ subs.each do \|s2\|
	83	+ if s1.user != s2.user
	84	+ compare(s1,s2,full_score)
	85	+ end
	86	+ end
	87	+ end
	88	+ else
	89	+ sub1 = Submission.find(options[:sub1])
	90	+ sub2 = Submission.find(options[:sub2])
	91	+ compare(sub1,sub2)
	92	+ end
	93	+

import_problem ¶ +10 -4

               #!/usr/bin/env ruby
               require 'erb'
               require 'fileutils'
               require File.join(File.dirname(__FILE__),'lib/import_helper')
               JUDGE_ENVIRONMENTS = [:grading, :exam]
               ENV_INFO = {
                 :grading => {
                   :ev_dir => 'ev',
                   :raw_prefix => '',
                 },
                 :exam => {
                   :ev_dir => 'ev-exam',
                   :raw_prefix => 'ex.',
                 }
               }
               def input_filename(dir,i)
                 "#{dir}/input-#{i}.txt"
               end
               def answer_filename(dir,i)
                 "#{dir}/answer-#{i}.txt"
               end
               def build_testrun_info_from_dir(num_testruns, importing_test_dir, raw_prefix='')
                 filenames = Dir["#{importing_test_dir}/#{raw_prefix}*.in"].collect do |filename|
                   File.basename((/(.*)\.in/.match(filename))[1])
                 end
                 build_testrun_info(num_testruns,filenames,raw_prefix)
               end
               def copy_testcase(importing_test_dir,fname,dir,i)
-            -   FileUtils.cp("#{importing_test_dir}/#{fname}.in", "#{input_filename(dir,i)}")
+            +   #copy the file from importing dir and also remove carriage return
-            -   FileUtils.cp("#{importing_test_dir}/#{fname}.sol", "#{answer_filename(dir,i)}")
+            +   a = File.read("#{importing_test_dir}/#{fname}.in").gsub(/\r\n?/,"\n")
+            +   File.write("#{input_filename(dir,i)}",a)
+            +   b = File.read("#{importing_test_dir}/#{fname}.sol").gsub(/\r\n?/,"\n")
+            +   File.write("#{answer_filename(dir,i)}",b)
               end
               def process_options(options)
                 i = 3
                 while i<ARGV.length
                   if ARGV[i]=='-t'
                     options[:time_limit] = ARGV[i+1].to_f if ARGV.length>i+1
                     i += 1
                   end
                   if ARGV[i]=='-m'
                     options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
                     i += 1
                   end
                   i += 1
                 end
               end
               def print_usage
                 puts "using: import_problem_new name dir check [options]
               where: name = problem_name (put '-' (dash) to use dir name)
                      dir = importing testcase directory
                      check = check script, which can be
                              'integer', 'text' (for standard script),
                              path_to_your_script, or
                              'wrapper:(path_to_your_wrapped_script)'
               options: -t time-limit (in seconds)
                        -m memory-limit (in megabytes)
               The script looks at test data files in the dir of the forms: *.in and
               *.sol and import them to the evaluation dir for their environment,
               based on their prefixes.
               Currently supporting environments are:"
                 JUDGE_ENVIRONMENTS.each do |env|
                   prefix = ENV_INFO[env][:raw_prefix]
                   prefix = 'no prefix' if prefix==''
                   puts "  * #{env}"
                   puts "      import to: #{ENV_INFO[env][:ev_dir]}"
                   puts "      prefix with: #{prefix}  (e.g., #{ENV_INFO[env][:raw_prefix]}1.in, #{ENV_INFO[env][:raw_prefix]}5a.sol)"
                 end
                 puts"
               For each environment, the script
                 * creates a directory for a problem in ev dir of that environment,
                 * copies testdata in the old format and create standard testcase config file
                 * copies a check script for grading
                 * creates a test_request template in the ev dir + '/test_request'
               For wrapped checked script see comment in templates/check_wrapper for
                 information."
               end
               def count_testruns(testcase_dir, raw_prefix)
                 n = 0
                 begin
                   # check for test case n+1
                   if ((Dir["#{testcase_dir}/#{raw_prefix}#{n+1}.in"].length==0) and
                       (Dir["#{testcase_dir}/#{raw_prefix}#{n+1}[a-z].in"].length==0))
                     return n
                   end
                   n += 1
                 end while true
               end
-            - def create_dir_if_not_exists(dir)
+            + def create_dir_if_not_exists(dir, options = {} )
                 if ! FileTest.exists? dir
                   FileUtils.mkdir(dir)
                 end
+            +
+            +   FileUtils.rm_rf(Dir.glob("#{dir}/*")) if options[:clear]
               end
               def import_problem(ev_dir, problem, testcase_dir, num_testruns, raw_prefix, check_script, options)
                 testrun_info = build_testrun_info_from_dir(num_testruns, testcase_dir, raw_prefix)
                 if !(FileTest.exists? ev_dir)
                   puts "Testdata dir (#{ev_dir}) not found."
                   return
                 end
                 problem_dir = "#{ev_dir}/#{problem}"
                 # start working
                 puts "creating directories"
                 create_dir_if_not_exists("#{problem_dir}")
                 create_dir_if_not_exists("#{problem_dir}/script")
-            -   create_dir_if_not_exists("#{problem_dir}/test_cases")
+            +   create_dir_if_not_exists("#{problem_dir}/test_cases",clear: true)
+            +   # clear test cases directory
                 puts "copying testcases"
                 tr_num = 0
                 num_testcases = 0
                 testrun_info.each do |testrun|
                   tr_num += 1
                   puts "testrun: #{tr_num}"
                   testrun.each do |testcase_info|
                     testcase_num, testcase_fname = testcase_info
                     puts "copy #{testcase_fname} to #{testcase_num}"
                     create_dir_if_not_exists("#{problem_dir}/test_cases/#{testcase_num}")
                     copy_testcase("#{testcase_dir}",testcase_fname,"#{problem_dir}/test_cases/#{testcase_num}",testcase_num)
                     num_testcases += 1
                   end
                 end
                 #also include any .txt files
                 Dir.glob("#{testcase_dir}/*.txt") do |file|
                   puts "copy data file #{file}"
                   FileUtils.cp(file,"#{problem_dir}")
                 end
                 # generating all_tests.cfg
                 puts "generating testcase config file"
                 template = File.open(SCRIPT_DIR + "/templates/all_tests.cfg.erb").read
                 all_test_cfg = ERB.new(template)
                 cfg_file = File.open("#{problem_dir}/test_cases/all_tests.cfg","w")
                 cfg_file.puts all_test_cfg.result binding
                 cfg_file.close
                 # copy check script
                 if res = /^wrapper:(.*)$/.match(check_script)
                   # wrapper script
                   check_script_fname = res[1]
                   script_name = File.basename(check_script_fname)
                   check_wrapper_template = File.open(SCRIPT_DIR + "/templates/check_wrapper").read
                   check_wrapper = ERB.new(check_wrapper_template)
                   check_file = File.open("#{problem_dir}/script/check","w")
                   check_file.puts check_wrapper.result binding
                   check_file.close
                   File.chmod(0755,"#{problem_dir}/script/check")
                   FileUtils.cp("#{check_script_fname}", "#{problem_dir}/script/#{script_name}")
                 else
                   if File.exists?(SCRIPT_DIR + "/templates/check.#{check_script}")
                     check_script_fname = SCRIPT_DIR + "/templates/check.#{check_script}"
                   else
                     check_script_fname = check_script
                   end
                   FileUtils.cp("#{check_script_fname}", "#{problem_dir}/script/check", :preserve => true)
                 end
                 # generating test_request directory
                 puts "generating test_request template"
                 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/script")
                 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/test_cases/1")
                 template = File.open(SCRIPT_DIR + "/templates/test_request_all_tests.cfg.erb").read
                 test_request_all_test_cfg = ERB.new(template)
                 cfg_file = File.open("#{ev_dir}/test_request/#{problem}/test_cases/all_tests.cfg","w")
                 cfg_file.puts test_request_all_test_cfg.result
                 cfg_file.close
                 FileUtils.cp("#{SCRIPT_DIR}/templates/check_empty",
                              "#{ev_dir}/test_request/#{problem}/script/check")
                 FileUtils.cp("#{SCRIPT_DIR}/templates/answer-1.txt",
                              "#{ev_dir}/test_request/#{problem}/test_cases/1")
                 puts "done"
               end
               SCRIPT_DIR = File.dirname(__FILE__)
               # print usage
               if (ARGV.length < 3) or (ARGV[2][0,1]=="-")
                 print_usage
                 exit(127)
               end
               # processing arguments
               problem = ARGV[0]
               testcase_dir = ARGV[1]
               problem = File.basename(testcase_dir) if problem=="-"

load_testcase ¶ +3

               #!/usr/bin/env ruby
               def config
                 Grader::Configuration.get_instance
               end
               def display_manual
                 puts <<USAGE
               load_testcases
               using: load_testcases [problem_name ...]
                 problem_name    are list of "short name" of the problems
                 options:
                   --dry-run     do nothing, just simulate the run
                   --all         import all problem. This might take several minutes
               USAGE
               end
               def process_options_and_stop_file
                 # Process 'help' option
                 if (ARGV.length == 0) or ((ARGV.length==1) and (/help/.match(ARGV[0])))
                   display_manual
                   exit(0)
                 end
                 #default options
                 options = {
                   :dry_run => false,
                 }
                 options[:dry_run] = (ARGV.delete('--dry') != nil)
                 options[:all] = (ARGV.delete('--all') != nil)
                 return options
               end
               def process_problem(prob,dry_run = false)
                 prob.testcases.destroy_all
                 testcases_root = File.expand_path(GRADER_ROOT+"/../ev/#{prob.name}/test_cases/")
                 num = 1
                 puts "Processing problem #{prob.name}"
                 loop do
                   file_root = testcases_root + "/#{num}/"
                   puts "  checking file #{file_root}"
                   break unless File.exists? file_root
                   input = File.read(file_root + "/input-#{num}.txt")
                   answer = File.read(file_root + "/answer-#{num}.txt")
+            +     #we also remove carraige return
+            +     input.gsub!(/\r\n?/,"\n")
+            +     answer.gsub!(/\r\n?/,"\n")
                   puts "  got test case ##{num} of size #{input.size} and #{answer.size}"
                   #THIS IS JUST A  PLACE HOLDER
                   group = num #this is wrong!!! fix it!!
                   score = 10
                   #BEWARE
                   prob.testcases.create(input: input,sol: answer, num: num, score:score,group: group) unless dry_run
                   num += 1
                 end
               end
               #########################################
               # main program
               #########################################
               options = process_options_and_stop_file
               # load grader environment
               GRADER_ENV = 'grading'
               require File.join(File.dirname(__FILE__),'config/environment')
               # boot rails, to be able to use the active record
               RAILS_ENV = config.rails_env
               require RAILS_ROOT + '/config/environment'
               if options[:all]
                 Problem.all.each { |prob| process_problem(prob,options[:dry_run]) }
               else
                 ARGV.each do |name|
                   prob = Problem.find_by(name: name)
                   process_problem(prob,options[:dry_run]) if prob
                   puts "Cannot find the problem #{name}" unless prob
                 end
               end

templates/check.float ¶ +13 -4

               #!/usr/bin/env ruby
               problem_home = ENV['PROBLEM_HOME']
               require "#{problem_home}/script/test_dsl.rb"
               if ARGV.length < 2
                 puts "Usage: check <language> <test-number> [<output-file>]"
                 exit(0)
               end
               language = ARGV[0]
               test_num = ARGV[1].to_i
               if ARGV.length >= 3
                 output_file_name = ARGV[2]
               else
                 output_file_name = "output.txt"
               end
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               output_file = File.new(output_file_name, "r")
               answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
               result_file = File.new("check_result", "w")
               output_file_content = output_file.read
               answer_file_content = answer_file.read
               report_correct = lambda {
                 result_file.write "Correct\n"
                 result_file.write problem.get_score(test_num)
                 result_file.write "\n"
                 result_file.close
                 exit(0)
               }
               report_wrong = lambda {
                 result_file.write "Incorrect\n"
                 result_file.write "0\n"
                 result_file.close
                 exit(0)
               }
               ##################
               # Your code here #
               ##################
               ########### THIS IS FOR CHECKING FLOAT with EPSILON error ##########
+            +
+            + def is_float?(fl)
+            +   !!Float(fl) rescue false
+            + end
+            +
               EPSILON = 0.000001
               out_items = output_file_content.split
               ans_items = answer_file_content.split
               if out_items.length != ans_items.length
                 report_wrong.call
               else
                 out_items.length.times do |i|
-            -     out_value = out_items[i].to_f
+            +     if is_float?(out_items[i]) && is_float?(ans_items[i])
-            -     ans_value = ans_items[i].to_f
+            +       out_value = out_items[i].to_f
-            -     if (out_value - ans_value).abs > EPSILON * [out_value.abs,ans_value.abs].max
+            +       ans_value = ans_items[i].to_f
-            -       report_wrong.call
+            +       if (out_value - ans_value).abs > EPSILON * [out_value.abs,ans_value.abs].max
+            +         report_wrong.call
+            +       end
+            +     else
+            +       report_wrong.call if out_items[i] != ans_items[i]
                   end
                 end
                 report_correct.call
               end

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r250:f064c4426ba6 - Tue, 12 Jun 2018 09:37:31 - 4 files changed: 119 inserted, 8 deleted

Sign in to your account

Commit r250:f064c4426ba6 public

Author

r250:f064c4426ba6 - Tue, 12 Jun 2018 09:37:31 - 4 files changed: 119 inserted, 8 deleted

Commit `r250:f064c4426ba6` public