Advertisement
NickAndNick

Interactive work with an array

Sep 16th, 2023 (edited)
764
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 3.67 KB | Software | 0 0
  1. #include <cctype>
  2. #include <iomanip>
  3. #include <iostream>
  4. #include <random>
  5. #include <string>
  6.  
  7. using namespace std;
  8.  
  9. void flush(istream& inp = cin) {
  10.     inp.ignore(0x1000, '\n');
  11. }
  12.  
  13. double double_parse(const string& msg = "") {
  14.     string word;
  15.     double value{};
  16.     while (true) {
  17.         cout << msg;
  18.         cin >> word;
  19.         flush();
  20.         try {
  21.             value = stod(word);
  22.             return value;
  23.         } catch (invalid_argument& e) {
  24.             cin.clear();
  25.         } catch (out_of_range& e) {}
  26.     }
  27. }
  28.  
  29. size_t size_t_parse(const char* msg = "") {
  30.     string word;
  31.     size_t value{};
  32.     while (true) {
  33.         cout << msg;
  34.         cin >> word;
  35.         flush();
  36.         try {
  37.             if (sizeof(size_t) == 4) value = stoul(word);
  38.             else value = stoull(word);
  39.             return value;
  40.         } catch (invalid_argument& e) {
  41.             cin.clear();
  42.         } catch (out_of_range& e) {}
  43.     }
  44. }
  45.  
  46. enum class Menu {
  47.     Average = 0x61,
  48.     Create  = 0x63,
  49.     Fill    = 0x66,
  50.     Exit    = 0x65,
  51.     Random  = 0x72,
  52.     Sum     = 0x73
  53. };
  54.  
  55. Menu point() {
  56.     char ch;
  57.     cin >> ch;
  58.     cin.ignore(0x1000, '\n');
  59.     return Menu(tolower(ch));
  60. }
  61.  
  62. double* create(const size_t n) {
  63.     return new(nothrow) double[n];
  64. }
  65.  
  66. double* destroy(double* vec) {
  67.     if (vec != nullptr) {
  68.         delete[] vec;
  69.         vec = nullptr;
  70.     }
  71.     return vec;
  72. }
  73.  
  74. bool fill(double* vec, const size_t n) {
  75.     puts("Input array:");
  76.     for (size_t i = 0; i < n; ++i) {
  77.         vec[i] = double_parse("[" + to_string(i) + "] => ");
  78.     }
  79.     return true;
  80. }
  81.  
  82. bool rand(double* vec, const size_t n) {
  83.     uniform_int_distribution<> uid(-99, 99);
  84.     mt19937 gen{ random_device()() };
  85.     cout.setf(ios::fixed);
  86.     cout.precision(1);
  87.     for (size_t i = 0; i < n; ++i) {
  88.         vec[i] = uid(gen) / 10.0;
  89.         cout << setw(8) << vec[i];
  90.     }
  91.     puts("");
  92.     cout.unsetf(ios::fixed);
  93.     cout.precision(8);
  94.     return true;
  95. }
  96.  
  97. void average(double* vec, const size_t n) {
  98.     auto sum = 0.0;
  99.     size_t cnt = 0;
  100.     for (size_t i = 0; i < n; ++i) {
  101.         if (vec[i] > 0) {
  102.             sum += vec[i];
  103.             ++cnt;
  104.         }
  105.     }
  106.     cout << "Average: " << (cnt ? sum / cnt : 0) << '\n';
  107. }
  108.  
  109. size_t max_element(double* vec, const size_t n) {
  110.     size_t max = 0;
  111.     for (size_t i = 1; i < n; ++i) {
  112.         if (vec[max] < vec[i]) max = i;
  113.     }
  114.     return max;
  115. }
  116.  
  117. void sum(double* vec, const size_t n) {
  118.     const auto pos = max_element(vec, n);
  119.     auto sum = 0.0;
  120.     for (size_t i = 0; i < pos; ++i) sum += vec[i];
  121.     cout << "Sum: " << sum << '\n';
  122. }
  123.  
  124. int main() {
  125.     size_t n = 0;
  126.     double* vec = nullptr;
  127.     auto flag = false;
  128.     while (true) {
  129.         puts("Input char C => Create Array");
  130.         if (vec) {
  131.             puts("Input char F => Fill");
  132.             puts("Input char R => Random Fill");
  133.             if (flag) {
  134.                 puts("Input char A => Average");
  135.                 puts("Input char S => Sum");
  136.             }
  137.         }
  138.         puts("Input char E => Exit");
  139.         switch (point()) {
  140.         case Menu::Create:
  141.             destroy(vec);
  142.             n = size_t_parse("Input size: ");
  143.             vec = create(n);
  144.             if (!vec) puts("Not enough memory!");
  145.             break;
  146.         case Menu::Fill: flag = fill(vec, n); break;
  147.         case Menu::Random: flag = rand(vec, n); break;
  148.         case Menu::Average: average(vec, n); break;
  149.         case Menu::Sum: sum(vec, n); break;
  150.         case Menu::Exit: return 0;
  151.         case Menu::Exit: if (destroy(vec) == nullptr) return 0;
  152.         default: puts("Invalid input!");
  153.         }
  154.     }
  155. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement