feat: [DSA,DP] Use tests.h

Author: manid2

cpp/dsa/extended-palindrome.cpp

@@ -1,29 +1,31 @@
-// c++ code to get extended palindrome
+/**
+ * Extended palindrome
+ * ===================
+ *
+ * Refer:
+ *
+ * https://thejoboverflow.com/problem/337/
+ */
 
-#include <algorithm>
-#include <iostream>
-#include <vector>
+#include "tests.h"
 
-using namespace std;
-
-// you can write to stdout for debugging purposes, e.g.
-// cout << "this is a debug message" << endl;
-
-bool isp(string &s)
-{
-	string p = s;
-	reverse(p.begin(), p.end());
-	return (s == p);
-}
+/* ===========================================================================
+ * Algorithms implementation
+ * ===========================================================================
+ */
+#define def_is_palin(T)                                                      \
+	bool _is_palindrome(const T &s)                                      \
+	{                                                                    \
+		T::const_iterator l, m;                                      \
+		T::const_reverse_iterator r;                                 \
+		l = begin(s), m = l + size(s) / 2, r = rbegin(s);            \
+		return equal(l, m, r);                                       \
+	}
 
-bool isl(vector<string> &l)
-{
-	vector<string> r = l;
-	reverse(r.begin(), r.end());
-	return (r == l);
-}
+def_is_palin(string);
+def_is_palin(vector<string>);
 
-bool iscp(string s, int d)
+bool _iscp(string s, int d)
 {
 	size_t cs = s.size() / d;
 	size_t c = 0;
@@ -32,13 +34,12 @@ bool iscp(string s, int d)
 		string p(s.begin() + c, s.begin() + c + d);
 		l.push_back(p);
 	}
-	return isl(l);
+	return _is_palindrome(l);
 }
 
 int extendedPalindrome(string &s)
 {
-	if (isp(s)) return 1;
-
+	if (_is_palindrome(s)) return 1;
 	// get prime divisor of |s| or 1
 	size_t d = 1;
 	for (size_t i = 2; i < s.size(); i++) {
@@ -47,33 +48,25 @@ int extendedPalindrome(string &s)
 			break;
 		}
 	}
-
-	if (iscp(s, d)) return d;
-
+	if (_iscp(s, d)) return d;
 	return -1;
 }
 
-// driver code
-int main(int, char **)
+/* ===========================================================================
+ * Test code
+ * ===========================================================================
+ */
+TEST(extendedPalindrome, "Extended palindrome")
 {
-	vector<string> vl = {"radar", "abcxyzabc", "microsoft"};
-
-	if (getenv("SHOW_TEST_OUTPUT"))
-		cout << "Testing implementation " << 1 << " "
-		     << "extended palindrome"
-		     << "\n";
-
-	for (int i = 0; i < static_cast<int>(vl.size()); i++) {
-		string s = vl[i];
-		int t = extendedPalindrome(s);
-
-		if (getenv("SHOW_TEST_OUTPUT"))
-			cout << "  test-" << i << ":  "
-			     << "input: str = " << vl[i]
-			     << "  output: num = " << t << "\n";
+	vector<string> _i = {"radar", "abcxyzabc", "microsoft"};
+	vi_t _e = {1, 3, -1};
+	int n = size(_i);
+	fii (i, n) {
+		string &s = _i[i];
+		int a = extendedPalindrome(s);
+		CHECK_EQ(_e[i], a);
+		SHOW_OUTPUT(s, a);
 	}
-
-	cout << "Executed " << 1 << " implementations"
-	     << " with " << 1 << " tests." << endl;
-	return 0;
 }
+
+INIT_TEST_MAIN();

cpp/dsa/str-to-num.cpp

@@ -1,87 +1,65 @@
 /**
- * Given a vector of strings representing unsigned numbers, convert the
- * numbers to a collection of std::uint16_t in which the odd numbers appear
- * before the even ones and output the data
+ * Convert strings into integers & put odd ones before even
+ * ========================================================
  */
 
-#include <bits/stdc++.h>
+#include "tests.h"
 
-using namespace std;
+/* ===========================================================================
+ * Algorithms implementation
+ * ===========================================================================
+ */
+static inline bool _is_number(const string &s)
+{
+	return !empty(s) && all_of(begin(s), end(s), ::isdigit);
+}
 
-auto input = std::vector<std::string>{
-    "9", "0", "49", "2", "100", "not a number", "12 not a number too"};
+static inline bool _is_odd(int n) { return n % 2; }
+static inline bool _is_even(int n) { return !_is_odd(n); }
 
-bool is_number(const std::string &s)
+void _moveOddToBegin(vi_t &a)
 {
-	return !s.empty() && std::all_of(s.begin(), s.end(), ::isdigit);
+	int l = 0, r = size(a) - 1;
+	while (l < r) {
+		while (_is_even(a[l]) && l < r) l++;
+		while (_is_odd(a[r]) && l < r) r--;
+		if (l < r) swap(a[l++], a[r--]);
+	}
 }
 
-std::vector<std::uint16_t>
-getOddEvenNums(const std::vector<std::string> &input)
+vi_t oddEvens(const vector<string> &a)
 {
-	std::vector<std::uint16_t> oen;
-	for (auto &a : input) {
-		std::uint16_t d = 0;
+	vi_t ret;
+	for (const auto &e : a) {
 		try {
-			if (is_number(a)) {
-				d = static_cast<std::uint16_t>(std::stoul(a));
-				oen.push_back(d);
-			}
+			if (_is_number(e)) ret.push_back(stoi(e));
 		} catch (std::invalid_argument const &ex) {
-			std::cout
-			    << "std::invalid_argument::what(): " << ex.what()
-			    << '\n';
+			cerr << format("invalid argument: {}\n", ex.what());
 		} catch (std::out_of_range const &ex) {
-			std::cout
-			    << "std::out_of_range::what(): " << ex.what()
-			    << '\n';
+			cerr << format("out of range: {}\n", ex.what());
 		}
 	}
-
-	std::size_t s = 0;
-	std::size_t e = oen.size() - 1;
-	while (s < e) {
-		while (oen.at(s) % 2 == 0 && s < e) s++;
-		while (oen.at(e) % 2 != 1 && s < e) e--;
-		// similar to bubble sort swap odd & even numbers
-		if (s < e) {
-			std::swap(oen.at(s), oen.at(e));
-			s++;
-			e--;
-		}
-	}
-	return oen;
+	_moveOddToBegin(ret);
+	return ret;
 }
 
 /* ===========================================================================
  * Test code
  * ===========================================================================
  */
-template <class T>
-string _vec2str(const vector<T> &vec)
+TEST(odd_evens, "Convert strings into integers & put odd ones before even")
 {
-	ostringstream oss;
-	oss << "{";
-	copy(vec.begin(), vec.end() - 1, ostream_iterator<T>(oss, ", "));
-	oss << vec.back();
-	oss << "}";
-	return oss.str();
+	vector<string> i = {"9",
+	                    "0",
+	                    "49",
+	                    "2",
+	                    "100",
+	                    "not a number",
+	                    "12 not a number too"};
+	vi_t e = {100, 0, 2, 49, 9};
+	vi_t a = oddEvens(i);
+	CHECK_EQ(e, a);
+	SHOW_OUTPUT(i, a);
 }
 
-int main(int, char **)
-{
-	std::vector<std::uint16_t> oen = getOddEvenNums(input);
-
-	if (getenv("SHOW_TEST_OUTPUT"))
-		cout << "Testing implementation " << 1 << " "
-		     << "get odd & even numbers from vector string"
-		     << "\n"
-		     << "  test-" << 1 << ":  "
-		     << "input:  = " << _vec2str<string>(input)
-		     << "  output: oddEvenNums = " << _vec2str<uint16_t>(oen)
-		     << "\n";
-
-	cout << "Executed " << 1 << " implementations"
-	     << " with " << 1 << " tests." << endl;
-	return 0;
-}
+INIT_TEST_MAIN();

cpp/dsa/third-max-num.cpp

@@ -2,48 +2,12 @@
  * Third distinct maximum number
  * ==============================
  *
- * Leetcode: [414. Third Maximum Number][lc414]
+ * Refer:
  *
- * Given an integer array nums, return the third distinct maximum number in
- * this array. If the third maximum does not exist, return the maximum number.
- *
- * Tags: #arrays, #easy
- *
- * Example 1:
- *   Input: nums = [3,2,1]
- *   Output: 1
- *
- * Example 2:
- *   Input: nums = [3,2,1]
- *   Output: 1
- *
- * Example 3:
- *   Input: nums = [2,2,3,1]
- *   Output: 1
- *
- * [lc414]: https://leetcode.com/problems/third-maximum-number/
+ * https://leetcode.com/problems/third-maximum-number/
  */
 
-#include <bits/stdc++.h>
-
-using namespace std;
-
-/* ===========================================================================
- * Test helpers
- * ===========================================================================
- */
-class _00_test
-{
-public:
-	_00_test(const string &name) : name(name) {}
-
-	string getName(void) const { return name; }
-
-	virtual int thirdMax(const vector<int> &nums) = 0;
-
-private:
-	string name;
-};
+#include "tests.h"
 
 /* ===========================================================================
  * Algorithms implementation
@@ -53,77 +17,28 @@ class _00_test
 /* TC : O(n log k) for k'th largest number
  * SC : O(1)
  */
-class _01_set : public _00_test
+int thirdMax(const vi_t &a)
 {
-public:
-	_01_set() : _00_test("Third max number using std::set") {}
-
-	int thirdMax(const vector<int> &a) override
-	{
-		set<int> s;
-		for (int e : a) {
-			s.insert(e);
-			if (s.size() > 3) s.erase(*s.begin());
-		}
-		if (s.size() == 3) return *s.begin();
-		return *prev(s.end());
+	set<int> s;
+	for (int e : a) {
+		s.insert(e);
+		if (s.size() > 3) s.erase(*s.begin());
 	}
-};
+	if (s.size() == 3) return *s.begin();
+	return *prev(s.end());
+}
 
 /* ===========================================================================
  * Test code
  * ===========================================================================
  */
-string _vec2str(const vector<int> &vec)
+TEST(thirdMax, "Third distinct maximum number")
 {
-	ostringstream oss;
-	oss << "{";
-	copy(vec.begin(), vec.end() - 1, ostream_iterator<int>(oss, ", "));
-	oss << vec.back();
-	oss << "}";
-	return oss.str();
+	vi_t i{2, 3, 2, 1};
+	int e = 1;
+	int a = thirdMax(i);
+	CHECK_EQ(e, a);
+	SHOW_OUTPUT(i, a);
 }
 
-void test_impl(const vector<vector<int>> &ip, vector<int> &op,
-               shared_ptr<_00_test> f)
-{
-	for (size_t i = 0; i < ip.size(); i++) {
-		int t = f->thirdMax(ip[i]);
-		if (t != op[i]) {
-			cerr << f->getName() << " test failed: "
-			     << "expected " << op[i] << ", actual " << t
-			     << "." << endl;
-			exit(1);
-		}
-
-		if (getenv("SHOW_TEST_OUTPUT"))
-			cout << "  test-" << i << ":  "
-			     << "input: nums = " << _vec2str(ip[i])
-			     << "  output: num = " << t << "\n";
-	}
-}
-
-int main(int, char **)
-{
-	vector<vector<int>> ip{
-	    {2, 3, 2, 1},
-	};
-
-	vector op{1};
-
-	vector<shared_ptr<_00_test>> impls{
-	    make_shared<_01_set>(),
-	};
-
-	for (size_t i = 0; i < impls.size(); i++) {
-		if (getenv("SHOW_TEST_OUTPUT"))
-			cout << "Testing implementation " << i + 1 << " "
-			     << impls[i]->getName() << "\n";
-
-		test_impl(ip, op, impls[i]);
-	}
-
-	cout << "Executed " << impls.size() << " implementations"
-	     << " with " << ip.size() << " tests." << endl;
-	return 0;
-}
+INIT_TEST_MAIN();