clang-format and clang-tidy fixes for 9cc3951

Author: github-actions

backtracking/graph_coloring.cpp

@@ -1,23 +1,25 @@
 /**
  * @file
  * @brief prints the assigned colors
- * using [Graph Coloring](https://en.wikipedia.org/wiki/Graph_coloring) algorithm
+ * using [Graph Coloring](https://en.wikipedia.org/wiki/Graph_coloring)
+ * algorithm
  *
  * @details
- * In graph theory, graph coloring is a special case of graph labeling; 
- * it is an assignment of labels traditionally called "colors" to elements of a graph subject to certain constraints. 
- * In its simplest form, it is a way of coloring the vertices of a graph such that no two adjacent vertices are of the same color; 
- * this is called a vertex coloring. Similarly, an edge coloring assigns
- * a color to each edge so that no two adjacent edges are of the same color,
- * and a face coloring of a planar graph assigns a color to each face or
+ * In graph theory, graph coloring is a special case of graph labeling;
+ * it is an assignment of labels traditionally called "colors" to elements of a
+ * graph subject to certain constraints. In its simplest form, it is a way of
+ * coloring the vertices of a graph such that no two adjacent vertices are of
+ * the same color; this is called a vertex coloring. Similarly, an edge coloring
+ * assigns a color to each edge so that no two adjacent edges are of the same
+ * color, and a face coloring of a planar graph assigns a color to each face or
  * region so that no two faces that share a boundary have the same color.
  *
  * @author [Anup Kumar Panwar](https://github.com/AnupKumarPanwar)
  * @author [David Leal](https://github.com/Panquesito7)
  */
-#include <iostream>    /// for IO operations
-#include <array>       /// for std::array
-#include <vector>      /// for std::vector
+#include <array>     /// for std::array
+#include <iostream>  /// for IO operations
+#include <vector>    /// for std::vector
 
 /**
  * @namespace backtracking
@@ -26,7 +28,8 @@
 namespace backtracking {
 /**
  * @namespace graph_coloring
- * @brief Functions for the [Graph Coloring](https://en.wikipedia.org/wiki/Graph_coloring) algorith,
+ * @brief Functions for the [Graph
+ * Coloring](https://en.wikipedia.org/wiki/Graph_coloring) algorith,
  */
 namespace graph_coloring {
 /**
@@ -35,9 +38,9 @@ namespace graph_coloring {
  * @param color array of colors assigned to the nodes
  */
 template <size_t V>
-void printSolution(const std::array <int, V>& color) {
+void printSolution(const std::array<int, V>& color) {
     std::cout << "Following are the assigned colors\n";
-    for (auto &col : color) {
+    for (auto& col : color) {
         std::cout << col;
     }
     std::cout << "\n";
@@ -55,7 +58,8 @@ void printSolution(const std::array <int, V>& color) {
  * @returns `false` if the color is not safe to be assigned to the node
  */
 template <size_t V>
-bool isSafe(int v, const std::array<std::array <int, V>, V>& graph, const std::array <int, V>& color, int c) {
+bool isSafe(int v, const std::array<std::array<int, V>, V>& graph,
+            const std::array<int, V>& color, int c) {
     for (int i = 0; i < V; i++) {
         if (graph[v][i] && c == color[i]) {
             return false;
@@ -74,7 +78,8 @@ bool isSafe(int v, const std::array<std::array <int, V>, V>& graph, const std::a
  * @param v index of graph vertex to check
  */
 template <size_t V>
-void graphColoring(const std::array<std::array <int, V>, V>& graph, int m, std::array <int, V> color, int v) {
+void graphColoring(const std::array<std::array<int, V>, V>& graph, int m,
+                   std::array<int, V> color, int v) {
     // base case:
     // If all vertices are assigned a color then return true
     if (v == V) {
@@ -112,15 +117,12 @@ int main() {
     // (0)---(1)
 
     const int V = 4;  // number of vertices in the graph
-    std::array <std::array <int, V>, V> graph = {
-        std::array <int, V>({0, 1, 1, 1}),
-        std::array <int, V>({1, 0, 1, 0}),
-        std::array <int, V>({1, 1, 0, 1}),
-        std::array <int, V>({1, 0, 1, 0})
-    };
+    std::array<std::array<int, V>, V> graph = {
+        std::array<int, V>({0, 1, 1, 1}), std::array<int, V>({1, 0, 1, 0}),
+        std::array<int, V>({1, 1, 0, 1}), std::array<int, V>({1, 0, 1, 0})};
 
     int m = 3;  // Number of colors
-    std::array <int, V> color{};
+    std::array<int, V> color{};
 
     backtracking::graph_coloring::graphColoring<V>(graph, m, color, 0);
     return 0;

backtracking/knight_tour.cpp

@@ -1,6 +1,7 @@
 /**
  * @file
- * @brief [Knight's tour](https://en.wikipedia.org/wiki/Knight%27s_tour) algorithm
+ * @brief [Knight's tour](https://en.wikipedia.org/wiki/Knight%27s_tour)
+ * algorithm
  *
  * @details
  * A knight's tour is a sequence of moves of a knight on a chessboard
@@ -12,8 +13,8 @@
  * @author [Nikhil Arora](https://github.com/nikhilarora068)
  * @author [David Leal](https://github.com/Panquesito7)
  */
-#include <iostream>    /// for IO operations
-#include <array>       /// for std::array
+#include <array>     /// for std::array
+#include <iostream>  /// for IO operations
 
 /**
  * @namespace backtracking
@@ -22,7 +23,8 @@
 namespace backtracking {
 /**
  * @namespace knight_tour
- * @brief Functions for the [Knight's tour](https://en.wikipedia.org/wiki/Knight%27s_tour) algorithm
+ * @brief Functions for the [Knight's
+ * tour](https://en.wikipedia.org/wiki/Knight%27s_tour) algorithm
  */
 namespace knight_tour {
 /**
@@ -35,7 +37,7 @@ namespace knight_tour {
  * @returns `false` if ....
  */
 template <size_t V>
-bool issafe(int x, int y, const std::array <std::array <int, V>, V>& sol) {
+bool issafe(int x, int y, const std::array<std::array<int, V>, V> &sol) {
     return (x < V && x >= 0 && y < V && y >= 0 && sol[x][y] == -1);
 }
 
@@ -52,8 +54,8 @@ bool issafe(int x, int y, const std::array <std::array <int, V>, V>& sol) {
  * @returns `false` if solution does not exist
  */
 template <size_t V>
-bool solve(int x, int y, int mov, std::array <std::array <int, V>, V> &sol,
-    const std::array <int, V> &xmov, std::array <int, V> &ymov) {
+bool solve(int x, int y, int mov, std::array<std::array<int, V>, V> &sol,
+           const std::array<int, V> &xmov, std::array<int, V> &ymov) {
     int k = 0, xnext = 0, ynext = 0;
 
     if (mov == V * V) {
@@ -69,8 +71,7 @@ bool solve(int x, int y, int mov, std::array <std::array <int, V>, V> &sol,
 
             if (solve<V>(xnext, ynext, mov + 1, sol, xmov, ymov) == true) {
                 return true;
-            }
-             else {
+            } else {
                 sol[xnext][ynext] = -1;
             }
         }
@@ -86,25 +87,28 @@ bool solve(int x, int y, int mov, std::array <std::array <int, V>, V> &sol,
  */
 int main() {
     const int n = 8;
-    std::array <std::array <int, n>, n> sol = { 0 };
+    std::array<std::array<int, n>, n> sol = {0};
 
-    int i, j;
+    int i = 0, j = 0;
     for (i = 0; i < n; i++) {
-        for (j = 0; j < n; j++) { sol[i][j] = -1; }
+        for (j = 0; j < n; j++) {
+            sol[i][j] = -1;
+        }
     }
 
-    std::array <int, n> xmov = { 2, 1, -1, -2, -2, -1, 1, 2 };
-    std::array <int, n> ymov = { 1, 2, 2, 1, -1, -2, -2, -1 };
+    std::array<int, n> xmov = {2, 1, -1, -2, -2, -1, 1, 2};
+    std::array<int, n> ymov = {1, 2, 2, 1, -1, -2, -2, -1};
 
     sol[0][0] = 0;
 
     bool flag = backtracking::knight_tour::solve<n>(0, 0, 1, sol, xmov, ymov);
     if (flag == false) {
         std::cout << "Error: Solution does not exist\n";
-    }
-    else {
+    } else {
         for (i = 0; i < n; i++) {
-            for (j = 0; j < n; j++) { std::cout << sol[i][j] << "  "; }
+            for (j = 0; j < n; j++) {
+                std::cout << sol[i][j] << "  ";
+            }
             std::cout << "\n";
         }
     }

backtracking/minimax.cpp

@@ -6,21 +6,22 @@
  * @details
  * Minimax (sometimes MinMax, MM or saddle point) is a decision rule used in
  * artificial intelligence, decision theory, game theory, statistics,
- * and philosophy for minimizing the possible loss for a worst case (maximum loss) scenario.
- * When dealing with gains, it is referred to as "maximin"—to maximize the minimum gain.
- * Originally formulated for two-player zero-sum game theory, covering both the cases where players take
- * alternate moves and those where they make simultaneous moves, it has also been extended to more
- * complex games and to general decision-making in the presence of uncertainty.
- * 
+ * and philosophy for minimizing the possible loss for a worst case (maximum
+ * loss) scenario. When dealing with gains, it is referred to as "maximin"—to
+ * maximize the minimum gain. Originally formulated for two-player zero-sum game
+ * theory, covering both the cases where players take alternate moves and those
+ * where they make simultaneous moves, it has also been extended to more complex
+ * games and to general decision-making in the presence of uncertainty.
+ *
  * @author [Gleison Batista](https://github.com/gleisonbs)
  * @author [David Leal](https://github.com/Panquesito7)
  */
-#include <algorithm>   /// for std::max, std::min
-#include <cmath>       /// for log2
-#include <iostream>    /// for IO operations
-#include <array>       /// for std::array
+#include <algorithm>  /// for std::max, std::min
+#include <array>      /// for std::array
+#include <cmath>      /// for log2
+#include <iostream>   /// for IO operations
 
-/** 
+/**
  * @namespace backtracking
  * @brief Backtracking algorithms
  */
@@ -56,7 +57,7 @@ int main() {
     std::array<int, 8> scores = {90, 23, 6, 33, 21, 65, 123, 34423};
     double height = log2(scores.size());
 
-    std::cout << "Optimal value: " << backtracking::minimax(0, 0, true, scores, height)
-              << std::endl;
+    std::cout << "Optimal value: "
+              << backtracking::minimax(0, 0, true, scores, height) << std::endl;
     return 0;
 }

backtracking/n_queens.cpp

@@ -15,8 +15,8 @@
  * @author [David Leal](https://github.com/Panquesito7)
  *
  */
-#include <iostream>
 #include <array>
+#include <iostream>
 
 /**
  * @namespace backtracking
@@ -25,7 +25,8 @@
 namespace backtracking {
 /**
  * @namespace n_queens
- * @brief Functions for [Eight Queens](https://en.wikipedia.org/wiki/Eight_queens_puzzle) puzzle.
+ * @brief Functions for [Eight
+ * Queens](https://en.wikipedia.org/wiki/Eight_queens_puzzle) puzzle.
  */
 namespace n_queens {
 /**
@@ -35,14 +36,14 @@ namespace n_queens {
  */
 template <size_t n>
 void printSolution(const std::array<std::array<int, n>, n> &board) {
-  std::cout << "\n";
+    std::cout << "\n";
     for (int i = 0; i < n; i++) {
-      for (int j = 0; j < n; j++) {
-        std::cout << "" << board[i][j] << " ";
-      }
-      std::cout << "\n";
+        for (int j = 0; j < n; j++) {
+            std::cout << "" << board[i][j] << " ";
+        }
+        std::cout << "\n";
     }
-  }
+}
 
 /**
  * Check if a queen can be placed on matrix
@@ -56,28 +57,28 @@ void printSolution(const std::array<std::array<int, n>, n> &board) {
 template <size_t n>
 bool isSafe(const std::array<std::array<int, n>, n> &board, const int &row,
             const int &col) {
-  int i = 0, j = 0;
+    int i = 0, j = 0;
 
-  // Check this row on left side
-  for (i = 0; i < col; i++) {
-    if (board[row][i]) {
-      return false;
+    // Check this row on left side
+    for (i = 0; i < col; i++) {
+        if (board[row][i]) {
+            return false;
+        }
     }
-  }
 
-  // Check upper diagonal on left side
-  for (i = row, j = col; i >= 0 && j >= 0; i--, j--) {
-    if (board[i][j]) {
-      return false;
+    // Check upper diagonal on left side
+    for (i = row, j = col; i >= 0 && j >= 0; i--, j--) {
+        if (board[i][j]) {
+            return false;
+        }
     }
-  }
-  // Check lower diagonal on left side
-  for (i = row, j = col; j >= 0 && i < n; i++, j--) {
-    if (board[i][j]) {
-      return false;
+    // Check lower diagonal on left side
+    for (i = row, j = col; j >= 0 && i < n; i++, j--) {
+        if (board[i][j]) {
+            return false;
+        }
     }
-  }
-  return true;
+    return true;
 }
 
 /**
@@ -88,43 +89,40 @@ bool isSafe(const std::array<std::array<int, n>, n> &board, const int &row,
  */
 template <size_t n>
 void solveNQ(std::array<std::array<int, n>, n> board, const int &col) {
-  if (col >= n) {
-    printSolution<n>(board);
-    return;
-  }
+    if (col >= n) {
+        printSolution<n>(board);
+        return;
+    }
 
-  // Consider this column and try placing
-  // this queen in all rows one by one
-  for (int i = 0; i < n; i++) {
-    // Check if queen can be placed
-    // on board[i][col]
-    if (isSafe<n>(board, i, col)) {
-      // Place this queen in matrix
-      board[i][col] = 1;
+    // Consider this column and try placing
+    // this queen in all rows one by one
+    for (int i = 0; i < n; i++) {
+        // Check if queen can be placed
+        // on board[i][col]
+        if (isSafe<n>(board, i, col)) {
+            // Place this queen in matrix
+            board[i][col] = 1;
 
-      // Recursive to place rest of the queens
-      solveNQ<n>(board, col + 1);
+            // Recursive to place rest of the queens
+            solveNQ<n>(board, col + 1);
 
-      board[i][col] = 0; // backtrack
+            board[i][col] = 0;  // backtrack
+        }
     }
-  }
 }
-} // namespace n_queens
-} // namespace backtracking
+}  // namespace n_queens
+}  // namespace backtracking
 
 /**
  * @brief Main function
  * @returns 0 on exit
  */
 int main() {
-  const int n = 4;
-  std::array<std::array<int, n>, n> board = {
-    std::array<int, n>({0, 0, 0, 0}),
-    std::array<int, n>({0, 0, 0, 0}),
-    std::array<int, n>({0, 0, 0, 0}),
-    std::array<int, n>({0, 0, 0, 0})
-    };
+    const int n = 4;
+    std::array<std::array<int, n>, n> board = {
+        std::array<int, n>({0, 0, 0, 0}), std::array<int, n>({0, 0, 0, 0}),
+        std::array<int, n>({0, 0, 0, 0}), std::array<int, n>({0, 0, 0, 0})};
 
-  backtracking::n_queens::solveNQ<n>(board, 0);
-  return 0;
+    backtracking::n_queens::solveNQ<n>(board, 0);
+    return 0;
 }