add kodu2

kodu/kodu2/main.cpp

+#include <iostream>
+#include <random>
+#include <sstream>
+#include <string>
+
+// Ülesanne 1.
+// Kirjuta funktsioon `is_palindrome`, mis kontrollib kas sõne on palindroom
+// (https://et.wikipedia.org/wiki/Palindroom). Ignoreeri tühikuid (whitespace)
+// ja suurtähelisust, s.t et "a A" on palindroom.
+//
+// Kasuta funktsioonide üle defineerimist, et funktsioon kasutaks mõlemat
+// tüüpi argumente, nii `std::string` kui ka C-tüüpi sõne `const char*`.
+// Mõlemad üle defineerimised peavad tagastama tõeväärtustüübi `bool`.
+//
+// Näide:
+//   is_palindrome("racecar") tagastab true
+//   is_palindrome(std::string("racecar")) tagastab true
+//   is_palindrome("") tagastab true
+//   is_palindrome("ab") tagastab false
+//
+// NB! Pane tähele, et ainult `bool is_palindrome(std::string)` loomisel
+// töötavad mõlemat tüüpi argumendid. Uuri iseseisvalt lähemalt miks see nii
+// juhtub.
+
+bool is_palindrome(const char *s) {
+  size_t left = 0;
+  auto length = std::strlen(s);
+
+  if (length == 0) {
+    return true;
+  }
+
+  size_t right = length - 1;
+
+  while (left < right) {
+    if (left < right && std::tolower(s[left]) != std::tolower(s[right])) {
+      return false;
+    }
+
+    left++;
+    right--;
+  }
+
+  return true;
+}
+
+bool is_palindrome(std::string s) { return is_palindrome(s.c_str()); }
+
+// Ülesanne 2.
+// Kirjuta funktsioon `word_count`, mis loeb sõnade arvu antud sõnes.
+// Siin kontekstis tähendab sõna tühikutega (whitespace) eraldatud karakterite
+// jada. Tühjas sõnes on 0 sõna.
+//
+// Näide:
+//   word_count("Tere maailm!") tagastab 2 ja toimib järgmiselt:
+//     1. sõna on "Tere"
+//     2. sõna on "maailm!"
+
+size_t word_count(std::string s) {
+  std::stringstream ss(s);
+
+  size_t count = 0;
+  std::string sona;
+  while (ss >> sona) {
+    count++;
+  }
+
+  return count;
+}
+
+// Ülesanne 3.
+// Kirjuta funktsioon `words`, mis tagastab konteineri
+// `std::vector<std::string>`, ning tagastab iga sõna antud sõnes. Sõna on siin
+// kontekstis sama, mis ülesandes 2.
+//
+// Näide:
+//   words("Tere maailm!") tagastab vektori, kus on sõnad "Tere" ja "maailm!"
+//   words("a b c d ") tagastab vektori, kus on sõnad "a", "b", "c" ja "d"
+//     Pane tähele, et viimane sõna on "d" mitte "", s.t ignoreeri ülejäänud
+//     tühikuid
+//
+// Vihje: Proovi kasutada klassi `std::stringstream`
+
+std::vector<std::string> words(std::string s) {
+  std::vector<std::string> words;
+  std::stringstream ss(s);
+
+  std::string sona;
+  while (ss >> sona) {
+    words.push_back(sona);
+  }
+
+  return words;
+}
+
+// Ülesanne 4.
+// Kirjuta funktsioon `random_diff`, mis saab argumendiks täisarvu n ning
+// konstrueerib 2 täisarvuvektorit (`std::vector<int>`). Seejärel lisab
+// funktsioon mõlemasse vektorisse juhuslikke arve senikaua kuni mõlema vektori
+// pikkus on n. Vali ise, mille alusel vektoreid täita. Funktsioon tagastab
+// vektori vastavate elementide vahede summa. See tähendab, et kui vektor a =
+// {1, 2, 3} ja b = {4, 5, 6} siis tagastatakse sum({1 - 4, 2 - 5, 3 - 6}) = -9
+// Üleval toodud näidis on pseudokood ja ei ole valiidne C++ keeles.
+//
+// NB! Ära kasuta funktsiooni `rand()`.
+// NB! Ülesannet on võimalik lahendada ilma vektoriteta, aga lahenda siiski
+// kasutades vektoreid.
+
+int random_diff(int n) {
+  std::vector<int> v1(n);
+  std::vector<int> v2(n);
+
+  std::default_random_engine gen;
+  std::uniform_int_distribution<int> jaotus(-100, 100);
+  for (int i = 0; i < n; ++i) {
+    v1[i] = jaotus(gen);
+    v2[i] = jaotus(gen);
+  }
+  std::vector<int> diffs(n);
+  for (int i = 0; i < n; ++i) {
+    diffs[i] = v1[i] - v2[i];
+  }
+  int sum = 0;
+  for (int i = 0; i < n; ++i) {
+    sum += diffs[i];
+  }
+  // Võimalus, kuidas vektori elemendid kokku liita
+  // return std::reduce(diffs.begin(), diffs.end(), 0);
+  return sum;
+}
+
+// Ülesanne 5.
+// Kirjuta funktsioon `randomize`, mis saab argumendiks C-tüüpi täisarvude
+// massiivi ning selle pikkuse (tüüpi size_t). Seejärel täidab fuktsioon antud
+// massiivi juhuslike arvudega ning tagastab nende arvude summa. Võid eeldada,
+// et n > 0
+//
+// Näide:
+//   int arr[10] = {0};
+//   size_t size = 10;
+//   int sum = randomize(arr, size);
+//   // nüüd on massiivis juhuslikud arvud ja sum võrdne nende summaga
+
+int randomize(int *arr, size_t n) {
+  auto sum = 0;
+  std::default_random_engine gen;
+  std::uniform_int_distribution<int> jaotus(-100, 100);
+  for (size_t i = 0; i < n; i++) {
+    auto x = jaotus(gen);
+    arr[i] = x;
+    sum += x;
+  }
+  return sum;
+}
+
+// Ülesanne 6.
+// Kirjuta funktsioon `average`, mis saab argumendiks konteineri
+// `std::array<int, 10>` ning tagastab nende arvude aritmeetilise keskmise.
+//
+// Näide:
+//   std::array<int, 10> arr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+//   average(arr) tagastab keskmise 5.5
+//
+// NB! Pane tähele, et funktsioon aktsepteerib argumendina ainult `std::array`
+// konteinereid mille pikkus on 10. Selle piirangu eemaldamist vaatame tulevatel
+// nädalatel.
+//
+// Mõtle std::array ja C-tüüpi massiivide erisuse peale
+
+float average(std::array<int, 10> arr) {
+  return std::reduce(arr.begin(), arr.end(), 0) /
+         static_cast<float>(arr.size());
+}
+
+// Ära neid muutujaid ja funktsioone redigeeri.
+static int g_TotalTestCount = 0;
+static int g_SuccessfulTestCount = 0;
+
+#define TEST(condition) testAssert(condition, __FILE__, __LINE__)
+
+void testAssert(bool condition, const char *file, int line) {
+  g_TotalTestCount++;
+  if (!condition) {
+    std::cout << "VIGA: Kontroll asukohas " << file << ":" << line
+              << " ei olnud õige.\n";
+  } else {
+    g_SuccessfulTestCount++;
+  }
+}
+
+auto equal(auto a, auto b) {
+  if (a.size() != b.size()) {
+    return false;
+  }
+
+  return std::equal(a.begin(), a.end(), b.begin());
+}
+
+template <typename T> auto all(T *ptr, size_t count, T comp) {
+  return std::all_of(ptr, ptr + count, [comp](auto v) { return v == comp; });
+}
+
+int main() {
+  // Ülesanne 1. Palindroom
+  TEST(is_palindrome("racecar") == true);
+  TEST(is_palindrome("raCecaR") == true);
+  TEST(is_palindrome(std::string("racecar")) == true);
+  TEST(is_palindrome(std::string("")) == true);
+  TEST(is_palindrome(std::string("aa")) == true);
+  TEST(is_palindrome(std::string("ab")) == false);
+  TEST(is_palindrome(std::string("()()")) == false);
+  TEST(is_palindrome(std::string("())(")) == true);
+
+  // Ülesanne 2. Sõnade arv
+  TEST(word_count("") == 0);
+  TEST(word_count("A B") == 2);
+  TEST(word_count("A B ") == 2);
+  TEST(word_count("Tere maailm!") == 2);
+
+  // Ülesanne 3. Sõnad
+  using StrVector = std::vector<std::string>;
+  TEST(words("").empty());
+  TEST(equal(words("A B"), StrVector{"A", "B"}));
+  TEST(equal(words("A B "), StrVector{"A", "B"}));
+  TEST(equal(words("a b c d"), StrVector{"a", "b", "c", "d"}));
+
+  // Ülesanne 4. Suvalised arvud
+  // NB! Korrektset tulemust on pisut keerukam testida. Proovi mõelda, kuidas
+  // sina seda testiksid.
+  TEST(random_diff(10) != std::numeric_limits<int>::min());
+
+  {
+    int arr[10] = {0};
+    size_t size = 10;
+    int sum = randomize(arr, size);
+    // Statistiliselt ei tohiks summa olla 0.
+    TEST(sum > 0);
+    // Arvud ei tohiks olla 0.
+    TEST(!all(arr, size, 0));
+  }
+
+  // Ülesanne 5. Keskmine väärtus
+  {
+    std::array arr{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    TEST(average(arr) == 5.5f);
+  }
+
+  std::cout << "Testide tulemus: " << g_SuccessfulTestCount << "/"
+            << g_TotalTestCount << '\n';
+  return 0;
+}