clang-format and clang-tidy fixes for 02439b57

divide_and_conquer/strassen_matrix_multiplication.cpp

@@ -26,7 +26,7 @@ class Matrix {
     template <typename Integer,
               typename = typename std::enable_if<
                   std::is_integral<Integer>::value, Integer>::type>
-    Matrix(const Integer size) {
+    explicit Matrix(const Integer size) {
         for (size_t i = 0; i < size; ++i) {
             _mat.emplace_back(std::vector<T>(size, 0));
         }

range_queries/sparse_table.cpp

@@ -1,21 +1,23 @@
 /**
  * @file sparse_table.cpp
- * @brief Implementation of [Sparse Table](https://en.wikipedia.org/wiki/Range_minimum_query) data structure
+ * @brief Implementation of [Sparse
+ * Table](https://en.wikipedia.org/wiki/Range_minimum_query) data structure
  *
  * @details
  * Sparse Table is a data structure, that allows answering range queries.
- * It can answer most range queries in O(logn), but its true power is answering range minimum queries
- * or equivalent range maximum queries). For those queries it can compute the answer in O(1) time.
+ * It can answer most range queries in O(logn), but its true power is answering
+ * range minimum queries or equivalent range maximum queries). For those queries
+ * it can compute the answer in O(1) time.
  *
  * * Running Time Complexity \n
  * * Build : O(NlogN) \n
  * * Range Query : O(1) \n
-*/
+ */
 
-#include <vector>
+#include <algorithm>
 #include <cassert>
 #include <iostream>
-#include <algorithm>
+#include <vector>
 
 /**
  * @namespace range_queries
@@ -26,19 +28,19 @@ namespace range_queries {
  * @namespace sparse_table
  * @brief Range queries using sparse-tables
  */
- namespace sparse_table {
+namespace sparse_table {
 /**
  * This function precomputes intial log table for further use.
  * @param n value of the size of the input array
  * @return corresponding vector of the log table
  */
-template<typename T>
+template <typename T>
 std::vector<T> computeLogs(const std::vector<T>& A) {
     int n = A.size();
     std::vector<T> logs(n);
     logs[1] = 0;
-    for (int i = 2 ; i < n ; i++) {
-        logs[i] = logs[i/2] + 1;
+    for (int i = 2; i < n; i++) {
+        logs[i] = logs[i / 2] + 1;
     }
     return logs;
 }
@@ -50,19 +52,20 @@ std::vector<T> computeLogs(const std::vector<T>& A) {
  * @param logs array of the log table
  * @return created sparse table data structure
  */
-template<typename T>
-std::vector<std::vector<T> > buildTable(const std::vector<T>& A, const std::vector<T>& logs) {
+template <typename T>
+std::vector<std::vector<T> > buildTable(const std::vector<T>& A,
+                                        const std::vector<T>& logs) {
     int n = A.size();
-    std::vector<std::vector<T> > table(20, std::vector<T>(n+5, 0));
+    std::vector<std::vector<T> > table(20, std::vector<T>(n + 5, 0));
     int curLen = 0;
-    for (int i = 0 ; i <= logs[n] ; i++) {
+    for (int i = 0; i <= logs[n]; i++) {
         curLen = 1 << i;
-        for (int j = 0 ; j + curLen < n ; j++) {
+        for (int j = 0; j + curLen < n; j++) {
             if (curLen == 1) {
                 table[i][j] = A[j];
-            }
-            else {
-                table[i][j] = std::min(table[i-1][j], table[i-1][j + curLen/2]);
+            } else {
+                table[i][j] =
+                    std::min(table[i - 1][j], table[i - 1][j + curLen / 2]);
             }
         }
     }
@@ -77,14 +80,15 @@ std::vector<std::vector<T> > buildTable(const std::vector<T>& A, const std::vect
  * @param table sparse table data structure for the input array
  * @return minimum value for the [beg, end] range for the input array
  */
-template<typename T>
-int getMinimum(int beg, int end, const std::vector<T>& logs, const std::vector<std::vector<T> >& table) {
+template <typename T>
+int getMinimum(int beg, int end, const std::vector<T>& logs,
+               const std::vector<std::vector<T> >& table) {
     int p = logs[end - beg + 1];
     int pLen = 1 << p;
     return std::min(table[p][beg], table[p][end - pLen + 1]);
 }
-}
-} // namespace range_queries
+}  // namespace sparse_table
+}  // namespace range_queries
 
 /**
  * Main function
@@ -92,10 +96,10 @@ int getMinimum(int beg, int end, const std::vector<T>& logs, const std::vector<s
 int main() {
     std::vector<int> A{1, 2, 0, 3, 9};
     std::vector<int> logs = range_queries::sparse_table::computeLogs(A);
-    std::vector<std::vector<int> >  table = range_queries::sparse_table::buildTable(A, logs);
+    std::vector<std::vector<int> > table =
+        range_queries::sparse_table::buildTable(A, logs);
     assert(range_queries::sparse_table::getMinimum(0, 0, logs, table) == 1);
     assert(range_queries::sparse_table::getMinimum(0, 4, logs, table) == 0);
     assert(range_queries::sparse_table::getMinimum(2, 4, logs, table) == 0);
     return 0;
 }
-