private Tuple <string, List <string> > GetStaticTests(ProblemNames problem) { switch (problem) { case ProblemNames.Summation: return(Tuple.Create("summation_using_accumulate", new List <string>() { "recursion", "for", "while" })); case ProblemNames.G: return(Tuple.Create("g", new List <string>() { "for", "while" })); case ProblemNames.G_iter: return(Tuple.Create("g_iter", new List <string>() { "recursion" })); case ProblemNames.Pingpong: return(Tuple.Create("pingpong", new List <string>() { "Assign", "AugAssign" })); default: return(null); } }
public void ExtractFunctionAndSaveIncorrectBenchmark(ProblemNames problemName) { var problem = GetProblemByName(problemName); if (problem != null) { var file = new DirectoryInfo("../../benchmark_incorrect/" + problem.Id + ".json"); var submissions = JsonConvert.DeserializeObject <List <Mistake> >(File.ReadAllText(file.FullName, Encoding.ASCII)); foreach (var mistake in submissions) { if (mistake.date != null) { mistake.SubmissionTime = DateTime.Parse(mistake.date); } mistake.before = GetQuestion(mistake.before, problemName); } var submissionsToJson = JsonConvert.SerializeObject(submissions); File.WriteAllText(file.FullName, submissionsToJson); } }
private string GetQuestion(string backup, ProblemNames problemName) { int start; int end; switch (problemName) { case ProblemNames.Product: start = backup.IndexOf("def product(", StringComparison.Ordinal); end = backup.IndexOf("def factorial(", StringComparison.Ordinal); break; case ProblemNames.Accumulate: start = backup.IndexOf("def accumulate(", StringComparison.Ordinal); end = backup.IndexOf("def summation_using_accumulate(", StringComparison.Ordinal); break; case ProblemNames.Summation: start = backup.IndexOf("def accumulate(", StringComparison.Ordinal); end = backup.IndexOf("def product_using_accumulate(", StringComparison.Ordinal); break; case ProblemNames.FilteredAccumulate: start = backup.IndexOf("def filtered_accumulate(", StringComparison.Ordinal); end = backup.IndexOf("def repeated(", StringComparison.Ordinal); break; case ProblemNames.Repeated: start = backup.IndexOf("def repeated(", StringComparison.Ordinal); end = backup.IndexOf("def g(", StringComparison.Ordinal); break; case ProblemNames.CountChange: start = backup.IndexOf("def count_change(", StringComparison.Ordinal); end = backup.IndexOf("def move_stack(", StringComparison.Ordinal); break; case ProblemNames.G: start = backup.IndexOf("def g(", StringComparison.Ordinal); end = backup.IndexOf("def g_iter(", StringComparison.Ordinal); break; case ProblemNames.G_iter: start = backup.IndexOf("def g_iter(", StringComparison.Ordinal); end = backup.IndexOf("def pingpong(", StringComparison.Ordinal); break; case ProblemNames.Pingpong: start = backup.IndexOf("def pingpong(", StringComparison.Ordinal); end = backup.IndexOf("def count_change(", StringComparison.Ordinal); break; default: start = 0; end = backup.Length - 1; break; } //it may be possible that the student changed the signature of the method, invalidating the pattern //in this case, consider the whole file. start = start == -1 ? 0 : start; var result = (end == -1 || end < start) ? backup.Substring(start) : backup.Substring(start, end - start); return(result); }
public Problem GetProblemByName(ProblemNames problemName) { return(Problems.First(p => p.Id.Equals(problemName.ToString()))); }
private static Dictionary <string, long> GetTests(ProblemNames problem) { var testSetup = GetTestSetup(); switch (problem) { case ProblemNames.Product: return(new Dictionary <string, long> { { testSetup + "assert(product(3, identity)==6)", 6 }, { "assert(product(5, identity)==120)", 120 }, { "assert(product(3, square)==36)", 36 }, { "assert(product(5, square)==14400)", 14400 } }); case ProblemNames.Repeated: return(new Dictionary <string, long> { { testSetup + "assert(repeated(increment, 3)(5)== 8)", 8 }, { "assert(repeated(triple, 5)(1)==243)", 243 }, { "assert(repeated(square, 2)(5)==625)", 625 }, { "assert(repeated(square, 3)(5)==390625)", 390625 }, { "assert(repeated(square, 0)(5)==5)", 5 } }); case ProblemNames.G: return(new Dictionary <string, long> { { testSetup + "assert(g(1)==1)", 15 }, { "assert(g(2)==2)", 26 }, { "assert(g(3)==3)", 11 }, { "assert(g(4)==10)", 25 }, { "assert(g(5)==22)", 72 } }); case ProblemNames.G_iter: return(new Dictionary <string, long> { { testSetup + "assert(g_iter(1)==1)", 15 }, { "assert(g_iter(2)==2)", 26 }, { "assert(g_iter(3)==3)", 11 }, { "assert(g_iter(4)==10)", 25 }, { "assert(g_iter(5)==22)", 72 } }); case ProblemNames.Accumulate: return(new Dictionary <string, long> { { testSetup + "assert(accumulate(add, 0, 5, identity)==15)", 15 }, { "assert(accumulate(add, 11, 5, identity)==26)", 26 }, { "assert(accumulate(add, 11, 0, identity)==11)", 11 }, { "assert(accumulate(add, 11, 3, square)==25)", 25 }, { "assert(accumulate(mul, 2, 3, square)==72)", 72 } }); case ProblemNames.CountChange: return(new Dictionary <string, long> { { testSetup + "assert(count_change(7)==6)", 6 }, { "assert(count_change(10)==14)", 14 }, { "assert(count_change(20)==60)", 60 }, { "assert(count_change(100)==9828)", 9828 } }); case ProblemNames.Summation: return(new Dictionary <string, long> { { testSetup + "assert(summation_using_accumulate(5, square)==55)", 6 }, { "assert(summation_using_accumulate(5, triple)==45)", 14 }, }); case ProblemNames.FilteredAccumulate: return(new Dictionary <string, long> { { testSetup + "assert(filtered_accumulate(add, 0, true, 5, identity)==15)", 15 }, { "assert(filtered_accumulate(add, 11, false, 5, identity)==11)", 11 }, { "assert(filtered_accumulate(add, 0, odd, 5, identity)==9)", 9 }, { "assert(filtered_accumulate(mul, 1, odd, 5, square)==255)", 255 }, }); case ProblemNames.Pingpong: return(new Dictionary <string, long> { { testSetup + "assert(pingpong(7)==7)", 7 }, { "assert(pingpong(8)==6)", 11 }, { "assert(pingpong(15)==1)", 9 }, { "assert(pingpong(21)==-1)", 255 }, { "assert(pingpong(22)==0)", 255 }, { "assert(pingpong(30)==6)", 255 }, { "assert(pingpong(68)==2)", 255 }, { "assert(pingpong(69)==1)", 255 }, { "assert(pingpong(70)==0)", 255 }, { "assert(pingpong(71)==1)", 255 }, { "assert(pingpong(72)==0)", 255 }, { "assert(pingpong(100)==2)", 255 }, }); } return(null); }