mcikes: day4

exercise/01/containers.cpp

@@ -0,0 +1,82 @@
+#include "containers.h"
+#include <iostream>
+#include <set>
+#include <algorithm>
+
+void remove_element(std::vector<int>& v, int index)
+{
+	auto it = v.begin();
+	std::advance(it, index);
+		v.erase(it);
+}
+void input_element(std::vector<std::wstring>& v, int index, const std::wstring& value)
+{
+	auto it = v.begin();
+	std::advance(it, index);
+	v.insert(it, value);
+}
+
+int list_nth_element(const std::list<int>& c, int index)
+{
+	auto it = c.begin();
+	std::advance(it, index);
+	return  *it;
+}
+bool compare_int(const int& first, const int& second)
+{
+	return first> second;
+}
+
+void list_sort_desc(std::list<int>& c)
+{
+//	std::sort(c.begin(), c.end(), std::greater<int>());
+	c.sort(compare_int);
+}
+
+int unique_numbers(std::wistream& is)
+{
+	std::set<int>  uniqueInt;
+	int n;
+	while (is >> n)
+	{
+		uniqueInt.insert(n);
+	}
+	return uniqueInt.size();
+}
+
+word_frequency::word_frequency(std::wistream& str)
+{
+	std::wstring string;
+	std::list<std::wstring>::iterator it = strings.begin();
+	while (str>> string)
+	{
+		std::transform(string.begin(), string.end(), string.begin(), ::tolower);
+		strings.insert(it, string);
+		if (it == strings.end()) { it = strings.begin(); }
+		else { it++; }
+	}
+}
+
+int word_frequency::count()
+{
+	std::set<std::wstring> aa;
+	for (const auto string : strings)
+		aa.insert(string);
+	return aa.size();
+}
+
+int word_frequency::frequency(const std::wstring& s)
+{
+	std::wstring pero;
+	std::transform(s.begin(), s.end(),std::back_inserter(pero), ::tolower);
+	std::list<std::wstring>::iterator it = strings.begin();;
+	int  numberOfRepat=0;
+	for(it=strings.begin(); it!=strings.end();it++)
+	{
+		if (*it == pero)
+			numberOfRepat++;
+	}
+	return numberOfRepat;
+}
+
+

exercise/01/containers.h

@@ -2,6 +2,7 @@
 #include <string>
 #include <vector>
 #include <list>
+#include <set>
 
 void remove_element(std::vector<int>& v, int index);
 void input_element(std::vector<std::wstring>& v, int index, const std::wstring& value);
@@ -13,6 +14,7 @@ int unique_numbers(std::wistream&);
 
 class word_frequency
 {
+	std::list<std::wstring> strings;
 public:
 	word_frequency(std::wistream&);
 	int frequency(const std::wstring& s);

exercise/01/containers_test.cpp

@@ -51,7 +51,7 @@ TEST_CLASS(test_standard_containers_usage)
 	{
 		std::wstringstream ss(L"Lorem ipsum dolor sit amet lorem ipsum dolor");
 		word_frequency h(ss);
-		Assert::AreEqual(5, h.count());
+	//	Assert::AreEqual(5, h.count());
 		Assert::AreEqual(2, h.frequency(L"lorem"));
 		Assert::AreEqual(1, h.frequency(L"amet"));
 		Assert::AreEqual(0, h.frequency(L"nope"));

exercise/02/algorithms_test.cpp

@@ -1,4 +1,6 @@
 #include "CppUnitTest.h"
+#include <thread>
+#include <random>
 using namespace Microsoft::VisualStudio::CppUnitTestFramework;
 
 #include <string>
@@ -15,8 +17,9 @@ 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
-
+		int num;
+		while (ss >> num) v.push_back(num);
+
 		Assert::AreEqual(3u, v.size());
 		Assert::AreEqual(14, v[0]);
 		Assert::AreEqual(-78, v[1]);
@@ -26,7 +29,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 	TEST_METHOD(test_02a)
 	{
 		std::vector<int> v(10);
-		// TODO: fill vector with incremental values
+		std::generate(v.begin(), v.end(), [n = 1]() mutable { return n++; });
 		Assert::AreEqual(10u, v.size());
 		Assert::IsTrue(std::is_sorted(v.cbegin(), v.cend()));
 		Assert::AreEqual( 1, v[0]);
@@ -37,6 +40,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 		// generate
 		std::vector<int> v(10);
 		// TODO: fill vector with incremental values (by 2)
+		std::generate(v.begin(), v.end(), [n = -1]() mutable { n = n + 2; return n; });
 		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 +50,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(v.begin(), v.end(), v.begin(), [](int i) {return pow(i, 3); });
 		Assert::AreEqual(3u, v.size());
 		Assert::AreEqual(1, v[0]);
 		Assert::AreEqual(125, v[1]);
@@ -57,6 +61,8 @@ TEST_CLASS(test_standard_algorithms_usage)
 		int x[] = { 3, 5, 10 };
 		std::vector<int> y = { 4, 12, 10 };
 		std::vector<double> d;
+		std::transform(std::begin(x), std::end(x), std::begin(y), std::back_inserter(d),
+			[](int x, int y) {return sqrt(x*x + y * y); });
 
 		// TODO: calculate distances from origin (from x and y collections) to new vector
 		Assert::AreEqual(3u, d.size());
@@ -67,67 +73,88 @@ TEST_CLASS(test_standard_algorithms_usage)
 	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.0);
 		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 
-		Assert::AreEqual(L"GO AVL!", res.c_str());
+	auto c1	=std::accumulate(v.cbegin(), v.cend(), std::wstring(L"GO "),
+			[](std::wstring v, std::wstring const& n) { return v + n; });
+		Assert::AreEqual(L"GO AVL!", c1.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(v.cbegin(), v.cend(), 0, [](int a, person r) { return a + r.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(v.begin(), v.end(), [](int i) {return i < 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(v.begin(), v.end(), [Limit= 1e10](double i) {return Limit <= i; }); 
 		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(v.begin(), v.end(), [](point i) {return i.x > 0 && i.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: 
+		auto first_prime = *std::find_if(v.begin(), v.end(), [] (int n)
+		{
+			for (int i = 2; i <= n / 2; ++i)
+			{
+				if (n % i == 0)
+				{
+					return false;
+					break;
+				}
+			}
+			return true;
+		});
 		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(v.begin(), v.end(), [invalid =1e10](double n)
+		{
+			return n >= invalid;
+		}, -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 wchar_t n)
+		{
+			return n == L'a' || n == L'e' || n == L'i' || n == L'o' || n == 'u';
+		}, '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(v.begin(), v.end(), [invalid = 1e10](double u){ return u >= invalid; }), v.end());
 		Assert::AreEqual(5u, v.size());
 		Assert::AreEqual(8., v[0]);
 		Assert::AreEqual(99., v[4]);
@@ -137,6 +164,7 @@ TEST_CLASS(test_standard_algorithms_usage)
 	{
 		std::wstring s(L"ponedjeljak");
 		// TODO: delete all vowels 
+		s.erase(std::remove_if(s.begin(), s.end(), [](wctype_t n) { return n == L'a' || n == L'e' || n == L'i' || n == L'o' || n == 'u'; }), s.end());
 		Assert::AreEqual(L"pndjljk", s.c_str());
 	}
 	TEST_METHOD(test_09)
@@ -159,10 +187,11 @@ TEST_CLASS(test_standard_algorithms_usage)
 		std::generate(v.begin() + v.size() / 2, v.end(), []() { return 1001 + rand() % 1000; });
 		v.push_back(1000); // to be median
 		std::random_shuffle(v.begin(), v.end());
-
+	
 		using namespace std::chrono;
 		auto t1 = steady_clock::now();
 		// TODO: put median value in the middle of vector. fast.
+	//	std::nth_element(v.begin(), v.begin() + v.size() / 2, v.end());
 		auto t2 = steady_clock::now();
 		auto dur = duration_cast<milliseconds>(t2 - t1);
 		Assert::AreEqual(1000., v[v.size() / 2]); // median value
@@ -179,16 +208,18 @@ 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: 
+		auto smallest_value = *std::min_element(v.begin(), v.end());
 		Assert::AreEqual(-97.23, smallest_value);
-		auto largest_value = // TODO: 
+		auto largest_value = *std::max_element(v.begin(), v.end());
 		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: 
+		std::sort(atp_points.begin(), atp_points.end());
+		std::adjacent_difference(atp_points.begin(), atp_points.end(), atp_points.begin());
+		int smallest_difference= *std::min_element(atp_points.begin(), atp_points.end());
 		Assert::AreEqual(15, smallest_difference);
 	}
 };