Fix cpp param names

epi_judge_cpp/buy_and_sell_stock_k_times.cc

@@ -10,7 +10,7 @@ double BuyAndSellStockKTimes(const vector<double>& prices, int k) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"&prices", "k"};
+  std::vector<std::string> param_names{"prices", "k"};
   generic_test_main(argc, argv, param_names, "buy_and_sell_stock_k_times.tsv",
                     &BuyAndSellStockKTimes);
   return 0;

epi_judge_cpp/combinations.cc

@@ -10,8 +10,7 @@ vector<vector<int>> Combinations(int n, int k) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"int",          "int", "int",
-                                       "vector<int>*", "n",   "k"};
+  std::vector<std::string> param_names{"n", "k"};
   generic_test_main(argc, argv, param_names, "combinations.tsv", &Combinations,
                     &UnorderedComparator<std::vector<std::vector<int>>>);
   return 0;

epi_judge_cpp/element_appearing_once.cc

@@ -10,7 +10,7 @@ int FindElementAppearsOnce(const vector<int>& A) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"&A"};
+  std::vector<std::string> param_names{"A"};
   generic_test_main(argc, argv, param_names, "element_appearing_once.tsv",
                     &FindElementAppearsOnce);
   return 0;

epi_judge_cpp/enumerate_balanced_parentheses.cc

@@ -12,7 +12,7 @@ vector<string> GenerateBalancedParentheses(int num_pairs) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"int", "int", "string&", "num_pairs"};
+  std::vector<std::string> param_names{"num_pairs"};
   generic_test_main(
       argc, argv, param_names, "enumerate_balanced_parentheses.tsv",
       &GenerateBalancedParentheses, &UnorderedComparator<vector<string>>);

epi_judge_cpp/enumerate_palindromic_decompositions.cc

@@ -20,8 +20,7 @@ bool Comp(vector<vector<string>> expected, vector<vector<string>> result) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"string&", "int", "vector<string>*",
-                                       "input"};
+  std::vector<std::string> param_names{"input"};
   generic_test_main(argc, argv, param_names,
                     "enumerate_palindromic_decompositions.tsv",
                     &PalindromeDecompositions, &Comp);

epi_judge_cpp/insert_operators_in_string.cc

@@ -10,9 +10,7 @@ bool ExpressionSynthesis(const vector<int>& digits, int target) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{
-      "vector<int>&", "int",          "int",    "int",
-      "vector<int>*", "vector<int>&", "digits", "target"};
+  std::vector<std::string> param_names{"digits", "target"};
   generic_test_main(argc, argv, param_names, "insert_operators_in_string.tsv",
                     &ExpressionSynthesis);
   return 0;

epi_judge_cpp/longest_subarray_with_sum_constraint.cc

@@ -10,7 +10,7 @@ int FindLongestSubarrayLessEqualK(const vector<int>& A, int k) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"&A", "k"};
+  std::vector<std::string> param_names{"A", "k"};
   generic_test_main(argc, argv, param_names,
                     "longest_subarray_with_sum_constraint.tsv",
                     &FindLongestSubarrayLessEqualK);

epi_judge_cpp/max_water_trappable.cc

@@ -10,7 +10,7 @@ int CalculateTrappingWater(const vector<int>& heights) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"&heights"};
+  std::vector<std::string> param_names{"heights"};
   generic_test_main(argc, argv, param_names, "max_water_trappable.tsv",
                     &CalculateTrappingWater);
   return 0;

epi_judge_cpp/n_queens.cc

@@ -18,7 +18,7 @@ bool Comp(vector<vector<int>>& a, vector<vector<int>>& b) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  std::vector<std::string> param_names{"int", "int", "vector<int>*", "n"};
+  std::vector<std::string> param_names{"n"};
   generic_test_main(argc, argv, param_names, "n_queens.tsv", &NQueens, &Comp);
   return 0;
 }

epi_judge_cpp/regular_expression.cc

@@ -10,7 +10,7 @@ bool IsMatch(const string &regex, const string &s) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char *argv[]) {
-  std::vector<std::string> param_names{"&regex", "&s"};
+  std::vector<std::string> param_names{"regex", "s"};
   generic_test_main(argc, argv, param_names, "regular_expression.tsv",
                     &IsMatch);
   return 0;

epi_judge_cpp/run_length_compression.cc

@@ -26,7 +26,7 @@ void RleTester(const string &encoded, const string &decoded) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char *argv[]) {
-  std::vector<std::string> param_names{"&encoded", "&decoded"};
+  std::vector<std::string> param_names{"encoded", "decoded"};
   generic_test_main(argc, argv, param_names, "run_length_compression.tsv",
                     &RleTester);
   return 0;

epi_judge_cpp/smallest_subarray_covering_set.cc

@@ -47,7 +47,7 @@ int FindSmallestSubarrayCoveringSetWrapper(
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char *argv[]) {
-  std::vector<std::string> param_names{"&timer", "&paragraph", "&keywords"};
+  std::vector<std::string> param_names{"timer", "paragraph", "keywords"};
   generic_test_main(argc, argv, param_names,
                     "smallest_subarray_covering_set.tsv",
                     &FindSmallestSubarrayCoveringSetWrapper);

epi_judge_cpp/substring_match.cc

@@ -12,7 +12,7 @@ int RabinKarp(const string &t, const string &s) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char *argv[]) {
-  std::vector<std::string> param_names{"&t", "&s"};
+  std::vector<std::string> param_names{"t", "s"};
   generic_test_main(argc, argv, param_names, "substring_match.tsv", &RabinKarp);
   return 0;
 }