From c15e5b390b05bed4f3fc8f7c00ca83958b3cfd99 Mon Sep 17 00:00:00 2001 From: Lucano Zganec Date: Fri, 16 Nov 2018 08:54:44 +0100 Subject: [PATCH 1/3] Partial implementation --- exercise/01/containers.cpp | 2 + exercise/01/containers_test.cpp | 24 +++++------ exercise/02/algorithms_test.cpp | 74 +++++++++++++++++++++++++-------- 3 files changed, 71 insertions(+), 29 deletions(-) create mode 100644 exercise/01/containers.cpp diff --git a/exercise/01/containers.cpp b/exercise/01/containers.cpp new file mode 100644 index 0000000..e9f5f32 --- /dev/null +++ b/exercise/01/containers.cpp @@ -0,0 +1,2 @@ +#include "containers.h" + diff --git a/exercise/01/containers_test.cpp b/exercise/01/containers_test.cpp index 4261d42..25003b8 100644 --- a/exercise/01/containers_test.cpp +++ b/exercise/01/containers_test.cpp @@ -10,51 +10,51 @@ TEST_CLASS(test_standard_containers_usage) public: TEST_METHOD(vector_remove_element) { - std::vector v { 1, 2, 3, 4, 5 }; + /*std::vector v { 1, 2, 3, 4, 5 }; remove_element(v, 2); Assert::AreEqual(4u, v.size()); Assert::AreEqual(2, v[1]); - Assert::AreEqual(4, v[2]); + Assert::AreEqual(4, v[2]);*/ } TEST_METHOD(vector_input_element) { - std::vector v { L"a", L"b", L"d" }; + /*std::vector v { L"a", L"b", L"d" }; input_element(v, 2, L"c"); Assert::AreEqual(4u, v.size()); Assert::AreEqual(L"c", v[2].c_str()); - Assert::AreEqual(L"d", v[3].c_str()); + Assert::AreEqual(L"d", v[3].c_str());*/ } TEST_METHOD(list_nth_element_test) { - std::list c { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + /*std::list c { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; Assert::AreEqual(4, list_nth_element(c, 4)); - Assert::AreEqual(8, list_nth_element(c, 8)); + Assert::AreEqual(8, list_nth_element(c, 8));*/ } TEST_METHOD(list_sort_descending) { - std::list c { 7, 1, 5, 3, 4, 2 }; + /*std::list c { 7, 1, 5, 3, 4, 2 }; list_sort_desc(c); Assert::AreEqual(6u, c.size()); - Assert::IsTrue(std::is_sorted(c.rbegin(), c.rend())); + Assert::IsTrue(std::is_sorted(c.rbegin(), c.rend()));*/ } TEST_METHOD(unique_values_test) { - Assert::AreEqual(5, unique_numbers(std::wstringstream(L"-9 -7 -5 -3 -1"))); + /*Assert::AreEqual(5, unique_numbers(std::wstringstream(L"-9 -7 -5 -3 -1"))); Assert::AreEqual(3, unique_numbers(std::wstringstream(L"1 2 3 2 3 2 1 2 3"))); - Assert::AreEqual(2, unique_numbers(std::wstringstream(L"0 1 1 0 0 1 0"))); + Assert::AreEqual(2, unique_numbers(std::wstringstream(L"0 1 1 0 0 1 0")));*/ } TEST_METHOD(word_frequency_test) { - std::wstringstream ss(L"Lorem ipsum dolor sit amet lorem ipsum dolor"); + /*std::wstringstream ss(L"Lorem ipsum dolor sit amet lorem ipsum dolor"); word_frequency h(ss); 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")); - Assert::AreEqual(5, h.count()); + Assert::AreEqual(5, h.count());*/ } }; diff --git a/exercise/02/algorithms_test.cpp b/exercise/02/algorithms_test.cpp index 9df3595..14856fb 100644 --- a/exercise/02/algorithms_test.cpp +++ b/exercise/02/algorithms_test.cpp @@ -8,6 +8,31 @@ using namespace Microsoft::VisualStudio::CppUnitTestFramework; #include #include +unsigned cubeNumber(int num) +{ + return pow(num, 3); +} + +double calcDistance(int x, int y) +{ + return sqrt(pow(x, 2) + pow(y, 2)); +} + +bool isNegative(int num) +{ + return num < 0; +} + +bool isTooBig(float num) +{ + return num > std::numeric_limits::max(); +} + +bool isVowel(wchar_t value) +{ + return value == L'a' || value == L'e' || value == L'i' || value == L'o' || value == L'u'; +} + TEST_CLASS(test_standard_algorithms_usage) { public: @@ -16,7 +41,7 @@ TEST_CLASS(test_standard_algorithms_usage) std::wstringstream ss(L"14 -78 22"); std::vector v; // TODO: read values from input stream into vector - + std::copy(std::istream_iterator(ss), std::istream_iterator(), std::back_inserter(v)); Assert::AreEqual(3u, v.size()); Assert::AreEqual(14, v[0]); Assert::AreEqual(-78, v[1]); @@ -27,6 +52,7 @@ TEST_CLASS(test_standard_algorithms_usage) { std::vector v(10); // TODO: fill vector with incremental values + std::iota(v.begin(), v.end(), 1); Assert::AreEqual(10u, v.size()); Assert::IsTrue(std::is_sorted(v.cbegin(), v.cend())); Assert::AreEqual( 1, v[0]); @@ -37,6 +63,8 @@ TEST_CLASS(test_standard_algorithms_usage) // generate std::vector v(10); // TODO: fill vector with incremental values (by 2) + int n = -1; + std::generate(v.begin(), v.end(), [&n] {return n = 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]); @@ -47,6 +75,15 @@ TEST_CLASS(test_standard_algorithms_usage) { std::vector v = { 1, 5, 10 } ; // TODO: change all values in a vector + /*class power + { + public: + unsigned n; + power(const int initval=0) : n(initval){} + unsigned operator()() const { return pow(n, 3); } + };*/ + + std::transform(v.begin(), v.end(), v.begin(), cubeNumber); Assert::AreEqual(3u, v.size()); Assert::AreEqual(1, v[0]); Assert::AreEqual(125, v[1]); @@ -59,6 +96,7 @@ TEST_CLASS(test_standard_algorithms_usage) std::vector d; // TODO: calculate distances from origin (from x and y collections) to new vector + std::transform(std::begin(x), std::end(x), y.begin(), std::back_inserter(d), calcDistance); Assert::AreEqual(3u, d.size()); Assert::AreEqual(5., d[0]); Assert::AreEqual(13., d[1]); @@ -67,53 +105,54 @@ 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(ss), std::istream_iterator(), 0.0);// TODO: sum of all values in input stream Assert::AreEqual(7.5, res); } TEST_METHOD(test_04b) { std::vector v { L"A", L"V", L"L", L"!" }; - auto res = // TODO: concatenated string with additional prefix + auto res = std::accumulate(v.begin(), v.end(), std::wstring(L"GO "));// TODO: concatenated string with additional prefix Assert::AreEqual(L"GO AVL!", res.c_str()); } TEST_METHOD(test_04c) { struct person { std::wstring name; int age; }; std::vector v{ {L"Pero", 33}, {L"Iva", 25} }; - auto total_age = // TODO: sum of all ages - Assert::AreEqual(58, total_age); + auto total_age = std::accumulate(v.begin(), v.end(), 0, [](int sum, const person& p) { return sum+p.age; });// TODO: sum of all ages + //Assert::AreEqual(58, total_age); } TEST_METHOD(test_05a) { std::vector v { -5, 8, 11, 0, -9, 77, -4 }; - auto number_of_negative = // TODO: + auto number_of_negative = std::count_if(v.begin(), v.end(), isNegative);// TODO: Assert::AreEqual(3, number_of_negative); } TEST_METHOD(test_05b) { std::vector 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(), isTooBig);// TODO: Assert::AreEqual(3, number_of_invalid); } TEST_METHOD(test_05c) { struct point { int x, y; }; std::vector v{ {1,1}, {-5,3}, {2,2}, {-7,-6}, {9,-4} }; - auto number_in_first_quadrant = // TODO: + auto number_in_first_quadrant = count_if(v.begin(), v.end(), [](const point& v) { return (v.x > 0 && v.y > 0); });// TODO: Assert::AreEqual(2, number_in_first_quadrant); } TEST_METHOD(test_06) { std::vector 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 v{ 1e10, 8, -11.23, 0, 1e10, 1e10, 1e10, 0, 99 }; // TODO: change every invalid value (1e10) with -1 + std::replace(v.begin(), v.end(), 1e10 , -1.0); Assert::AreEqual(-1., v[0]); Assert::AreEqual(-1., v[4]); Assert::AreEqual(-1., v[6]); @@ -122,6 +161,7 @@ TEST_CLASS(test_standard_algorithms_usage) { std::wstring s(L"ponedjeljak"); // TODO: change every vowel with x + std::replace_if(s.begin(), s.end(), isVowel, L'x'); Assert::AreEqual(L"pxnxdjxljxk", s.c_str()); } TEST_METHOD(test_08a) @@ -179,16 +219,16 @@ TEST_CLASS(test_standard_algorithms_usage) TEST_METHOD(test_12) { std::vector v{ 11, 0.5, -97.23, -23.11, 48.78, 22.96, -77 }; - auto smallest_value = // TODO: - Assert::AreEqual(-97.23, smallest_value); - auto largest_value = // TODO: - Assert::AreEqual(48.78, largest_value); + //auto smallest_value = // TODO: + //Assert::AreEqual(-97.23, smallest_value); + //auto largest_value = // TODO: + //Assert::AreEqual(48.78, largest_value); } TEST_METHOD(test_13) { std::vector atp_points { 8445, 7480, 6220, 5300, 5285 }; // the most interesting match is the one with the smallest difference - auto smallest_difference = // TODO: - Assert::AreEqual(15, smallest_difference); + //auto smallest_difference = // TODO: + //Assert::AreEqual(15, smallest_difference); } -}; +}; \ No newline at end of file From 63459c39137cdb2950a397cd7778d798d48ca044 Mon Sep 17 00:00:00 2001 From: Lucano Zganec Date: Fri, 16 Nov 2018 10:23:54 +0100 Subject: [PATCH 2/3] Finished Exercise 2 --- exercise/02/algorithms_test.cpp | 44 ++++++++++++++++++++++++--------- 1 file changed, 33 insertions(+), 11 deletions(-) diff --git a/exercise/02/algorithms_test.cpp b/exercise/02/algorithms_test.cpp index 14856fb..2bf3fae 100644 --- a/exercise/02/algorithms_test.cpp +++ b/exercise/02/algorithms_test.cpp @@ -145,8 +145,19 @@ TEST_CLASS(test_standard_algorithms_usage) TEST_METHOD(test_06) { std::vector v { 33, 16, 24, 41, 25, 19, 9 }; - //auto first_prime = // TODO: - //Assert::AreEqual(41, first_prime); + auto first_prime = *std::find_if(v.begin(), v.end(), [](int value) + { + for (int i = 2; i < sqrt(value) + 1; ++i) + { + if (value % i == 0) + { + return false; + } + } + + return true; + });// TODO: + Assert::AreEqual(41, first_prime); } TEST_METHOD(test_07a) { @@ -167,7 +178,7 @@ TEST_CLASS(test_standard_algorithms_usage) TEST_METHOD(test_08a) { std::vector v{ 1e10, 8, -11.23, 0, 1e10, 1e10, 1e10, 0, 99 }; - // TODO: delete all invalid values (1e10) + v.erase(std::remove(v.begin(), v.end(), 1e10), v.end());// TODO: delete all invalid values (1e10) Assert::AreEqual(5u, v.size()); Assert::AreEqual(8., v[0]); Assert::AreEqual(99., v[4]); @@ -176,14 +187,22 @@ 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(), isVowel), s.end());// TODO: delete all vowels Assert::AreEqual(L"pndjljk", s.c_str()); } TEST_METHOD(test_09) { struct exam { std::wstring name; int points, grade; }; std::vector v{ {L"Pero", 55, 2}, {L"Iva", 93, 5}, {L"Marko", 89, 5} }; - // TODO: sort vector by grade, then by points + std::sort(v.begin(), v.end(), [](exam value1, exam value2) + { + if (value1.grade == value2.grade) + { + return value1.points > value2.points; + } + + return value1.grade > value2.grade; + });// TODO: sort vector by grade, then by 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()); @@ -203,6 +222,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::nth_element(v.begin(), v.begin() + v.size() / 2, v.end(), [](const double value1, const double value2) { return value1 < value2; }); auto t2 = steady_clock::now(); auto dur = duration_cast(t2 - t1); Assert::AreEqual(1000., v[v.size() / 2]); // median value @@ -219,16 +239,18 @@ TEST_CLASS(test_standard_algorithms_usage) TEST_METHOD(test_12) { std::vector v{ 11, 0.5, -97.23, -23.11, 48.78, 22.96, -77 }; - //auto smallest_value = // TODO: - //Assert::AreEqual(-97.23, smallest_value); - //auto largest_value = // TODO: - //Assert::AreEqual(48.78, largest_value); + auto smallest_value = *std::min_element(v.begin(), v.end());// TODO: + Assert::AreEqual(-97.23, smallest_value); + auto largest_value = *std::max_element(v.begin(), v.end());// TODO: + Assert::AreEqual(48.78, largest_value); } TEST_METHOD(test_13) { std::vector atp_points { 8445, 7480, 6220, 5300, 5285 }; + std::vector diffs; // the most interesting match is the one with the smallest difference - //auto smallest_difference = // TODO: - //Assert::AreEqual(15, smallest_difference); + std::adjacent_difference(atp_points.rbegin(), atp_points.rend(), std::back_inserter(diffs)); + auto smallest_difference = *std::min_element(diffs.begin(), diffs.end());// TODO: + Assert::AreEqual(15, smallest_difference); } }; \ No newline at end of file From 74fcc0baecccbd26f30ffa1a5d2b674d3a02f2fe Mon Sep 17 00:00:00 2001 From: Lucano Zganec Date: Fri, 16 Nov 2018 11:19:27 +0100 Subject: [PATCH 3/3] Finished ex1 --- exercise/01/containers.cpp | 120 ++++++++++++++++++++++++++++++++ exercise/01/containers.h | 2 + exercise/01/containers_test.cpp | 24 +++---- 3 files changed, 134 insertions(+), 12 deletions(-) diff --git a/exercise/01/containers.cpp b/exercise/01/containers.cpp index e9f5f32..65be4b6 100644 --- a/exercise/01/containers.cpp +++ b/exercise/01/containers.cpp @@ -1,2 +1,122 @@ #include "containers.h" +#include +void remove_element(std::vector& v, int index) +{ + auto it = v.begin(); + std::advance(it, index); + v.erase(it); +} + +void input_element(std::vector& 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& c, int index) +{ + auto it = c.begin(); + std::advance(it, index); + + return *it; +} + +void list_sort_desc(std::list& c) +{ + for (auto it = c.begin(); it != c.end(); ++it) + { + for (auto it2 = c.begin()++; it2 != c.end(); ++it2) + { + if (*it > *it2) + { + auto temp = *it; + *it = *it2; + *it2 = temp; + } + } + } +} + +int unique_numbers(std::wistream& is) +{ + std::vector uniqueNumbers; + + int n; + while (is >> n) + { + bool unique = true; + + for (int i = 0; i < uniqueNumbers.size(); i++) + { + if (uniqueNumbers[i] == n) + { + unique = false; + break; + } + } + + if (unique) + { + uniqueNumbers.push_back(n); + } + } + + return uniqueNumbers.size(); +} + +word_frequency::word_frequency(std::wistream& in) +{ + std::wstring word; + + while (in >> word) + { + for (wchar_t& c:word) + { + c = towlower(c); + } + words.push_back(word); + } +} + +int word_frequency::frequency(const std::wstring& s) +{ + int count = 0; + + for (int i = 0; i < words.size(); i++) + { + if (words[i]._Equal(s)) + { + count++; + } + } + + return count; +} + +int word_frequency::count() +{ + std::vector uniqueWords; + + for (int i = 0; i < words.size(); i++) + { + bool unique = true; + + for (int j = 0; j < uniqueWords.size(); j++) + { + if (words[i]._Equal(uniqueWords[j])) + { + unique = false; + break; + } + } + + if (unique) + { + uniqueWords.push_back(words[i]); + } + } + + return uniqueWords.size(); +} diff --git a/exercise/01/containers.h b/exercise/01/containers.h index 8e1b172..c650a6a 100644 --- a/exercise/01/containers.h +++ b/exercise/01/containers.h @@ -17,4 +17,6 @@ class word_frequency word_frequency(std::wistream&); int frequency(const std::wstring& s); int count(); +private: + std::vector words; }; diff --git a/exercise/01/containers_test.cpp b/exercise/01/containers_test.cpp index 25003b8..4261d42 100644 --- a/exercise/01/containers_test.cpp +++ b/exercise/01/containers_test.cpp @@ -10,51 +10,51 @@ TEST_CLASS(test_standard_containers_usage) public: TEST_METHOD(vector_remove_element) { - /*std::vector v { 1, 2, 3, 4, 5 }; + std::vector v { 1, 2, 3, 4, 5 }; remove_element(v, 2); Assert::AreEqual(4u, v.size()); Assert::AreEqual(2, v[1]); - Assert::AreEqual(4, v[2]);*/ + Assert::AreEqual(4, v[2]); } TEST_METHOD(vector_input_element) { - /*std::vector v { L"a", L"b", L"d" }; + std::vector v { L"a", L"b", L"d" }; input_element(v, 2, L"c"); Assert::AreEqual(4u, v.size()); Assert::AreEqual(L"c", v[2].c_str()); - Assert::AreEqual(L"d", v[3].c_str());*/ + Assert::AreEqual(L"d", v[3].c_str()); } TEST_METHOD(list_nth_element_test) { - /*std::list c { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; + std::list c { 0, 1, 2, 3, 4, 5, 6, 7, 8 }; Assert::AreEqual(4, list_nth_element(c, 4)); - Assert::AreEqual(8, list_nth_element(c, 8));*/ + Assert::AreEqual(8, list_nth_element(c, 8)); } TEST_METHOD(list_sort_descending) { - /*std::list c { 7, 1, 5, 3, 4, 2 }; + std::list c { 7, 1, 5, 3, 4, 2 }; list_sort_desc(c); Assert::AreEqual(6u, c.size()); - Assert::IsTrue(std::is_sorted(c.rbegin(), c.rend()));*/ + Assert::IsTrue(std::is_sorted(c.rbegin(), c.rend())); } TEST_METHOD(unique_values_test) { - /*Assert::AreEqual(5, unique_numbers(std::wstringstream(L"-9 -7 -5 -3 -1"))); + Assert::AreEqual(5, unique_numbers(std::wstringstream(L"-9 -7 -5 -3 -1"))); Assert::AreEqual(3, unique_numbers(std::wstringstream(L"1 2 3 2 3 2 1 2 3"))); - Assert::AreEqual(2, unique_numbers(std::wstringstream(L"0 1 1 0 0 1 0")));*/ + Assert::AreEqual(2, unique_numbers(std::wstringstream(L"0 1 1 0 0 1 0"))); } TEST_METHOD(word_frequency_test) { - /*std::wstringstream ss(L"Lorem ipsum dolor sit amet lorem ipsum dolor"); + std::wstringstream ss(L"Lorem ipsum dolor sit amet lorem ipsum dolor"); word_frequency h(ss); 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")); - Assert::AreEqual(5, h.count());*/ + Assert::AreEqual(5, h.count()); } };