Merge branch 'develop'

Author: codejsha

README.md

@@ -227,6 +227,8 @@ MutableValueGraph<City, Distance> roads = ValueGraphBuilder.directed()
 
 **Graph algorithms**
 
+> NOTE: In the following, the C++ implementations are currently only available on MSVC.
+
 - A\* search algorithm, CCSP#2.2.5: A single-pair shortest path algorithm. This is a variant of Dijkstra's algorithm using heuristics to try to speed up the search.
 - Bellman-Ford algorithm, CLRS#24.1: [c++](cpp-algorithm/src/cpp-algorithm/src/graph/bellman_ford.h), [java#1](java-algorithm/src/main/java/com/example/algorithm/graph/BellmanFord1.java), [java#2](java-algorithm/src/main/java/com/example/algorithm/graph/BellmanFord2.java) | A single source the shortest path algorithm that can handle negative edge weights. It finds the shortest path from a source vertex to all other vertices in a weighted graph.
 
@@ -387,6 +389,8 @@ algorithm Prim(G, root):
 
 **Examples**
 
+> NOTE: In the following, the C++ implementations are currently only available on MSVC.
+
 - Maze problem: [java](java-algorithm/src/main/java/com/example/algorithm/graph/MazeProblem.java) | A maze problem is that find a path from the start to the goal. The maze is represented by a graph. The start and the goal are represented by vertices. The path is represented by a sequence of vertices.
 - Minimum spanning tree (Kruskal, Prim, Boruvka), CLRS#23, CCSP#4.4.2: [python(test)](python-algorithm/algorithm/graph/test/test_minimum_spanning_tree.py) | Find the minimum spanning tree of a graph. cf. Kruskal(CLRS#23.2, CLRS#21.1), Prim(CLRS#23.2)
 

cpp-algorithm/src/array/advancing_through.cpp

@@ -2,13 +2,13 @@
 
 auto AdvancingThrough::CanReachEnd(const std::vector<int>& max_advance_steps) -> bool
 {
-    auto furthest_reach_so_far = 0;
-    const auto last_index = static_cast<int>(max_advance_steps.size()) - 1;
+    int reach_so_far = 0;   // furthest reach so far
+    const int last_index = static_cast<int>(max_advance_steps.size()) - 1;
 
-    for (int i = 0; i <= furthest_reach_so_far && furthest_reach_so_far < last_index; ++i)
+    for (int i = 0; i <= reach_so_far && reach_so_far < last_index; ++i)
     {
-        furthest_reach_so_far = std::max(furthest_reach_so_far, max_advance_steps[i] + i);
+        reach_so_far = std::max(reach_so_far, max_advance_steps[i] + i);
     }
 
-    return furthest_reach_so_far >= last_index;
+    return reach_so_far >= last_index;
 }

cpp-algorithm/src/array/arbitrary_precision_integer.cpp

@@ -20,20 +20,22 @@ auto ArbitraryPrecision::PlusOne(std::vector<int> number_array) -> std::vector<i
     return number_array;
 }
 
-auto ArbitraryPrecision::StringAddition(const std::string& number_string1, const std::string& number_string2) -> std::vector<int>
+auto ArbitraryPrecision::StringAddition(const std::string& number_string1,
+                                        const std::string& number_string2)
+    -> std::vector<int>
 {
-    const auto size1 = static_cast<int>(number_string1.size());
-    const auto size2 = static_cast<int>(number_string2.size());
+    const int size1 = static_cast<int>(number_string1.size());
+    const int size2 = static_cast<int>(number_string2.size());
 
-    const auto larger = size1 >= size2 ? size1 : size2;
+    const int larger = size1 >= size2 ? size1 : size2;
     auto sum = std::vector<int>(larger);
 
     for (int i = size1 - 1; i >= 0; --i)
     {
         sum[i] += number_string1.at(i) == '1' ? 1 : 0;
     }
 
-    auto carry = 0;
+    int carry = 0;
     for (int i = size2 - 1; i >= 0; --i)
     {
         sum[i] += carry;
@@ -58,9 +60,11 @@ auto ArbitraryPrecision::StringAddition(const std::string& number_string1, const
     return sum;
 }
 
-auto ArbitraryPrecision::Multiply(std::vector<int>& number_array1, std::vector<int>& number_array2) -> std::vector<int>
+auto ArbitraryPrecision::Multiply(std::vector<int>& number_array1,
+                                  std::vector<int>& number_array2)
+    -> std::vector<int>
 {
-    const auto sign = ((number_array1.front() < 0) ^ (number_array2.front() < 0)) ? -1 : 1;
+    const int sign = ((number_array1.front() < 0) ^ (number_array2.front() < 0)) ? -1 : 1;
     number_array1.front() = std::abs(number_array1.front());
     number_array2.front() = std::abs(number_array2.front());
 
@@ -75,7 +79,8 @@ auto ArbitraryPrecision::Multiply(std::vector<int>& number_array1, std::vector<i
         }
     }
 
-    result = {std::ranges::find_if_not(begin(result), end(result), [](const int i) { return i == 0; }), end(result)};
+    result = {std::ranges::find_if_not(begin(result), end(result), [](const int i) { return i == 0; }),
+              end(result)};
 
     if (std::empty(result))
     {

cpp-algorithm/src/array/benchmark/arbitrary_precision_integer_benchmark.cpp

@@ -15,8 +15,8 @@ BENCHMARK(BM_PlusOne);
 
 static void BM_StringAddition(benchmark::State& state)
 {
-    const auto number1 = std::string{"101"};
-    const auto number2 = std::string{"101"};
+    const std::string number1 = "101";
+    const std::string number2 = "101";
     for (auto _ : state)
     {
         ArbitraryPrecision::StringAddition(number1, number2);

cpp-algorithm/src/array/benchmark/delete_element_benchmark.cpp

@@ -27,7 +27,7 @@ BENCHMARK(BM_DeleteDuplicateElements);
 static void BM_DeleteSpecificElements(benchmark::State& state)
 {
     auto numbers = std::vector<int>{2, 3, 5, 5, 7, 11, 11, 11, 13};
-    constexpr auto element = 11;
+    constexpr int element = 11;
     for (auto _ : state)
     {
         DeleteElement::DeleteSpecificElements(numbers, element);

cpp-algorithm/src/array/benchmark/random_data_sampling_benchmark.cpp

@@ -4,7 +4,7 @@
 
 static void BM_OfflineRandomSampling(benchmark::State& state)
 {
-    constexpr auto k = 3;
+    constexpr int k = 3;
     auto arr = std::vector<int>{3, 7, 5, 11};
     for (auto _ : state)
     {
@@ -16,7 +16,7 @@ BENCHMARK(BM_OfflineRandomSampling);
 
 static void BM_ComputeRandomPermutation(benchmark::State& state)
 {
-    constexpr auto k = 3;
+    constexpr int k = 3;
     for (auto _ : state)
     {
         RandomDataSampling::ComputeRandomPermutation(k);

cpp-algorithm/src/array/delete_element.cpp

@@ -9,7 +9,7 @@ auto DeleteElement::DeleteDuplicates(std::vector<int>& numbers) -> std::vector<i
         return {};
     }
 
-    auto write_index = 1;
+    int write_index = 1;
     for (int i = 1; i < static_cast<int>(numbers.size()); ++i)
     {
         if (numbers[write_index - 1] != numbers[i])

cpp-algorithm/src/array/dutch_national_flag.cpp

@@ -34,7 +34,7 @@ auto DutchFlag::DutchFlagPartition2(const int pivot_index, std::vector<Color>& a
 {
     const auto pivot = arr[pivot_index];
 
-    auto smaller = 0;
+    int smaller = 0;
     for (int i = 0; i < static_cast<Color>(arr.size()); ++i)
     {
         if (arr[i] < pivot)
@@ -43,7 +43,7 @@ auto DutchFlag::DutchFlagPartition2(const int pivot_index, std::vector<Color>& a
         }
     }
 
-    auto larger = static_cast<Color>(arr.size()) - 1;
+    int larger = static_cast<Color>(arr.size()) - 1;
     for (int i = static_cast<Color>(arr.size()) - 1; i >= 0; --i)
     {
         if (arr[i] > pivot)
@@ -59,8 +59,8 @@ auto DutchFlag::DutchFlagPartition3(const int pivot_index, std::vector<Color>& a
 {
     const auto pivot = arr[pivot_index];
 
-    auto smaller = 0;
-    auto equal = 0;
+    int smaller = 0;
+    int equal = 0;
     int larger = static_cast<Color>(arr.size());
 
     while (equal < larger)

cpp-algorithm/src/array/enumerate_prime_number.cpp

@@ -2,7 +2,7 @@
 
 #include <deque>
 
-auto EnumeratePrime::GeneratePrimes(int n) -> std::vector<int>
+auto EnumeratePrime::GeneratePrimes(const int n) -> std::vector<int>
 {
     std::vector<int> primes;
     std::deque<bool> is_prime(n + 1, true);

cpp-algorithm/src/array/enumerate_prime_number.h

@@ -6,9 +6,9 @@
 namespace EnumeratePrime
 {
     /**
-     * brief Enumerate prime numbers in the range.
-     * param n upper bound
-     * return prime numbers
+     * \brief Enumerate prime numbers in the range.
+     * \param n upper bound
+     * \return prime numbers
      */
     auto GeneratePrimes(int n) -> std::vector<int>;
 }