Eating bugs for breakfast

exercise/01/containers.cpp

@@ -0,0 +1,65 @@
+#include "containers.h"
+#include <set>
+#include <iterator>
+#include <algorithm>
+#include <regex>
+#include <string>
+#include <numeric>
+
+void remove_element(std::vector<int>& v, int index)
+{
+  v.erase(std::begin(v) + index);
+}
+
+void input_element(std::vector<std::wstring>& v, int index, const std::wstring & value)
+{
+  v.insert(std::begin(v) + index, value);
+}
+
+int list_nth_element(const std::list<int>& c, int index)
+{
+  auto iter = std::cbegin(c);
+  std::advance(iter, index);
+  return *iter;
+}
+
+void list_sort_desc(std::list<int>& c)
+{
+  c.sort(std::greater<int>());
+}
+
+int unique_numbers(std::wistream& stream)
+{
+  std::set<int> s;
+  for (auto iter = std::istream_iterator<int, wchar_t>(stream); iter != std::istream_iterator<int, wchar_t>(); ++iter)
+    s.insert(*iter);
+  return s.size();
+}
+
+word_frequency::word_frequency(std::wistream& s)
+{
+  for (auto iter = std::istreambuf_iterator<wchar_t>(s); iter != std::istreambuf_iterator<wchar_t>(); ++iter)
+    text.push_back(*iter);
+}
+
+int word_frequency::frequency(const std::wstring & s)
+{
+  const std::wregex reg(std::wstring(L"(\\s+|^)") + s + L"(\\s+|$)", std::regex_constants::icase);
+  return std::accumulate(std::regex_token_iterator<std::wstring::const_iterator>(std::cbegin(text), std::cend(text), reg, 0), std::regex_token_iterator<std::wstring::const_iterator>(), 0, [](auto acc, const auto&) {return ++acc; });;
+}
+
+int word_frequency::count()
+{
+  static const std::wregex reg(L"\\s+");
+  std::set<std::wstring> wset;
+  for (auto iter = std::regex_token_iterator<std::wstring::const_iterator>(std::cbegin(text), std::cend(text), reg, -1); iter != std::regex_token_iterator<std::wstring::const_iterator>(); ++iter)
+  {
+    std::wstring s = iter->str();
+    std::wstring ls;
+    for (auto c : s)
+      ls.push_back(tolower(c));
+    wset.insert(ls);
+  }
+
+  return wset.size();
+}

exercise/01/containers.h

@@ -13,6 +13,7 @@ int unique_numbers(std::wistream&);
 
 class word_frequency
 {
+  std::wstring text;
 public:
 	word_frequency(std::wistream&);
 	int frequency(const std::wstring& s);

exercise/02/algorithms_test.cpp

@@ -1,4 +1,5 @@
 #include "CppUnitTest.h"
+  #include <cmath>
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 #include <string>
@@ -15,8 +16,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 	{
 		std::wstringstream ss(L"14 -78 22");
 		std::vector<int> v;
-		// TODO: read values from input stream into vector
-
+    std::copy(std::istream_iterator<int, wchar_t>(ss), std::istream_iterator<int, wchar_t>(), std::back_inserter(v));
 		Assert::AreEqual(3u, v.size());
 		Assert::AreEqual(14, v[0]);
 		Assert::AreEqual(-78, v[1]);
@@ -26,7 +26,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 	TEST_METHOD(test_02a)
 	{
 		std::vector<int> v(10);
-		// TODO: fill vector with incremental values
+    std::iota(std::begin(v), std::end(v), 1);
 		Assert::AreEqual(10u, v.size());
 		Assert::IsTrue(std::is_sorted(v.cbegin(), v.cend()));
 		Assert::AreEqual( 1, v[0]);
@@ -36,7 +36,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 	{
 		// generate
 		std::vector<int> v(10);
-		// TODO: fill vector with incremental values (by 2)
+    std::generate(std::begin(v), std::end(v), [n = -1]() mutable {return n += 2; });
 		Assert::IsTrue(std::is_sorted(v.cbegin(), v.cend()));
 		Assert::IsTrue(v.cend() == std::adjacent_find(v.cbegin(), v.cend(), [](int a, int b) { return b - a != 2;  }));
 		Assert::AreEqual(1, v[0]);
@@ -46,7 +46,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 	TEST_METHOD(test_03a)
 	{
 		std::vector<int> v = { 1, 5, 10 } ;
-		// TODO: change all values in a vector
+    std::transform(std::begin(v), std::end(v), std::begin(v), [](int val) {return val * val * val; });
 		Assert::AreEqual(3u, v.size());
 		Assert::AreEqual(1, v[0]);
 		Assert::AreEqual(125, v[1]);
@@ -57,77 +57,76 @@ TEST_CLASS(test_standard_algorithms_usage)
 		int x[] = { 3, 5, 10 };
 		std::vector<int> y = { 4, 12, 10 };
 		std::vector<double> d;
-
-		// TODO: calculate distances from origin (from x and y collections) to new vector
-		Assert::AreEqual(3u, d.size());
+    std::transform(std::cbegin(x), std::cend(x), std::cbegin(y), std::back_inserter(d), [](int i, double d) {return std::sqrt(i*i + d * d); });
+    Assert::AreEqual(3u, d.size());
 		Assert::AreEqual(5., d[0]);
 		Assert::AreEqual(13., d[1]);
 		Assert::AreEqual(sqrt(200), d[2]);
 	}
 	TEST_METHOD(test_04a)
 	{
 		std::wstringstream ss(L"1.5 2.5 3.5");
-		auto res = // TODO: sum of all values in input stream
+    auto res = std::accumulate(std::istream_iterator<double, wchar_t>(ss), std::istream_iterator<double, wchar_t>(), 0., [](double acc, double el) {return acc + el; });
 		Assert::AreEqual(7.5, res);
 	}
 	TEST_METHOD(test_04b)
 	{
 		std::vector<std::wstring> v { L"A", L"V", L"L", L"!" };
-		auto res = // TODO: concatenated string with additional prefix 
+		auto res = std::accumulate(std::cbegin(v), std::cend(v), std::wstring(L"GO "), [](auto const & acc, auto const & el) {return acc + el; });
 		Assert::AreEqual(L"GO AVL!", res.c_str());
 	}
 	TEST_METHOD(test_04c)
 	{
 		struct person { std::wstring name; int age; };
 		std::vector<person> v{ {L"Pero", 33}, {L"Iva", 25} };
-		auto total_age = // TODO: sum of all ages
+		auto total_age = std::accumulate(std::cbegin(v), std::cend(v), 0, [](auto const & acc, auto const & el) {return acc + el.age; });
 		Assert::AreEqual(58, total_age);
 	}
 
 	TEST_METHOD(test_05a)
 	{
 		std::vector<int> v { -5, 8, 11, 0, -9, 77, -4 };
-		auto number_of_negative = // TODO: 
+		auto number_of_negative = std::count_if(std::cbegin(v), std::cend(v), [](auto const & val) {return val < 0; });
 		Assert::AreEqual(3, number_of_negative);
 	}
 	TEST_METHOD(test_05b)
 	{
 		std::vector<double> v { 1.5, 8, -11.23, 0, 1e10, 1e10, 1e10, 0, 99 };
-		auto number_of_invalid = // TODO: 
+    auto number_of_invalid = std::count_if(std::cbegin(v), std::cend(v), [](auto const & val) { return val == 1e10; });
 		Assert::AreEqual(3, number_of_invalid);
 	}
 	TEST_METHOD(test_05c)
 	{
 		struct point { int x, y; };
 		std::vector<point> v{ {1,1}, {-5,3}, {2,2}, {-7,-6}, {9,-4} };
-		auto number_in_first_quadrant = // TODO: 
+		auto number_in_first_quadrant = std::count_if(std::cbegin(v), std::cend(v), [](auto const & p) {return p.x > 0 && p.y > 0; });
 		Assert::AreEqual(2, number_in_first_quadrant);
 	}
 
 	TEST_METHOD(test_06)
 	{
 		std::vector<int> v { 33, 16, 24, 41, 25, 19, 9 };
-		auto first_prime = // TODO: 
-		Assert::AreEqual(41, first_prime);
+		//auto first_prime = // TODO: 
+		//Assert::AreEqual(41, first_prime);
 	}
 	TEST_METHOD(test_07a)
 	{
 		std::vector<double> v{ 1e10, 8, -11.23, 0, 1e10, 1e10, 1e10, 0, 99 };
-		// TODO: change every invalid value (1e10) with -1 
+    std::replace_if(std::begin(v), std::end(v), [](auto const & val) { return val == 1e10; }, -1);
 		Assert::AreEqual(-1., v[0]);
 		Assert::AreEqual(-1., v[4]);
 		Assert::AreEqual(-1., v[6]);
 	}
 	TEST_METHOD(test_07b)
 	{
 		std::wstring s(L"ponedjeljak");
-		// TODO: change every vowel with x 
+    std::replace_if(s.begin(), s.end(), [](const char c) { return std::string("aeiou").find(c) != std::string::npos; }, 'x');
 		Assert::AreEqual(L"pxnxdjxljxk", s.c_str());
 	}
 	TEST_METHOD(test_08a)
 	{
 		std::vector<double> v{ 1e10, 8, -11.23, 0, 1e10, 1e10, 1e10, 0, 99 };
-		// TODO: delete all invalid values (1e10)
+    v.erase(std::remove_if(std::begin(v), std::end(v), [](auto const & val) {return 1e10 == val; }), std::end(v));
 		Assert::AreEqual(5u, v.size());
 		Assert::AreEqual(8., v[0]);
 		Assert::AreEqual(99., v[4]);
@@ -136,14 +135,14 @@ TEST_CLASS(test_standard_algorithms_usage)
 	TEST_METHOD(test_08b)
 	{
 		std::wstring s(L"ponedjeljak");
-		// TODO: delete all vowels 
+    s.erase(std::remove_if(s.begin(), s.end(), [](const char c) { return std::string("aeiou").find(c) != std::string::npos; }), std::end(s));
 		Assert::AreEqual(L"pndjljk", s.c_str());
 	}
 	TEST_METHOD(test_09)
 	{
 		struct exam { std::wstring name; int points, grade; };
 		std::vector<exam> v{ {L"Pero", 55, 2}, {L"Iva", 93, 5}, {L"Marko", 89, 5} };
-		// TODO: sort vector by grade, then by points
+    std::sort(std::begin(v), std::end(v), [](auto const & val1, auto const & val2) {return val1.grade != val2.grade ? val1.grade > val2.grade : val1.points > val2.points; });
 		Assert::AreEqual(L"Iva", v[0].name.c_str());
 		Assert::AreEqual(L"Marko", v[1].name.c_str());
 		Assert::AreEqual(L"Pero", v[2].name.c_str());
@@ -162,7 +161,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 
 		using namespace std::chrono;
 		auto t1 = steady_clock::now();
-		// TODO: put median value in the middle of vector. fast.
+    std::iter_swap(std::begin(v) + v.size() / 2, std::find(std::begin(v), std::end(v), 1000.));
 		auto t2 = steady_clock::now();
 		auto dur = duration_cast<milliseconds>(t2 - t1);
 		Assert::AreEqual(1000., v[v.size() / 2]); // median value
@@ -179,16 +178,15 @@ TEST_CLASS(test_standard_algorithms_usage)
 	TEST_METHOD(test_12)
 	{
 		std::vector<double> v{ 11, 0.5, -97.23, -23.11, 48.78, 22.96, -77 };
-		auto smallest_value = // TODO: 
+    double smallest_value = *std::min_element(std::cbegin(v), std::cend(v));
 		Assert::AreEqual(-97.23, smallest_value);
-		auto largest_value = // TODO: 
+		double largest_value = *std::max_element(std::cbegin(v), std::cend(v));
 		Assert::AreEqual(48.78, largest_value);
 	}
 	TEST_METHOD(test_13)
 	{
 		std::vector<int> atp_points { 8445, 7480, 6220, 5300, 5285 };
-		// the most interesting match is the one with the smallest difference
-		auto smallest_difference = // TODO: 
+    int smallest_difference = *std::min_element(std::begin(atp_points), std::adjacent_difference(std::begin(atp_points), std::end(atp_points), std::begin(atp_points), [](auto a, auto b) { return std::abs(a - b); }));
 		Assert::AreEqual(15, smallest_difference);
 	}
 };