Refactoring code

Author: TsungHsienLee

0-sum_subset.cpp

@@ -1,12 +1,18 @@
-#include <iostream>
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
 #include <algorithm>
-#include <numeric>
 #include <cassert>
+#include <iostream>
+#include <numeric>
+#include <random>
 #include <vector>
-#include <cstdlib>
-#include <ctime>
 
-using namespace std;
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::random_device;
+using std::uniform_int_distribution;
+using std::vector;
 
 // @include
 vector<int> find_0_sum_subset(const vector<int> &A) {
@@ -30,12 +36,12 @@ vector<int> find_0_sum_subset(const vector<int> &A) {
     table[prefix_sum[i]] = i;
   }
   // @exclude
-  return {};   // it should not happen
+  return {};  // it should not happen
   // @include
 }
 // @exclude
 
-void check_ans(vector<int> &A, vector<int> &ans) {
+void check_ans(const vector<int> &A, const vector<int> &ans) {
   int sum = 0;
   for (const int &a : ans) {
     sum = (sum + A[a]) % A.size();
@@ -44,29 +50,30 @@ void check_ans(vector<int> &A, vector<int> &ans) {
 }
 
 int main(int argc, char *argv[]) {
-  //srand(time(nullptr));
+  default_random_engine gen((random_device())());
   for (int times = 0; times < 1000; ++times) {
     int n;
     vector<int> A;
     if (argc == 2) {
       n = atoi(argv[1]);
       A.resize(n);
+      uniform_int_distribution<int> dis(0, 9999);
       for (int i = 0; i < n; ++i) {
-        A[i] = rand() % 10000;
+        A[i] = dis(gen);
       }
     } else if (argc > 2) {
       for (int i = 1; i < argc; ++i) {
         A.emplace_back(atoi(argv[i]));
       }
     } else {
-      n = 1 + rand() % 100;
+      uniform_int_distribution<int> n_dis(1, 100);
+      n = n_dis(gen);
       A.resize(n);
+      uniform_int_distribution<int> dis(0, 9999);
       for (int i = 0; i < n; ++i) {
-        A[i] = rand() % 10000;
+        A[i] = dis(gen);
       }
     }
-    //copy(A.begin(), A.end(), ostream_iterator<int>(cout, " "));
-    //cout << endl;
     vector<int> ans = find_0_sum_subset(A);
     check_ans(A, ans);
   }

Bignumber_multiplication.cpp

@@ -2,12 +2,13 @@
 
 #include <algorithm>
 #include <cassert>
-#include <cstring>
 #include <iostream>
 #include <random>
 #include <string>
 #include <vector>
 
+#include "./execute-shell.h"
+
 using std::cout;
 using std::default_random_engine;
 using std::endl;
@@ -20,7 +21,7 @@ using std::vector;
 // @include
 class BigInt {
  public:
-  explicit BigInt(const int &capacity) : sign_(1), digits_(capacity) {}
+  explicit BigInt(int capacity) : sign_(1), digits_(capacity) {}
 
   explicit BigInt(const string &s) : sign_(s[0] == '-' ? -1 : 1),
                                      digits_(s.size() - (s[0] == '-')) {
@@ -40,18 +41,18 @@ class BigInt {
         int carry = 0;
         for (j = 0; j < digits_.size() || carry; ++j) {
           int n_digit = result.digits_[i + j] +
-            (j < digits_.size() ? n.digits_[i] * digits_[j] : 0) +
-            carry;
+                        (j < digits_.size() ? n.digits_[i] * digits_[j] : 0) +
+                        carry;
           result.digits_[i + j] = n_digit % 10;
           carry = n_digit / 10;
         }
       }
     }
 
-    // If one number is 0, the result size should be 0
+    // If one number is 0, the result size should be 0.
     if ((digits_.size() == 1 && digits_.front() == 0) ||
-      (n.digits_.size() == 1 && n.digits_.front() == 0)) {
-      result.digits_.resize(1);
+        (n.digits_.size() == 1 && n.digits_.front() == 0)) {
+      result.sign_ = 1, result.digits_.resize(1);
     } else {
       result.digits_.resize(i + j - 1);
     }
@@ -97,18 +98,28 @@ string rand_string(int len) {
   return ret;
 }
 
-int main(int argc, char *argv[]) {
+void simple_test() {
   assert((BigInt("0") * BigInt("1000")).toString() == "0");
   assert((BigInt("131412") * BigInt("-1313332")).toString() == "-172587584784");
-  string s1, s2;
-  if (argc == 3) {
-    s1 = argv[1], s2 = argv[2];
-  } else {
-    default_random_engine gen((random_device())());
-    uniform_int_distribution<int> dis(0, 19);
-    s1 = rand_string(dis(gen)), s2 = rand_string(dis(gen));
+}
+
+int main(int argc, char *argv[]) {
+  simple_test();
+  for (int times = 0; times < 1000; ++times) {
+    string s1, s2;
+    if (argc == 3) {
+      s1 = argv[1], s2 = argv[2];
+    } else {
+      default_random_engine gen((random_device())());
+      uniform_int_distribution<int> dis(0, 19);
+      s1 = rand_string(dis(gen)), s2 = rand_string(dis(gen));
+    }
+    BigInt res = BigInt(s1) * BigInt(s2);
+    cout << s1 << " * " << s2 << " = " << res.toString() << endl;
+    string command = "bc <<<" + s1 + "*" + s2;
+    string result = execute_shell(command);
+    cout << "answer = " << result;
+    assert(res.toString().compare(result.substr(0, result.size() - 1)) == 0);
   }
-  BigInt res = BigInt(s1) * BigInt(s2);
-  cout << s1 << " * " << s2 << " = " << res.toString() << endl;
   return 0;
 }

Division.cpp

@@ -1,18 +1,24 @@
-#include <iostream>
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
 #include <cassert>
-#include <ctime>
-#include <climits>
-#include <cstdlib>
+#include <iostream>
+#include <limits>
+#include <random>
 
-using namespace std;
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::numeric_limits;
+using std::random_device;
+using std::uniform_int_distribution;
 
-unsigned divide_x_y_bsearch(const unsigned &x, const unsigned &y) {
+unsigned divide_x_y_bsearch(unsigned x, unsigned y) {
   if (x < y) {
     return 0;
   }
 
   int power_left = 0;
-  int power_right = sizeof(unsigned) << 3; 
+  int power_right = sizeof(unsigned) << 3;
   int power_mid = -1;
   while (power_left < power_right) {
     int tmp = power_mid;
@@ -39,7 +45,7 @@ unsigned divide_x_y_bsearch(const unsigned &x, const unsigned &y) {
 }
 
 // @include
-unsigned divide_x_y(const unsigned &x, const unsigned &y) {
+unsigned divide_x_y(unsigned x, unsigned y) {
   if (x < y) {
     return 0;
   }
@@ -53,10 +59,7 @@ unsigned divide_x_y(const unsigned &x, const unsigned &y) {
 }
 // @exclude
 
-
-void foo() { } 
-
-void simple_test(void) {
+void simple_test() {
   assert(divide_x_y(64, 1) == 64);
   assert(divide_x_y(64, 2) == 32);
   assert(divide_x_y(64, 3) == 21);
@@ -77,19 +80,20 @@ void simple_test(void) {
 
 int main(int argc, char *argv[]) {
   simple_test();
-  int MAX = UINT_MAX;
-  //srand(time(nullptr));
   if (argc == 3) {
     unsigned x = atoi(argv[1]), y = atoi(argv[2]);
     assert(x / y == divide_x_y(x, y));
     assert(x / y == divide_x_y_bsearch(x, y));
   } else {
-    for (int times = 0; times < 100000000; ++times) {
-      unsigned x = rand() % MAX; 
-      unsigned y = rand() % MAX;
-      y = (y==0) ? 1 : y; // ensure no divide by 0
-      assert((x/y) == divide_x_y(x, y));
-      assert( (x/y) == divide_x_y_bsearch(x, y));
+    default_random_engine gen((random_device())());
+    uniform_int_distribution<unsigned> dis(0, numeric_limits<int>::max());
+    for (int times = 0; times < 100000; ++times) {
+      unsigned x = dis(gen), y = dis(gen);
+      y = (y == 0) ? 1 : y;  // ensure no divide by 0
+      cout << "times = " << times << ", x = " << x << ", y = " << y << endl;
+      cout << "first = " << x / y << ", second = " << divide_x_y(x, y) << endl;
+      assert(x / y == divide_x_y(x, y));
+      assert(x / y == divide_x_y_bsearch(x, y));
     }
   }
   return 0;

Dutch_national_flag.cpp

@@ -16,25 +16,25 @@ using std::vector;
 
 // @include
 template <typename T>
-void dutch_flag_partition(vector<T> &A, const int &pivot_index) {
-  T pivot = A[pivot_index];
+void dutch_flag_partition(vector<T>* A, int pivot_index) {
+  T pivot = (*A)[pivot_index];
   /**
    * Keep the following invariants during partitioning:
-   * bottom group: A[0 : smaller - 1]
-   * middle group: A[smaller : equal - 1]
-   * unclassified group: A[equal : larger]
-   * top group: A[larger + 1 : A.size() - 1]
+   * bottom group: (*A)[0 : smaller - 1]
+   * middle group: (*A)[smaller : equal - 1]
+   * unclassified group: (*A)[equal : larger]
+   * top group: (*A)[larger + 1 : A->size() - 1]
    */
-  int smaller = 0, equal = 0, larger = A.size() - 1;
+  int smaller = 0, equal = 0, larger = A->size() - 1;
   // When there is any unclassified element
   while (equal <= larger) {
-    // A[equal] is the incoming unclassified element
-    if (A[equal] < pivot) {
-      swap(A[smaller++], A[equal++]);
-    } else if (A[equal] == pivot) {
+    // (*A)[equal] is the incoming unclassified element
+    if ((*A)[equal] < pivot) {
+      swap((*A)[smaller++], (*A)[equal++]);
+    } else if ((*A)[equal] == pivot) {
       ++equal;
-    } else {  // A[equal] > pivot
-      swap(A[equal], A[larger--]);
+    } else {  // (*A)[equal] > pivot
+      swap((*A)[equal], (*A)[larger--]);
     }
   }
 }
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
     uniform_int_distribution<int> dis(0, A.size() - 1);
     int pivot_index = dis(gen);
     int pivot = A[pivot_index];
-    dutch_flag_partition(A, pivot_index);
+    dutch_flag_partition(&A, pivot_index);
     int i = 0;
     while (A[i] < pivot && i < A.size()) {
       cout << A[i] << ' ';

Equiv_classes.cpp

@@ -1,5 +1,6 @@
 // Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
 
+#include <algorithm>
 #include <cassert>
 #include <iostream>
 #include <iterator>
@@ -31,7 +32,7 @@ int backtrace(const vector<int> &F, int idx) {
  * F of length N; F[i] holds the smallest index of all the elements that
  * i is equivalent to.
  */
-vector<int> compute_equival_classes(const int &n, const vector<int> &A,
+vector<int> compute_equival_classes(int n, const vector<int> &A,
                                     const vector<int> &B) {
   // Each element maps to itself
   vector<int> F(n);

GCD.cpp

@@ -1,33 +1,18 @@
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
 #include <iostream>
 #include <cassert>
+#include <limits>
+#include <random>
 
-using namespace std;
-
-// @include
-long long GCD(const long long &x, const long long &y) {
-  if (x == 0) {
-    return y;
-  } else if (y == 0) {
-    return x;
-  } else if (!(x & 1) && !(y & 1)) {  // x and y are even integers
-    return GCD(x >> 1, y >> 1) << 1;
-  } else if (!(x & 1) && y & 1) {  // x is even integer, and y is odd integer
-    return GCD(x >> 1, y);
-  } else if (x & 1 && !(y & 1)) {  // x is odd integer, and y is even integer
-    return GCD(x, y >> 1);
-  } else if (x > y) {  // both x and y are odd integers, and x > y
-    return GCD(x - y, y);
-  }
-  return GCD(x, y - x);  // both x and y are odd integers, and x <= y
-}
+#include "./GCD.h"
 
-long long another_GCD(long long a, long long b) {
-  if (b) {
-    while ((a %= b) && (b %= a));
-  }
-  return a + b;
-}
-// @exclude
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::numeric_limits;
+using std::random_device;
+using std::uniform_int_distribution;
 
 int main(int argc, char *argv[]) {
   long long x = 18, y = 12;
@@ -37,9 +22,11 @@ int main(int argc, char *argv[]) {
     cout << GCD(x, y) << endl;
     assert(GCD(x, y) == another_GCD(x, y));
   } else {
-    srand(time(nullptr));
+    default_random_engine gen((random_device())());
     for (int times = 0; times < 1000; ++times) {
-      x = rand(), y = rand();
+      uniform_int_distribution<long long>
+          dis(1, numeric_limits<long long>::max());
+      x = dis(gen), y = dis(gen);
       assert(GCD(x, y) == another_GCD(x, y));
     }
   }

GCD.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#ifndef SOLUTIONS_GCD_H_
+#define SOLUTIONS_GCD_H_
+
+// @include
+long long GCD(long long x, long long y) {
+  if (x == 0) {
+    return y;
+  } else if (y == 0) {
+    return x;
+  } else if (!(x & 1) && !(y & 1)) {  // x and y are even integers
+    return GCD(x >> 1, y >> 1) << 1;
+  } else if (!(x & 1) && y & 1) {  // x is even integer, and y is odd integer
+    return GCD(x >> 1, y);
+  } else if (x & 1 && !(y & 1)) {  // x is odd integer, and y is even integer
+    return GCD(x, y >> 1);
+  } else if (x > y) {  // both x and y are odd integers, and x > y
+    return GCD(x - y, y);
+  }
+  return GCD(x, y - x);  // both x and y are odd integers, and x <= y
+}
+// @exclude
+
+long long another_GCD(long long a, long long b) {
+  if (b) {
+    while ((a %= b) && (b %= a));
+  }
+  return a + b;
+}
+#endif  // SOLUTIONS_GCD_H_