cafe-grader-judge-scripts

Commit r250:f064c4426ba6 public

parent | child
Description:
merge algo-bm
Commit status:
[Not Reviewed]
References:
merge algo
Diff options:
Raw Diff | Patch Diff | Download Diff | Ignore whitespace | Increase context
Comments:
0 Commit comments 0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
Side by Side Unified
Expand All Files Collapse All Files Wide Mode Diff
Add another comment
Browse Files

r250:f064c4426ba6 - - 4 files changed: 119 inserted, 8 deleted

Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -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 +
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,220 +1,226
1 1 #!/usr/bin/env ruby
2 2
3 3 require 'erb'
4 4 require 'fileutils'
5 5 require File.join(File.dirname(__FILE__),'lib/import_helper')
6 6
7 7 JUDGE_ENVIRONMENTS = [:grading, :exam]
8 8 ENV_INFO = {
9 9 :grading => {
10 10 :ev_dir => 'ev',
11 11 :raw_prefix => '',
12 12 },
13 13 :exam => {
14 14 :ev_dir => 'ev-exam',
15 15 :raw_prefix => 'ex.',
16 16 }
17 17 }
18 18
19 19 def input_filename(dir,i)
20 20 "#{dir}/input-#{i}.txt"
21 21 end
22 22
23 23 def answer_filename(dir,i)
24 24 "#{dir}/answer-#{i}.txt"
25 25 end
26 26
27 27 def build_testrun_info_from_dir(num_testruns, importing_test_dir, raw_prefix='')
28 28 filenames = Dir["#{importing_test_dir}/#{raw_prefix}*.in"].collect do |filename|
29 29 File.basename((/(.*)\.in/.match(filename))[1])
30 30 end
31 31 build_testrun_info(num_testruns,filenames,raw_prefix)
32 32 end
33 33
34 34 def copy_testcase(importing_test_dir,fname,dir,i)
35 - FileUtils.cp("#{importing_test_dir}/#{fname}.in", "#{input_filename(dir,i)}")
36 - FileUtils.cp("#{importing_test_dir}/#{fname}.sol", "#{answer_filename(dir,i)}")
35 + #copy the file from importing dir and also remove carriage return
36 + a = File.read("#{importing_test_dir}/#{fname}.in").gsub(/\r\n?/,"\n")
37 + File.write("#{input_filename(dir,i)}",a)
38 + b = File.read("#{importing_test_dir}/#{fname}.sol").gsub(/\r\n?/,"\n")
39 + File.write("#{answer_filename(dir,i)}",b)
37 40 end
38 41
39 42 def process_options(options)
40 43 i = 3
41 44 while i<ARGV.length
42 45 if ARGV[i]=='-t'
43 46 options[:time_limit] = ARGV[i+1].to_f if ARGV.length>i+1
44 47 i += 1
45 48 end
46 49 if ARGV[i]=='-m'
47 50 options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
48 51 i += 1
49 52 end
50 53 i += 1
51 54 end
52 55 end
53 56
54 57 def print_usage
55 58 puts "using: import_problem_new name dir check [options]
56 59
57 60 where: name = problem_name (put '-' (dash) to use dir name)
58 61 dir = importing testcase directory
59 62 check = check script, which can be
60 63 'integer', 'text' (for standard script),
61 64 path_to_your_script, or
62 65 'wrapper:(path_to_your_wrapped_script)'
63 66 options: -t time-limit (in seconds)
64 67 -m memory-limit (in megabytes)
65 68
66 69 The script looks at test data files in the dir of the forms: *.in and
67 70 *.sol and import them to the evaluation dir for their environment,
68 71 based on their prefixes.
69 72
70 73 Currently supporting environments are:"
71 74
72 75 JUDGE_ENVIRONMENTS.each do |env|
73 76 prefix = ENV_INFO[env][:raw_prefix]
74 77 prefix = 'no prefix' if prefix==''
75 78 puts " * #{env}"
76 79 puts " import to: #{ENV_INFO[env][:ev_dir]}"
77 80 puts " prefix with: #{prefix} (e.g., #{ENV_INFO[env][:raw_prefix]}1.in, #{ENV_INFO[env][:raw_prefix]}5a.sol)"
78 81 end
79 82
80 83 puts"
81 84 For each environment, the script
82 85 * creates a directory for a problem in ev dir of that environment,
83 86 * copies testdata in the old format and create standard testcase config file
84 87 * copies a check script for grading
85 88 * creates a test_request template in the ev dir + '/test_request'
86 89
87 90 For wrapped checked script see comment in templates/check_wrapper for
88 91 information."
89 92 end
90 93
91 94 def count_testruns(testcase_dir, raw_prefix)
92 95 n = 0
93 96 begin
94 97 # check for test case n+1
95 98 if ((Dir["#{testcase_dir}/#{raw_prefix}#{n+1}.in"].length==0) and
96 99 (Dir["#{testcase_dir}/#{raw_prefix}#{n+1}[a-z].in"].length==0))
97 100 return n
98 101 end
99 102 n += 1
100 103 end while true
101 104 end
102 105
103 - def create_dir_if_not_exists(dir)
106 + def create_dir_if_not_exists(dir, options = {} )
104 107 if ! FileTest.exists? dir
105 108 FileUtils.mkdir(dir)
106 109 end
110 +
111 + FileUtils.rm_rf(Dir.glob("#{dir}/*")) if options[:clear]
107 112 end
108 113
109 114 def import_problem(ev_dir, problem, testcase_dir, num_testruns, raw_prefix, check_script, options)
110 115 testrun_info = build_testrun_info_from_dir(num_testruns, testcase_dir, raw_prefix)
111 116
112 117 if !(FileTest.exists? ev_dir)
113 118 puts "Testdata dir (#{ev_dir}) not found."
114 119 return
115 120 end
116 121
117 122 problem_dir = "#{ev_dir}/#{problem}"
118 123
119 124 # start working
120 125 puts "creating directories"
121 126
122 127 create_dir_if_not_exists("#{problem_dir}")
123 128 create_dir_if_not_exists("#{problem_dir}/script")
124 - create_dir_if_not_exists("#{problem_dir}/test_cases")
129 + create_dir_if_not_exists("#{problem_dir}/test_cases",clear: true)
130 + # clear test cases directory
125 131
126 132 puts "copying testcases"
127 133
128 134 tr_num = 0
129 135
130 136 num_testcases = 0
131 137
132 138 testrun_info.each do |testrun|
133 139 tr_num += 1
134 140 puts "testrun: #{tr_num}"
135 141
136 142 testrun.each do |testcase_info|
137 143 testcase_num, testcase_fname = testcase_info
138 144
139 145 puts "copy #{testcase_fname} to #{testcase_num}"
140 146
141 147 create_dir_if_not_exists("#{problem_dir}/test_cases/#{testcase_num}")
142 148 copy_testcase("#{testcase_dir}",testcase_fname,"#{problem_dir}/test_cases/#{testcase_num}",testcase_num)
143 149
144 150 num_testcases += 1
145 151 end
146 152 end
147 153
148 154 #also include any .txt files
149 155 Dir.glob("#{testcase_dir}/*.txt") do |file|
150 156 puts "copy data file #{file}"
151 157 FileUtils.cp(file,"#{problem_dir}")
152 158 end
153 159
154 160 # generating all_tests.cfg
155 161 puts "generating testcase config file"
156 162
157 163 template = File.open(SCRIPT_DIR + "/templates/all_tests.cfg.erb").read
158 164 all_test_cfg = ERB.new(template)
159 165
160 166 cfg_file = File.open("#{problem_dir}/test_cases/all_tests.cfg","w")
161 167 cfg_file.puts all_test_cfg.result binding
162 168 cfg_file.close
163 169
164 170 # copy check script
165 171 if res = /^wrapper:(.*)$/.match(check_script)
166 172 # wrapper script
167 173 check_script_fname = res[1]
168 174 script_name = File.basename(check_script_fname)
169 175 check_wrapper_template = File.open(SCRIPT_DIR + "/templates/check_wrapper").read
170 176 check_wrapper = ERB.new(check_wrapper_template)
171 177
172 178 check_file = File.open("#{problem_dir}/script/check","w")
173 179 check_file.puts check_wrapper.result binding
174 180 check_file.close
175 181
176 182 File.chmod(0755,"#{problem_dir}/script/check")
177 183
178 184 FileUtils.cp("#{check_script_fname}", "#{problem_dir}/script/#{script_name}")
179 185 else
180 186 if File.exists?(SCRIPT_DIR + "/templates/check.#{check_script}")
181 187 check_script_fname = SCRIPT_DIR + "/templates/check.#{check_script}"
182 188 else
183 189 check_script_fname = check_script
184 190 end
185 191 FileUtils.cp("#{check_script_fname}", "#{problem_dir}/script/check", :preserve => true)
186 192 end
187 193
188 194 # generating test_request directory
189 195 puts "generating test_request template"
190 196 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/script")
191 197 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/test_cases/1")
192 198
193 199 template = File.open(SCRIPT_DIR + "/templates/test_request_all_tests.cfg.erb").read
194 200 test_request_all_test_cfg = ERB.new(template)
195 201
196 202 cfg_file = File.open("#{ev_dir}/test_request/#{problem}/test_cases/all_tests.cfg","w")
197 203 cfg_file.puts test_request_all_test_cfg.result
198 204 cfg_file.close
199 205
200 206 FileUtils.cp("#{SCRIPT_DIR}/templates/check_empty",
201 207 "#{ev_dir}/test_request/#{problem}/script/check")
202 208 FileUtils.cp("#{SCRIPT_DIR}/templates/answer-1.txt",
203 209 "#{ev_dir}/test_request/#{problem}/test_cases/1")
204 210
205 211 puts "done"
206 212 end
207 213
208 214
209 215 SCRIPT_DIR = File.dirname(__FILE__)
210 216
211 217 # print usage
212 218 if (ARGV.length < 3) or (ARGV[2][0,1]=="-")
213 219 print_usage
214 220 exit(127)
215 221 end
216 222
217 223 # processing arguments
218 224 problem = ARGV[0]
219 225 testcase_dir = ARGV[1]
220 226 problem = File.basename(testcase_dir) if problem=="-"
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,85 +1,88
1 1 #!/usr/bin/env ruby
2 2
3 3 def config
4 4 Grader::Configuration.get_instance
5 5 end
6 6
7 7 def display_manual
8 8 puts <<USAGE
9 9 load_testcases
10 10 using: load_testcases [problem_name ...]
11 11 problem_name are list of "short name" of the problems
12 12
13 13 options:
14 14 --dry-run do nothing, just simulate the run
15 15 --all import all problem. This might take several minutes
16 16
17 17 USAGE
18 18 end
19 19
20 20 def process_options_and_stop_file
21 21
22 22 # Process 'help' option
23 23 if (ARGV.length == 0) or ((ARGV.length==1) and (/help/.match(ARGV[0])))
24 24 display_manual
25 25 exit(0)
26 26 end
27 27
28 28 #default options
29 29 options = {
30 30 :dry_run => false,
31 31 }
32 32
33 33 options[:dry_run] = (ARGV.delete('--dry') != nil)
34 34 options[:all] = (ARGV.delete('--all') != nil)
35 35
36 36 return options
37 37 end
38 38
39 39 def process_problem(prob,dry_run = false)
40 40 prob.testcases.destroy_all
41 41 testcases_root = File.expand_path(GRADER_ROOT+"/../ev/#{prob.name}/test_cases/")
42 42 num = 1
43 43 puts "Processing problem #{prob.name}"
44 44 loop do
45 45 file_root = testcases_root + "/#{num}/"
46 46 puts " checking file #{file_root}"
47 47 break unless File.exists? file_root
48 48 input = File.read(file_root + "/input-#{num}.txt")
49 49 answer = File.read(file_root + "/answer-#{num}.txt")
50 + #we also remove carraige return
51 + input.gsub!(/\r\n?/,"\n")
52 + answer.gsub!(/\r\n?/,"\n")
50 53 puts " got test case ##{num} of size #{input.size} and #{answer.size}"
51 54
52 55 #THIS IS JUST A PLACE HOLDER
53 56 group = num #this is wrong!!! fix it!!
54 57 score = 10
55 58 #BEWARE
56 59
57 60 prob.testcases.create(input: input,sol: answer, num: num, score:score,group: group) unless dry_run
58 61 num += 1
59 62 end
60 63 end
61 64
62 65 #########################################
63 66 # main program
64 67 #########################################
65 68
66 69 options = process_options_and_stop_file
67 70
68 71 # load grader environment
69 72 GRADER_ENV = 'grading'
70 73 require File.join(File.dirname(__FILE__),'config/environment')
71 74
72 75 # boot rails, to be able to use the active record
73 76 RAILS_ENV = config.rails_env
74 77 require RAILS_ROOT + '/config/environment'
75 78
76 79 if options[:all]
77 80 Problem.all.each { |prob| process_problem(prob,options[:dry_run]) }
78 81 else
79 82 ARGV.each do |name|
80 83 prob = Problem.find_by(name: name)
81 84 process_problem(prob,options[:dry_run]) if prob
82 85 puts "Cannot find the problem #{name}" unless prob
83 86 end
84 87 end
85 88
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,66 +1,75
1 1 #!/usr/bin/env ruby
2 2
3 3 problem_home = ENV['PROBLEM_HOME']
4 4 require "#{problem_home}/script/test_dsl.rb"
5 5
6 6 if ARGV.length < 2
7 7 puts "Usage: check <language> <test-number> [<output-file>]"
8 8 exit(0)
9 9 end
10 10
11 11 language = ARGV[0]
12 12 test_num = ARGV[1].to_i
13 13 if ARGV.length >= 3
14 14 output_file_name = ARGV[2]
15 15 else
16 16 output_file_name = "output.txt"
17 17 end
18 18
19 19 load "#{problem_home}/test_cases/all_tests.cfg"
20 20 problem = Problem.get_instance
21 21
22 22 output_file = File.new(output_file_name, "r")
23 23 answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
24 24 result_file = File.new("check_result", "w")
25 25
26 26 output_file_content = output_file.read
27 27 answer_file_content = answer_file.read
28 28
29 29 report_correct = lambda {
30 30 result_file.write "Correct\n"
31 31 result_file.write problem.get_score(test_num)
32 32 result_file.write "\n"
33 33 result_file.close
34 34 exit(0)
35 35 }
36 36
37 37 report_wrong = lambda {
38 38 result_file.write "Incorrect\n"
39 39 result_file.write "0\n"
40 40 result_file.close
41 41 exit(0)
42 42 }
43 43
44 44 ##################
45 45 # Your code here #
46 46 ##################
47 47
48 48 ########### THIS IS FOR CHECKING FLOAT with EPSILON error ##########
49 49
50 +
51 + def is_float?(fl)
52 + !!Float(fl) rescue false
53 + end
54 +
50 55 EPSILON = 0.000001
51 56
52 57 out_items = output_file_content.split
53 58 ans_items = answer_file_content.split
54 59
55 60 if out_items.length != ans_items.length
56 61 report_wrong.call
57 62 else
58 63 out_items.length.times do |i|
59 - out_value = out_items[i].to_f
60 - ans_value = ans_items[i].to_f
61 - if (out_value - ans_value).abs > EPSILON * [out_value.abs,ans_value.abs].max
62 - report_wrong.call
64 + if is_float?(out_items[i]) && is_float?(ans_items[i])
65 + out_value = out_items[i].to_f
66 + ans_value = ans_items[i].to_f
67 + if (out_value - ans_value).abs > EPSILON * [out_value.abs,ans_value.abs].max
68 + report_wrong.call
69 + end
70 + else
71 + report_wrong.call if out_items[i] != ans_items[i]
63 72 end
64 73 end
65 74 report_correct.call
66 75 end
You need to be logged in to leave comments. Login now