Skip to content

Dean Leibner Day4 #5

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
DLeibner wants to merge 2 commits into
base: master
Choose a base branch
from
Open

Dean Leibner Day4 #5

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
67e677a
exercise 01
Nov 15, 2018
c6bb8ba
exercise 02
Nov 15, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
81 changes: 81 additions & 0 deletions exercise/01/containers.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,81 @@
#include "containers.h"
#include <set>
#include <locale>
#include <cwctype>

void remove_element(std::vector<int>& v, int index)
{
v.erase(v.begin() + index);
}

void input_element(std::vector<std::wstring>& v, int index, const std::wstring& value)
{
v.insert(v.begin() + index, value);
}

int list_nth_element(const std::list<int>& c, int index)
{
std::list<int>::const_iterator it = c.begin();
std::advance(it, index);

return *it;
}

void list_sort_desc(std::list<int>& c)
{
c.sort();
c.reverse();
}

int unique_numbers(std::wistream& s)
{
int n;
std::set<int> uniqueNumbers;

while (s >> n)
{
uniqueNumbers.insert(n);
}

return uniqueNumbers.size();
}

word_frequency::word_frequency(std::wistream& stream)
{
std::wstring s;
while (stream >> s)
{
ToLower(s);
if (data.find(s) != data.end())
{
data[s]++;
}
else
{
data[s] = 1;
}
}
}

int word_frequency::frequency(const std::wstring& s)
{
if (data.find(s) != data.end())
{
return data[s];
}

return 0;
}

int word_frequency::count()
{
return data.size();
}

void word_frequency::ToLower(std::wstring& str)
{
for(wchar_t& c : str)
{
c= std::towlower(c);
}
}
5 changes: 5 additions & 0 deletions exercise/01/containers.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@
#include <string>
#include <vector>
#include <list>
#include <map>

void remove_element(std::vector<int>& v, int index);
void input_element(std::vector<std::wstring>& v, int index, const std::wstring& value);
Expand All @@ -17,4 +18,8 @@ class word_frequency
word_frequency(std::wistream&);
int frequency(const std::wstring& s);
int count();

private:
std::map<std::wstring, int> data;
void ToLower(std::wstring& str);
};
95 changes: 70 additions & 25 deletions exercise/02/algorithms_test.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,8 +15,8 @@ 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

// 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]);
Expand All @@ -26,7 +26,8 @@ TEST_CLASS(test_standard_algorithms_usage)
TEST_METHOD(test_02a)
{
std::vector<int> v(10);
// TODO: fill vector with incremental values
// 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]);
Expand All @@ -36,7 +37,8 @@ TEST_CLASS(test_standard_algorithms_usage)
{
// generate
std::vector<int> v(10);
// TODO: fill vector with incremental values (by 2)
// fill vector with incremental values (by 2)
std::generate(v.begin(), v.end(), [n = -1]() mutable { 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]);
Expand All @@ -45,8 +47,9 @@ 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::vector<int> v = { 1, 5, 10 };
// change all values in a vector
std::for_each(v.begin(), v.end(), [](int& n) { n = pow(n, 3); });
Assert::AreEqual(3u, v.size());
Assert::AreEqual(1, v[0]);
Assert::AreEqual(125, v[1]);
Expand All @@ -58,7 +61,8 @@ TEST_CLASS(test_standard_algorithms_usage)
std::vector<int> y = { 4, 12, 10 };
std::vector<double> d;

// TODO: calculate distances from origin (from x and y collections) to new vector
// calculate distances from origin (from x and y collections) to new vector
std::transform(std::begin(x), std::end(x), std::begin(y), std::back_inserter(d), [](int x, int y) { return sqrt(pow(x, 2) + pow(y, 2)); });
Assert::AreEqual(3u, d.size());
Assert::AreEqual(5., d[0]);
Assert::AreEqual(13., d[1]);
Expand All @@ -67,67 +71,83 @@ 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
// 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
// concatenated string with additional prefix
auto res = std::accumulate(v.begin(), v.end(), std::wstring(L"GO "), [](std::wstring result, std::wstring current) { result += current; return result; });
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
// sum of all ages
auto total_age = std::accumulate(v.begin(), v.end(), 0, [](int age, const person& p) { age += p.age; return 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 n) { return n < 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(v.begin(), v.end(), 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(v.begin(), v.end(), [](const point& 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:
auto first_prime = *std::find_if(v.begin(), v.end(), [](int n)
{
if (n <= 1) return false;

for (auto i=2; i < sqrt(n); ++i)
{
if (n % i == 0) return false;
}

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
// 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]);
}
TEST_METHOD(test_07b)
{
std::wstring s(L"ponedjeljak");
// TODO: change every vowel with x
// change every vowel with x
std::replace_if(s.begin(), s.end(), [](wchar_t c) { return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; }, L'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)
// delete all invalid values (1e10)
v.erase(std::remove(v.begin(), v.end(), 1e10), v.end());
Assert::AreEqual(5u, v.size());
Assert::AreEqual(8., v[0]);
Assert::AreEqual(99., v[4]);
Expand All @@ -136,14 +156,37 @@ TEST_CLASS(test_standard_algorithms_usage)
TEST_METHOD(test_08b)
{
std::wstring s(L"ponedjeljak");
// TODO: delete all vowels
// delete all vowels
s.erase(std::remove_if(s.begin(), s.end(), [](wchar_t c) { return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u'; }), s.end());
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
// sort vector by grade, then by points
std::sort(v.begin(), v.end(), [](const exam& e1, const exam& e2)
{
if (e1.grade < e2.grade)
{
return false;
}
else if (e1.grade > e2.grade)
{
return true;
}
else
{
if (e1.points <= e2.points)
{
return false;
}
else
{
return true;
}
}
});
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());
Expand All @@ -162,7 +205,8 @@ 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.
// 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
Expand All @@ -172,23 +216,24 @@ TEST_CLASS(test_standard_algorithms_usage)
{
struct employee { std::wstring name; int salary; };
std::vector<employee> v{ {L"Iva", 2000}, {L"Pero", 1000}, {L"Marko", 10000} };
// TODO: put employee with median salary in the middle of vector
std::nth_element(v.begin(), v.begin() + v.size() / 2, v.end(), [](const employee& a, const employee& b) { return a.salary < b.salary; });
// put employee with median salary in the middle of vector
std::nth_element(v.begin(), v.begin() + v.size() / 2, v.end(), [](const employee& e1, const employee& e2) { return e1.salary < e2.salary; });
Assert::AreEqual(L"Iva", v[v.size() / 2].name.c_str()); // median_salary
}
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::adjacent_difference(atp_points.begin(), atp_points.end(), atp_points.begin(), [](int a, int b) { return abs(a - b); });
auto smallest_difference = *std::min_element(atp_points.begin(), atp_points.end());
Assert::AreEqual(15, smallest_difference);
}
};