Update gcd_of_n_numbers.cpp

Reformatting code, comment and test cases, change array data type.

Author: hollowcrust

math/gcd_of_n_numbers.cpp

@@ -5,14 +5,16 @@
  * @details
  * The GCD of n numbers can be calculated by
  * repeatedly calculating the GCDs of pairs of numbers
- * i.e. gcd(a, b, c) = gcd(gcd(a, b), c)
- * Euclidean algorithm helps calculate the GCD of each pair of numbers efficiently
- * 
+ * i.e. \f$\gcd(a, b, c)\f$ = \f$\gcd(\gcd(a, b), c)\f$
+ * Euclidean algorithm helps calculate the GCD of each pair of numbers
+ * efficiently
+ *
  * @see gcd_iterative_euclidean.cpp, gcd_recursive_euclidean.cpp
  */
+#include <algorithm> /// for std::abs
+#include <array>     /// for std::array
+#include <cassert>   /// for assert
 #include <iostream>  /// for IO operations
-#include <cassert>  /// for assert
-#include <algorithm>  /// for std::abs
 
 /**
  * @namespace math
@@ -31,10 +33,12 @@ namespace gcd_of_n_numbers {
  * @return GCD of x and y via recursion
  */
 int gcd_two(int x, int y) {
-    // base cases
-    if (y == 0) return x;
-    if (x == 0) return y;
-    return gcd_two(y, x % y);  // Euclidean method
+  // base cases
+  if (y == 0)
+    return x;
+  if (x == 0)
+    return y;
+  return gcd_two(y, x % y); // Euclidean method
 }
 /**
  * @brief Function to check if all elements in array are 0
@@ -43,37 +47,37 @@ int gcd_two(int x, int y) {
  * @return 'True' if all elements are 0
  * @return 'False' if not all elements are 0
  */
-bool check_all_zeros(int a[], size_t n) {
-    // Check for the undefined GCD cases
-    int zero_count = 0;
-    for (int i = 0; i < n; ++i) {
-        if (a[i] == 0) {
-            ++zero_count;
-        }
+template <size_t n> bool check_all_zeros(std::array<int, n> a) {
+  // Check for the undefined GCD cases
+  int zero_count = 0;
+  for (int i = 0; i < n; ++i) {
+    if (a[i] == 0) {
+      ++zero_count;
     }
+  }
 
-    // return whether all elements in array are 0
-    return zero_count == n;
+  // return whether all elements in array are 0
+  return zero_count == n;
 }
-/** 
- * @brief Main program to compute GCD using division algorithm
+/**
+ * @brief Main program to compute GCD by repeatedly use Euclidean algorithm
  * @param a Array of integers to compute GCD for
- * @param n number of integers in the array
+ * @param n Number of integers in the array
  * @return GCD of the numbers in the array
  */
-int gcd(int a[], size_t n) {
-    // GCD is undefined if all elements in the array are 0
-    if (check_all_zeros(a, n))
-        return -1;  // since gcd is positive, use -1 to mark undefined gcd
+template <size_t n> int gcd(std::array<int, n> a) {
+  // GCD is undefined if all elements in the array are 0
+  if (check_all_zeros(a))
+    return -1; // since gcd is positive, use -1 to mark undefined gcd
 
-    int gcd = a[0];
-    for(int i = 1; i < n; i++) {
-        gcd = gcd_two(gcd, a[i]);
-        if (std::abs(gcd) == 1) 
-            break;  // if gcd is already 1, further computations still result in gcd of 1
-    }
+  int gcd = a[0];
+  for (int i = 1; i < n; i++) {
+    gcd = gcd_two(gcd, a[i]);
+    if (std::abs(gcd) == 1)
+      break; // gcd is already 1, further computations still result in gcd of 1
+  }
 
-    return std::abs(gcd);  // divisors can be negative, and we only want positive value
+  return std::abs(gcd); // divisors can be negative, we only want positive value
 }
 } // namespace gcd_of_n_numbers
 } // namespace math
@@ -82,31 +86,31 @@ int gcd(int a[], size_t n) {
  * @brief Self-test implementation
  * @return void
  */
-static void test() { 
-    int array_1[1] = {0};
-    int array_2[1] = {1};
-    int array_3[2] = {0, 2};
-    int array_4[3] = {-60, 24, 18};
-    int array_5[4] = {100, -100, -100, 200};
-    int array_6[5] = {0, 0, 0, 0, 0};
-    int array_7[7] = {90, -120, 0, 135, 660, -280, 900}; 
-    int array_8[7] = {90, -120, 0, 4000, 0, 0, 111};
+static void test() {
+  std::array<int, 1> array_1 = {0};
+  std::array<int, 1> array_2 = {1};
+  std::array<int, 2> array_3 = {0, 2};
+  std::array<int, 3> array_4 = {-60, 24, 18};
+  std::array<int, 4> array_5 = {100, -100, -100, 200};
+  std::array<int, 5> array_6 = {0, 0, 0, 0, 0};
+  std::array<int, 7> array_7 = {10350, -24150, 0, 17250, 37950, -127650, 51750};
+  std::array<int, 7> array_8 = {9500000, -12121200, 0, 4444, 0, 0, 123456789};
 
-    assert(math::gcd_of_n_numbers::gcd(array_1, 1) == -1);
-    assert(math::gcd_of_n_numbers::gcd(array_2, 1) == 1); 
-    assert(math::gcd_of_n_numbers::gcd(array_3, 2) == 2);
-    assert(math::gcd_of_n_numbers::gcd(array_4, 3) == 6);
-    assert(math::gcd_of_n_numbers::gcd(array_5, 4) == 100);
-    assert(math::gcd_of_n_numbers::gcd(array_6, 5) == -1);
-    assert(math::gcd_of_n_numbers::gcd(array_7, 7) == 5);
-    assert(math::gcd_of_n_numbers::gcd(array_8, 7) == 1);
+  assert(math::gcd_of_n_numbers::gcd(array_1) == -1);
+  assert(math::gcd_of_n_numbers::gcd(array_2) == 1);
+  assert(math::gcd_of_n_numbers::gcd(array_3) == 2);
+  assert(math::gcd_of_n_numbers::gcd(array_4) == 6);
+  assert(math::gcd_of_n_numbers::gcd(array_5) == 100);
+  assert(math::gcd_of_n_numbers::gcd(array_6) == -1);
+  assert(math::gcd_of_n_numbers::gcd(array_7) == 3450);
+  assert(math::gcd_of_n_numbers::gcd(array_8) == 1);
 }
 
 /**
  * @brief Main function
  * @return 0 on exit
  */
 int main() {
-    test();  // run self-test implementation
-    return 0;
+  test(); // run self-test implementation
+  return 0;
 }