1
#include <cstdint>
2
#include <print>
3
#include <iostream>
4
#include <vector>
5
#include <numeric>
6
#include <stdint.h>
7

8
int main(){
9
  std::vector<int> array_c;
10
  std::vector<int> array_p;
11

12
  signed quantity = 0;
13
  std::print("Введите количество цифр для множеств C и P: ");
14
  std::cin >> quantity;
15

16
  std::print("Введите цифры C: ");
17

18
  for(signed i =0;i< quantity ;i++){
19
    int number;
20
    std::cin >> number;
21
    array_c.push_back(number);
22
  }
23

24

25
  std::print("Введите цифры P: ");
26
  for(int i =0;i< quantity ;i++){
27
    int number;
28
    std::cin >> number;
29
    array_p.push_back(number);
30
  }
31

32
  int sum_of_array_p = std::accumulate(array_p.begin(), array_p.end(), 0);
33
  bool is_all_positive = true;
34

35
  for (const int& x: array_c ){
36
    if (x > sum_of_array_p){
37
      std::print("Элемент первого массива больше или равен сумме элементов другого");
38
      return 0 ;
39
    }
40
  }
41

42
  float max_calculation = array_c[0] / (array_p[0] + array_c[0] * 2);
43

44
  int max_i = 0;
45
  int max_j = 0;
46

47
  for(int i = 0; i < quantity; i++){
48
    for(int j = 0; j < quantity; j++){
49
      float max_calculated = (float)array_c[i] / (float)(array_p[j] + array_c[j] * 2);
50

51
      if(max_calculated > max_calculation){
52
        max_calculation = max_calculated;
53
        max_i = i;
54
        max_j = j;
55
      }
56
    }
57
  }
58

59
  std::print("Максимальное значение выражения Ci / (Pj + Cj * 2): {0}", max_calculation);
60
  std::print("При i = {}, j = {}", max_i, max_j);
61
}

1
#include <cstdint>
2
#include <iostream>
3
#include <numeric>
4
#include <print>
5
#include <stdint.h>
6
#include <vector>
7

8
class FormulaCalculator {
9
private:
10
  std::vector<int> array_c;
11
  std::vector<int> array_p;
12

13
public:
14
  FormulaCalculator(std::vector<int> arr_c, std::vector<int> arr_p) : array_c(arr_c), array_p(arr_p) {
15
    if (arr_c.size() != arr_p.size()) {
16
      throw "Ошибка размеров!";
17
    }
18
  }
19

20
  int get_sum_of_array(const std::vector<int> &array) {
21
    return std::accumulate(array.begin(), array.end(), 0);
22
  }
23

24
  bool check_for_requirement() {
25
    int sum_of_array_p = get_sum_of_array(array_p);
26

27
    for (const int &x : array_c) {
28
      if (x > sum_of_array_p) {
29
        return false;
30
      }
31
    }
32

33
    return true;
34
  }
35

36
  std::tuple<float, int, int> calculate() {
37
    float max_calculation = (float)array_c[0] / (array_p[0] + array_c[0] * 2);
38

39
    int max_i = 0;
40
    int max_j = 0;
41

42
    for (int i = 0; i < array_c.size(); i++) {
43
      for (int j = 0; j < array_c.size(); j++) {
44
        float max_calculated = (float)array_c[i] / (float)(array_p[j] + array_c[j] * 2);
45

46
        if (max_calculated > max_calculation) {
47
          max_calculation = max_calculated;
48
          max_i = i;
49
          max_j = j;
50
        }
51
      }
52
    }
53

54
    return {max_calculation, max_i, max_j};
55
  }
56
};
57

58
void get_values_for_array(std::vector<int> &array, signed quantity) {
59
  for (signed i = 0; i < quantity; i++) {
60
    int number;
61
    std::cin >> number;
62
    array.push_back(number);
63
  }
64
}
65

66
int main() {
67
  std::vector<int> array_c;
68
  std::vector<int> array_p;
69

70
  signed quantity = 0;
71
  std::println("Введите количество цифр для множеств C и P: ");
72
  std::cin >> quantity;
73

74
  std::println("Введите цифры C: ");
75
  get_values_for_array(array_c, quantity);
76

77
  std::println("Введите цифры P: ");
78
  get_values_for_array(array_p, quantity);
79

80
  FormulaCalculator calc(array_c, array_p);
81

82
  if (!calc.check_for_requirement()) {
83
    std::println("Элемент первого массива больше или равен сумме элементов другого");
84
    return 0;
85
  }
86

87
  auto max_calculation = calc.calculate();
88

89
  std::println("Максимальное значение выражения Ci / (Pj + Cj * 2): {0}", std::get<0>(max_calculation));
90
  std::println("При i = {}, j = {}", std::get<1>(max_calculation), std::get<2>(max_calculation));
91
}