refactor code

Author: TsungHsienLee

Anagrams.cpp

@@ -1,37 +1,41 @@
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#include <algorithm>
 #include <iostream>
-#include <string>
-#include <cstdlib>
-#ifdef __clang__
 #include <unordered_set>
 #include <unordered_map>
-#else
-#include <tr1/unordered_set>
-#include <tr1/unordered_map>
-#endif
-#include <algorithm>
+#include <random>
+#include <string>
+#include <utility>
 #include <vector>
-#include <ctime>
 
-using namespace std;
-#ifndef __clang__
-using namespace std::tr1;
-#endif
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::pair;
+using std::ostream_iterator;
+using std::random_device;
+using std::string;
+using std::uniform_int_distribution;
+using std::unordered_map;
+using std::unordered_set;
+using std::vector;
 
 // @include
 void find_anagrams(const vector<string> &dictionary) {
-  // Get the sorted string and then insert into hash table
+  // Get the sorted string and then insert into hash table.
   unordered_map<string, vector<string>> hash;
   for (const string &s : dictionary) {
     string sorted_str(s);
-    // Use sorted string as the hash code
+    // Use sorted string as the hash code.
     sort(sorted_str.begin(), sorted_str.end());
     hash[sorted_str].emplace_back(s);
   }
 
   for (const pair<string, vector<string>> &p : hash) {
-    // Multiple strings with the same hash code => anagrams
+    // Multiple strings with the same hash code => anagrams.
     if (p.second.size() >= 2) {
-      // Output all strings
+      // Output all strings.
       copy(p.second.begin(), p.second.end(),
            ostream_iterator<string>(cout, " "));
       cout << endl;
@@ -41,20 +45,24 @@ void find_anagrams(const vector<string> &dictionary) {
 // @exclude
 
 string rand_string(int len) {
+  default_random_engine gen((random_device())());
   string ret;
   while (len--) {
-    ret.push_back('a' + rand() % 26);
+    uniform_int_distribution<int> dis('a', 'z');
+    ret.push_back(dis(gen));
   }
   return ret;
 }
 
 int main(int argc, char *argv[]) {
-  srand(time(nullptr));
+  default_random_engine gen((random_device())());
   vector<string> dictionary;
-  int n = rand() % 100000;
+  uniform_int_distribution<int> n_dis(0, 99999);
+  int n = n_dis(gen);
   unordered_set<string> table;
   for (size_t i = 0; i < n; ++i) {
-    table.emplace(rand_string(1 + rand() % 12));
+    uniform_int_distribution<int> dis(1, 12);
+    table.emplace(rand_string(dis(gen)));
   }
   for (const string &s : table) {
     dictionary.emplace_back(s);

Anonymous_letter.cpp

@@ -1,24 +1,28 @@
-#include <iostream>
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
 #include <algorithm>
 #include <cassert>
-#ifdef __clang__
-#include <unordered_map>
-#else
-#include <tr1/unordered_map>
-#endif
+#include <iostream>
+#include <random>
 #include <string>
-#include <cstdlib>
-#include <ctime>
+#include <unordered_map>
 
-using namespace std;
-#ifndef __clang__
-using namespace std::tr1;
-#endif
+using std::boolalpha;
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::random_device;
+using std::string;
+using std::uniform_int_distribution;
+using std::unordered_map;
+using std::vector;
 
 string rand_string(int len) {
   string ret;
+  default_random_engine gen((random_device())());
   while (len--) {
-    int x = rand() % 27;
+    uniform_int_distribution<int> dis(0, 26);
+    int x = dis(gen);
     ret += (x < 26) ? 'a' + x : ' ';
   }
   return ret;
@@ -27,10 +31,10 @@ string rand_string(int len) {
 // @include
 bool anonymous_letter(const string &L, const string &M) {
   unordered_map<char, int> hash;
-  // Insert all chars in L into a hash table
+  // Insert all chars in L into a hash table.
   for_each(L.begin(), L.end(), [&hash](const char &c) { ++hash[c]; });
 
-  // Check chars in M that could cover chars in a hash table
+  // Check chars in M that could cover chars in a hash table.
   for (const char &c : M) {
     auto it = hash.find(c);
     if (it != hash.cend()) {
@@ -42,18 +46,20 @@ bool anonymous_letter(const string &L, const string &M) {
       }
     }
   }
-  // No entry in hash means L can be covered by M
+  // No entry in hash means L can be covered by M.
   return hash.empty();
 }
 // @exclude
 
 int main(int argc, char *argv[]) {
-  srand(time(nullptr));
+  default_random_engine gen((random_device())());
   string L, M;
   if (argc == 3) {
     L = argv[1], M = argv[2];
   } else {
-    L = rand_string(1 + rand() % 1000), M = rand_string(1 + rand() % 100000);
+    uniform_int_distribution<int> L_dis(1, 1000);
+    uniform_int_distribution<int> M_dis(1, 100000);
+    L = rand_string(L_dis(gen)), M = rand_string(M_dis(gen));
   }
   cout << L << endl;
   cout << M << endl;

Can_string_be_palindrome.cpp

@@ -0,0 +1,44 @@
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#include <cassert>
+#include <iostream>
+#include <random>
+#include <string>
+
+#include "./Can_string_be_palindrome_hash.h"
+#include "./Can_string_be_palindrome_sorting.h"
+
+using std::boolalpha;
+using std::cout;
+using std::default_random_engine;
+using std::endl;
+using std::random_device;
+using std::string;
+using std::uniform_int_distribution;
+
+string rand_string(int len) {
+  string ret;
+  default_random_engine gen((random_device())());
+  while (len--) {
+    uniform_int_distribution<int> dis('a', 'z');
+    ret += dis(gen);
+  }
+  return ret;
+}
+
+int main(int argc, char *argv[]) {
+  default_random_engine gen((random_device())());
+  for (int times = 0; times < 1000; ++times) {
+    string s;
+    if (argc == 2) {
+      s = argv[1];
+    } else {
+      uniform_int_distribution<int> dis(1, 10);
+      s = rand_string(dis(gen));
+    }
+    cout << s << endl;
+    assert(can_string_be_a_palindrome_hash(s) ==
+           can_string_be_a_palindrome_sorting(&s));
+  }
+  return 0;
+}

Can_string_be_palindrome_hash.cpp

@@ -0,0 +1,31 @@
+// Copyright (c) 2013 Elements of Programming Interviews. All rights reserved.
+
+#ifndef SOLUTIONS_CAN_STRING_BE_PALINDROME_HASH_H_
+#define SOLUTIONS_CAN_STRING_BE_PALINDROME_HASH_H_
+
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+using std::pair;
+using std::string;
+using std::unordered_map;
+
+// @include
+bool can_string_be_a_palindrome_hash(const string &s) {
+  unordered_map<char, int> hash;
+  // Insert each char into hash.
+  for_each(s.begin(), s.end(), [&hash](const char &c) { ++hash[c]; });
+
+  // A string can be permuted as a palindrome if the number of odd time
+  // chars <= 1.
+  int odd_count = 0;
+  for (const pair<char, int> &p : hash) {
+    if (p.second & 1 && ++odd_count > 1) {
+      break;
+    }
+  }
+  return odd_count <= 1;
+}
+// @exclude
+#endif  // SOLUTIONS_CAN_STRING_BE_PALINDROME_HASH_H_