Update on 01/30/2018

epi_judge_cpp/CMakeLists.txt

@@ -168,6 +168,7 @@ add_executable(road_network road_network.cc)
 add_executable(roman_to_integer roman_to_integer.cc)
 add_executable(rook_attack rook_attack.cc)
 add_executable(rotate_array rotate_array.cc)
+add_executable(rotate_array_permutation rotate_array_permutation.cc)
 add_executable(run_length_compression run_length_compression.cc)
 add_executable(search_entry_equal_to_index search_entry_equal_to_index.cc)
 add_executable(search_first_greater_value_in_bst search_first_greater_value_in_bst.cc)

epi_judge_cpp/Makefile

@@ -2378,6 +2378,21 @@ rotate_array_dbg: $(BUILD_DIR)/rotate_array_dbg
 .PHONY: rotate_array rotate_array_dbg
 
 
+# rotate_array_permutation.cc
+
+$(BUILD_DIR)/rotate_array_permutation: $(SRC_DIR)/rotate_array_permutation.cc $(BUILD_DIR)
+	$(CXX_COMPILER) $(CXX_FLAGS_RELEASE) -o $@ $<
+rotate_array_permutation: $(BUILD_DIR)/rotate_array_permutation
+	$< --test_data_dir $(TEST_DATA_DIR)
+
+$(BUILD_DIR)/rotate_array_permutation_dbg: $(SRC_DIR)/rotate_array_permutation.cc $(BUILD_DIR)
+	$(CXX_COMPILER) $(CXX_FLAGS_DEBUG) -o $@ $<
+rotate_array_permutation_dbg: $(BUILD_DIR)/rotate_array_permutation_dbg
+	$< --test_data_dir $(TEST_DATA_DIR)
+
+.PHONY: rotate_array_permutation rotate_array_permutation_dbg
+
+
 # run_length_compression.cc
 
 $(BUILD_DIR)/run_length_compression: $(SRC_DIR)/run_length_compression.cc $(BUILD_DIR)

epi_judge_cpp/absent_value_array.cc

@@ -12,9 +12,9 @@ int FindMissingElement(vector<int>::const_iterator stream_begin,
   return 0;
 }
 
-int FindMissingElementWrapper(const vector<int>& data) {
+int FindMissingElementWrapper(const vector<int>& stream) {
   try {
-    return FindMissingElement(cbegin(data), cend(data));
+    return FindMissingElement(cbegin(stream), cend(stream));
   } catch (invalid_argument&) {
     throw TestFailureException("Unexpected no_missing_element exception");
   }
@@ -23,7 +23,8 @@ int FindMissingElementWrapper(const vector<int>& data) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "absent_value_array.tsv",
+  std::vector<std::string> param_names{"stream"};
+  generic_test_main(argc, argv, param_names, "absent_value_array.tsv",
                     &FindMissingElementWrapper);
   return 0;
 }

epi_judge_cpp/adding_credits.cc

@@ -74,7 +74,8 @@ void ClientsCreditsInfoTester(const std::vector<Operation>& ops) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "adding_credits.tsv",
+  std::vector<std::string> param_names{"ops"};
+  generic_test_main(argc, argv, param_names, "adding_credits.tsv",
                     &ClientsCreditsInfoTester);
   return 0;
 }

epi_judge_cpp/advance_by_offsets.cc

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

epi_judge_cpp/alternating_array.cc

@@ -11,7 +11,7 @@ void Rearrange(vector<int>* A_ptr) {
 }
 
 void CheckAnswer(const vector<int>& A) {
-  for (size_t i = 0; i < A.size(); ++i) {
+  for (int i = 0; i < A.size(); ++i) {
     if (i % 2) {
       if (A[i] < A[i - 1]) {
         throw TestFailureException("");
@@ -36,17 +36,19 @@ void CheckAnswer(const vector<int>& A) {
   }
 }
 
-void RearrangeWrapper(TestTimer& timer, vector<int> v) {
+void RearrangeWrapper(TestTimer& timer, vector<int> A) {
   timer.Start();
-  Rearrange(&v);
+  Rearrange(&A);
   timer.Stop();
 
-  CheckAnswer(v);
+  CheckAnswer(A);
 }
 
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "alternating_array.tsv", &RearrangeWrapper);
+  std::vector<std::string> param_names{"timer", "A"};
+  generic_test_main(argc, argv, param_names, "alternating_array.tsv",
+                    &RearrangeWrapper);
   return 0;
 }

epi_judge_cpp/anagrams.cc

@@ -12,8 +12,9 @@ vector<vector<string>> FindAnagrams(const vector<string>& dictionary) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
+  std::vector<std::string> param_names{"dictionary"};
   generic_test_main(
-      argc, argv, "anagrams.tsv", &FindAnagrams,
+      argc, argv, param_names, "anagrams.tsv", &FindAnagrams,
       &UnorderedComparator<std::vector<std::vector<std::string>>>);
   return 0;
 }

epi_judge_cpp/apply_permutation.cc

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

epi_judge_cpp/arbitrage.cc

@@ -2,14 +2,16 @@
 
 using std::vector;
 
-bool IsArbitrageExist(vector<vector<double>> G) {
+bool IsArbitrageExist(vector<vector<double>> graph) {
   // Implement this placeholder.
   return true;
 }
 
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "arbitrage.tsv", &IsArbitrageExist);
+  std::vector<std::string> param_names{"graph"};
+  generic_test_main(argc, argv, param_names, "arbitrage.tsv",
+                    &IsArbitrageExist);
   return 0;
 }

epi_judge_cpp/binomial_coefficients.cc

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

epi_judge_cpp/bonus.cc

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

epi_judge_cpp/bst_from_preorder.cc

@@ -14,7 +14,8 @@ unique_ptr<BstNode<int>> RebuildBSTFromPreorder(
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "bst_from_preorder.tsv",
+  std::vector<std::string> param_names{"preorder_sequence"};
+  generic_test_main(argc, argv, param_names, "bst_from_preorder.tsv",
                     &RebuildBSTFromPreorder);
   return 0;
 }

epi_judge_cpp/bst_from_sorted_array.cc

@@ -29,7 +29,8 @@ int BuildMinHeightBSTFromSortedArrayWrapper(TestTimer& timer,
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "bst_from_sorted_array.tsv",
+  std::vector<std::string> param_names{"timer", "A"};
+  generic_test_main(argc, argv, param_names, "bst_from_sorted_array.tsv",
                     &BuildMinHeightBSTFromSortedArrayWrapper);
   return 0;
 }

epi_judge_cpp/bst_merge.cc

@@ -13,6 +13,7 @@ shared_ptr<BstNode<int>> MergeTwoBSTs(shared_ptr<BstNode<int>> A,
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "bst_merge.tsv", &MergeTwoBSTs);
+  std::vector<std::string> param_names{"A", "B"};
+  generic_test_main(argc, argv, param_names, "bst_merge.tsv", &MergeTwoBSTs);
   return 0;
 }

epi_judge_cpp/bst_to_sorted_list.cc

@@ -36,7 +36,8 @@ std::vector<int> BSTToDoublyLinkedListWrapper(
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "bst_to_sorted_list.tsv",
+  std::vector<std::string> param_names{"timer", "tree"};
+  generic_test_main(argc, argv, param_names, "bst_to_sorted_list.tsv",
                     &BSTToDoublyLinkedListWrapper);
   return 0;
 }

epi_judge_cpp/buy_and_sell_stock.cc

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

epi_judge_cpp/buy_and_sell_stock_k_times.cc

@@ -10,7 +10,8 @@ double BuyAndSellStockKTimes(const vector<double>& prices, int k) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "buy_and_sell_stock_k_times.tsv",
+  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/buy_and_sell_stock_twice.cc

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

epi_judge_cpp/calendar_rendering.cc

@@ -19,7 +19,8 @@ struct SerializationTraits<Event> : UserSerTraits<Event, int, int> {};
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "calendar_rendering.tsv",
+  std::vector<std::string> param_names{"A"};
+  generic_test_main(argc, argv, param_names, "calendar_rendering.tsv",
                     &FindMaxSimultaneousEvents);
   return 0;
 }

epi_judge_cpp/circular_queue.cc

@@ -84,6 +84,8 @@ void QueueTester(const std::vector<QueueOp>& ops) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "circular_queue.tsv", &QueueTester);
+  std::vector<std::string> param_names{"ops"};
+  generic_test_main(argc, argv, param_names, "circular_queue.tsv",
+                    &QueueTester);
   return 0;
 }

epi_judge_cpp/closest_int_same_weight.cc

@@ -8,7 +8,8 @@ unsigned long ClosestIntSameBitCount(unsigned long x) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "closest_int_same_weight.tsv",
+  std::vector<std::string> param_names{"x"};
+  generic_test_main(argc, argv, param_names, "closest_int_same_weight.tsv",
                     &ClosestIntSameBitCount);
   return 0;
 }

epi_judge_cpp/collatz_checker.cc

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

epi_judge_cpp/combinations.cc

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

epi_judge_cpp/convert_base.cc

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

epi_judge_cpp/copy_posting_list.cc

@@ -10,7 +10,7 @@ using std::make_shared;
 using std::shared_ptr;
 
 shared_ptr<PostingListNode> CopyPostingsList(
-    const shared_ptr<PostingListNode>& L) {
+    const shared_ptr<PostingListNode>& l) {
   // Implement this placeholder.
   return nullptr;
 }
@@ -84,8 +84,8 @@ void AssertListsEqual(const PostingListPtr& orig, const PostingListPtr& copy) {
 }
 
 void CopyPostingsListWrapper(TestTimer& timer,
-                             const std::vector<SerializedNode>& serialized) {
-  auto head = CreatePostingList(serialized);
+                             const std::vector<SerializedNode>& l) {
+  auto head = CreatePostingList(l);
   timer.Start();
   auto copy = CopyPostingsList(head);
   timer.Stop();
@@ -95,7 +95,8 @@ void CopyPostingsListWrapper(TestTimer& timer,
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "copy_posting_list.tsv",
+  std::vector<std::string> param_names{"timer", "l"};
+  generic_test_main(argc, argv, param_names, "copy_posting_list.tsv",
                     &CopyPostingsListWrapper);
   return 0;
 }

epi_judge_cpp/count_bits.cc

@@ -7,6 +7,7 @@ short CountBits(unsigned int x) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "count_bits.tsv", &CountBits);
+  std::vector<std::string> param_names{"x"};
+  generic_test_main(argc, argv, param_names, "count_bits.tsv", &CountBits);
   return 0;
 }

epi_judge_cpp/count_inversions.cc

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

epi_judge_cpp/deadlock_detection.cc

@@ -11,7 +11,7 @@ struct GraphVertex {
   vector<GraphVertex*> edges;
 };
 
-bool IsDeadlocked(vector<GraphVertex>* G) {
+bool IsDeadlocked(vector<GraphVertex>* graph) {
   // Implement this placeholder.
   return true;
 }
@@ -24,19 +24,20 @@ struct Edge {
 template <>
 struct SerializationTraits<Edge> : UserSerTraits<Edge, int, int> {};
 
-bool HasCycleWrapper(TestTimer& timer, int k, const vector<Edge>& edges) {
+bool HasCycleWrapper(TestTimer& timer, int num_nodes,
+                     const vector<Edge>& edges) {
   vector<GraphVertex> graph;
-  if (k <= 0) {
-    throw std::runtime_error("Invalid k value");
+  if (num_nodes <= 0) {
+    throw std::runtime_error("Invalid num_nodes value");
   }
-  graph.reserve(k);
+  graph.reserve(num_nodes);
 
-  for (int i = 0; i < k; i++) {
+  for (int i = 0; i < num_nodes; i++) {
     graph.push_back(GraphVertex{});
   }
 
   for (const Edge& e : edges) {
-    if (e.from < 0 || e.from >= k || e.to < 0 || e.to >= k) {
+    if (e.from < 0 || e.from >= num_nodes || e.to < 0 || e.to >= num_nodes) {
       throw std::runtime_error("Invalid vertex index");
     }
     graph[e.from].edges.push_back(&graph[e.to]);
@@ -51,6 +52,8 @@ bool HasCycleWrapper(TestTimer& timer, int k, const vector<Edge>& edges) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "deadlock_detection.tsv", &HasCycleWrapper);
+  std::vector<std::string> param_names{"timer", "num_nodes", "edges"};
+  generic_test_main(argc, argv, param_names, "deadlock_detection.tsv",
+                    &HasCycleWrapper);
   return 0;
 }

epi_judge_cpp/defective_jugs.cc

@@ -23,6 +23,8 @@ bool operator==(const Jug& lhs, const Jug& rhs) {
 #include "test_framework/test_utils_generic_main.h"
 
 int main(int argc, char* argv[]) {
-  generic_test_main(argc, argv, "defective_jugs.tsv", &CheckFeasible);
+  std::vector<std::string> param_names{"jugs", "L", "H"};
+  generic_test_main(argc, argv, param_names, "defective_jugs.tsv",
+                    &CheckFeasible);
   return 0;
 }