Часть №10: Практические задания по С++ / Ravesli

SirAyane:

24 июля 2022 в 10:48

задание н.2

#include <iostream>
#include <conio.h>
int main() 
{
	uint8_t a = 6,sum1{}, sum2{},temp;
	while (a--)
	{
		temp = _getch();
		if (temp >= '0' && temp <= '9') { std::cout << temp; (a > 2 ? sum1 : sum2) += temp; }
		else a++;
	}
	std::cout << "\nYour num is " << (sum1 == sum2 ? "magikal." : "not magikal.");
}

1

2

3

4

5

6

7

8

9

10

11

12

13

#include <iostream>

#include <conio.h>

int main()

{

uint8_t a = 6,sum1{}, sum2{},temp;

while (a--)

{

temp = _getch();

if (temp >= '0' && temp <= '9') { std::cout << temp; (a > 2 ? sum1 : sum2) += temp; }

else a++;

}

std::cout << "\nYour num is " << (sum1 == sum2 ? "magikal." : "not magikal.");

}

Ответить

Антон:

17 мая 2022 в 20:56

Мое решение задание №2 (исправлено). В первом варианте были ошибки

#include<iostream>
#include<locale>
#include<string>
#include<math.h>
using namespace std;
int main()
{
	setlocale(LC_ALL, "rus");
	std::cout << "Введите шестизначное число: ";
	int x;
	std::cin >> x;
	std::cout << endl;
	int x1 = x / 100000;
	int x2 = (x / 10000) - x1*10;
	int x3 = (x / 1000) - (x2*10)-x1*100;
	int x4 = (x / 100) - (x2 * 100) - (x3 * 10) - x1*1000;
	int x5 = (x / 10) - 10000*x1 - (x2 * 1000) - (x3 * 100) - (x4 * 10);
	int x6 = x -x1*100000- (x2 * 10000) - (x3 * 1000) - (x4 * 100) - (x5 * 10);
	int sum1 = x1 + x2 + x3;
	int sum2 = x4 + x5 + x6;
	if (sum1 == sum2)
	{
		std::cout << "Введенное шестизначное число " << x << " есть 'счастливым'"<<endl;
}
	else if (x > 999999 || x < 100000)
	{
		std::cout << "Вы ввели не шестизначное число. Перезапустите программу и попробуйте еще раз" << endl;
	}
	else
	{
		std::cout << "Введенное шестизначное число " << x << "  не есть 'счастливым'" << endl;
	}

	system("pause");
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

#include<iostream>

#include<locale>

#include<string>

#include<math.h>

using namespace std;

int main()

{

setlocale(LC_ALL, "rus");

std::cout << "Введите шестизначное число: ";

int x;

std::cin >> x;

std::cout << endl;

int x1 = x / 100000;

int x2 = (x / 10000) - x1*10;

int x3 = (x / 1000) - (x2*10)-x1*100;

int x4 = (x / 100) - (x2 * 100) - (x3 * 10) - x1*1000;

int x5 = (x / 10) - 10000*x1 - (x2 * 1000) - (x3 * 100) - (x4 * 10);

int x6 = x -x1*100000- (x2 * 10000) - (x3 * 1000) - (x4 * 100) - (x5 * 10);

int sum1 = x1 + x2 + x3;

int sum2 = x4 + x5 + x6;

if (sum1 == sum2)

{

std::cout << "Введенное шестизначное число " << x << " есть 'счастливым'"<<endl;

}

else if (x > 999999 || x < 100000)

{

std::cout << "Вы ввели не шестизначное число. Перезапустите программу и попробуйте еще раз" << endl;

}

else

{

std::cout << "Введенное шестизначное число " << x << " не есть 'счастливым'" << endl;

}

system("pause");

return 0;

}

Ответить

Антон:

21 апреля 2022 в 23:37

Задание 1

Не могу преобразовать решение в дробное число (если получается целое)

#include<iostream>
#include<locale>
#include<vector>
#include <cmath>
using namespace std;

int main()
{
	setlocale(LC_ALL, "rus");
	std::cout << "Ведите последовательность дробных чисел (если вы закончили введите 0 и нажмите enter): ";
	std::vector<double>array;
	double x;
	double sum = 0.0;
	do
	{
		std::cin >> x;
		array.push_back(x);
	} while (x);
	while (!array.empty())
	{

		sum += array.back();
		array.pop_back();

	}
	double n = array.capacity()-1;
	float ser = sum / n;
	std::cout << "Среднее арифметическое введеной последовательности: "<<ser<< endl;
	system("pause");
		return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

#include<iostream>

#include<locale>

#include<vector>

#include <cmath>

using namespace std;

int main()

{

setlocale(LC_ALL, "rus");

std::cout << "Ведите последовательность дробных чисел (если вы закончили введите 0 и нажмите enter): ";

std::vector<double>array;

double x;

double sum = 0.0;

do

{

std::cin >> x;

array.push_back(x);

} while (x);

while (!array.empty())

{

sum += array.back();

array.pop_back();

}

double n = array.capacity()-1;

float ser = sum / n;

std::cout << "Среднее арифметическое введеной последовательности: "<<ser<< endl;

system("pause");

return 0;

}

Ответить

Mixa:

26 декабря 2021 в 00:28

Задание 2

#include <iostream>
#include <vector>
using namespace std;
bool cool_number(int x)
{
    int a[6];
    a[0] = x / 100000;
    a[1] = (x / 10000)%10;
    a[2] = ((x / 1000) %100)%10;
    a[3] = ((((x/100)%1000)%100)%10);
    a[4] = ((((x/10)%10000)%1000)%100)%10;
    a[5] = (((((x%100000)%10000)%1000)%100)%10);
    int sum1 = a[0]+a[1]+a[2];
    int sum2 = a[3] +a[4] + a[5];
    return (sum2 == sum1);
    
}
int main()
{
    int a;
    cout<<"Введите шестизначное число: ";
    cin>>a;
    cool_number(a) ? cout << a<<" счастливое число" : cout << a<<" не счастливое число";
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

#include <iostream>

#include <vector>

using namespace std;

bool cool_number(int x)

{

int a[6];

a[0] = x / 100000;

a[1] = (x / 10000)%10;

a[2] = ((x / 1000) %100)%10;

a[3] = ((((x/100)%1000)%100)%10);

a[4] = ((((x/10)%10000)%1000)%100)%10;

a[5] = (((((x%100000)%10000)%1000)%100)%10);

int sum1 = a[0]+a[1]+a[2];

int sum2 = a[3] +a[4] + a[5];

return (sum2 == sum1);

}

int main()

{

int a;

cout<<"Введите шестизначное число: ";

cin>>a;

cool_number(a) ? cout << a<<" счастливое число" : cout << a<<" не счастливое число";

}

Ответить

Mixa:

26 декабря 2021 в 00:07

Задание 1

#include <iostream>
#include <vector>
using namespace std;
int main()
{
    setlocale(0, "Ru");
    const int SIZE = 5;
    double sum=0, temp;
    cout<<"Введите последовательность дробных чисел: ";
    for (int i = 0; i <SIZE; i++) {
        std::cin >> temp;
        sum+=temp;
    }
    cout<<"Среднее арифметическое введенной последовательности: "<<sum/SIZE;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#include <iostream>

#include <vector>

using namespace std;

int main()

{

setlocale(0, "Ru");

const int SIZE = 5;

double sum=0, temp;

cout<<"Введите последовательность дробных чисел: ";

for (int i = 0; i <SIZE; i++) {

std::cin >> temp;

sum+=temp;

}

cout<<"Среднее арифметическое введенной последовательности: "<<sum/SIZE;

}

Ответить

WAR:

22 августа 2021 в 13:52

Задание №2:

#include <iostream>
#include <string>

int sumPart(std::string s, int start, int len) {
	int res{0};
	for(int i{start}; i < len; ++i) res += (s[i] - '0');
	return res;
}

int main() {
int num{0};
while(num < 100000 || num > 999000) {
	std::cout<<"Enter 6-sign number: ";
	std::cin >> num;
}
std::string str = std::to_string(num);
int sum = sumPart(str, 0, 3);
int sum2 = sumPart(str, 3, 6);
sum == sum2 ? std::cout << "Number: " << num << " is Happie!":
	std::cout << "Number: " << num << " not is Happie";
return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

#include <iostream>

#include <string>

int sumPart(std::string s, int start, int len) {

int res{0};

for(int i{start}; i < len; ++i) res += (s[i] - '0');

return res;

}

int main() {

int num{0};

while(num < 100000 || num > 999000) {

std::cout<<"Enter 6-sign number: ";

std::cin >> num;

}

std::string str = std::to_string(num);

int sum = sumPart(str, 0, 3);

int sum2 = sumPart(str, 3, 6);

sum == sum2 ? std::cout << "Number: " << num << " is Happie!":

std::cout << "Number: " << num << " not is Happie";

return 0;

}

Ответить

WAR:

22 августа 2021 в 13:19

Задание №1:

#include <iostream>

int main() {
int size{5};
double sum{0}, average{0}, num{0};
for(int i{0}; i<size; ++i) {
	std::cout<<"Enter number: ";
	std::cin >> num;
	sum += num;
}
average = sum / size;
std::cout<<"\nAverage is: "<<average;
return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

#include <iostream>

int main() {

int size{5};

double sum{0}, average{0}, num{0};

for(int i{0}; i<size; ++i) {

std::cout<<"Enter number: ";

std::cin >> num;

sum += num;

}

average = sum / size;

std::cout<<"\nAverage is: "<<average;

return 0;

}

Ответить

Rock:

20 декабря 2020 в 02:31

Задание 1:

#include <iostream>
#include<vector>

double Mid_aref(std::vector<double> &vect)
{
	double result=0;
	for (int i = 0; i < vect.size(); i++)
	{
		result += vect[i];
	}

	return result / vect.size();
}

int main()
{
	setlocale(0, "");

	std::vector<double> vect;
	int x,lock=0;
	double y;

	std::cout << "Введите сколько чисел вы хотите задать для вычисления среднего арифметического - ";
	std::cin >> x;
	std::cout << "Вводите числа в формате #.## " << std::endl;

	while (lock < x)
	{
		std::cin >> y;
		vect.push_back(y);
		lock++;
	}
	
	std::cout << "Среднее арифметическое ваших чисел = " << Mid_aref(vect) << std::endl;

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

#include <iostream>

#include<vector>

double Mid_aref(std::vector<double> &vect)

{

double result=0;

for (int i = 0; i < vect.size(); i++)

{

result += vect[i];

}

return result / vect.size();

}

int main()

{

setlocale(0, "");

std::vector<double> vect;

int x,lock=0;

double y;

std::cout << "Введите сколько чисел вы хотите задать для вычисления среднего арифметического - ";

std::cin >> x;

std::cout << "Вводите числа в формате #.## " << std::endl;

while (lock < x)

{

std::cin >> y;

vect.push_back(y);

lock++;

}

std::cout << "Среднее арифметическое ваших чисел = " << Mid_aref(vect) << std::endl;

return 0;

}

Задача 2: Пришлось запарится с конвертацией и записью в массив
можно было использовать только математику и уложится в в 3 раза меньше кода но тогда пропадет возможность ввести любое число для проверки

#include<iostream>
#include<vector>

void convert(std::string& str,std::vector<int> &vect)
{
	for (int i = 0; i < str.length(); i++)
	{
		std::string buff;
		buff = str[i];

		vect.push_back(std::atoi(buff.c_str()));// функция конвертации string в int  c_str() возвращает указатель на массив 
	}
}

bool is_Luck(std::string& str)
{

	std::vector<int> vect;
	
	int x=0, y=0;
	convert(str, vect);

	int iter, cycle;

	if (vect.size() % 2 == 0)
	{
		iter = vect.size() / 2;
		cycle = vect.size() / 2;
	}
	else
	{
		iter = vect.size() / 2 + 1;
		cycle = vect.size() / 2 + 1;
		vect.push_back(0);
	}

	for (int i = 0; i < cycle; i++)
	{
		y += vect[iter];
		x += vect[i];
		iter++;
	}

	if (y == x)
		return true;

	return false;
}


int main()
{
	setlocale(0, "");

	std::string str; 
	
	std::cout << "Введите 6-тизначное число для того что бы узнать счастливое ли оно: ";

	std::cin >> str;

	if (is_Luck(str))
	{
		std::cout << "Ваше число счастливое!" << std::endl;
	}
	else
	{
		std::cout << "Ваше число несчастливое..." << std::endl;
	}

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

#include<iostream>

#include<vector>

void convert(std::string& str,std::vector<int> &vect)

{

for (int i = 0; i < str.length(); i++)

{

std::string buff;

buff = str[i];

vect.push_back(std::atoi(buff.c_str()));// функция конвертации string в int c_str() возвращает указатель на массив

}

bool is_Luck(std::string& str)

{

std::vector<int> vect;

int x=0, y=0;

convert(str, vect);

int iter, cycle;

if (vect.size() % 2 == 0)

{

iter = vect.size() / 2;

cycle = vect.size() / 2;

}

else

{

iter = vect.size() / 2 + 1;

cycle = vect.size() / 2 + 1;

vect.push_back(0);

}

for (int i = 0; i < cycle; i++)

{

y += vect[iter];

x += vect[i];

iter++;

}

if (y == x)

return true;

return false;

}

int main()

{

setlocale(0, "");

std::string str;

std::cout << "Введите 6-тизначное число для того что бы узнать счастливое ли оно: ";

std::cin >> str;

if (is_Luck(str))

{

std::cout << "Ваше число счастливое!" << std::endl;

}

else

{

std::cout << "Ваше число несчастливое..." << std::endl;

}

return 0;

}

Задача 3: Просто но писать много)

Проверки, вводы ,выводы и манипуляции с массивами. В принципе очень приближенное к реальности задание

#include<iostream>
#include<array>
#include<vector>
#include<algorithm>


template <typename T>
T Proverka(T& x)
{

	if (std::cin.fail())
	{
		std::cin.clear();
		std::cin.ignore(32767, '\n');
		std::cout << "Вы ввели недопустимое значение. Повторите ввод." << std::endl;

		std::cin >> x;
		return Proverka(x);
	}
	else
	{
		std::cin.ignore(32767, '\n');
		return x;
	}

}


struct Student 
{
	std::string name;
	int year;
	std::array<double, 5> rating;
};


void set_Student(std::vector<Student> &vect) // ввод данных для заполнения вектора студентами с данными
{
	vect.erase(vect.begin(), vect.end()); // очистка вектора при повторном вводе

	system("cls<NUL");

	int how_m;
	std::cout << "Скольких студентов вы хотите ввести? ";
	std::cin >> how_m;
	Proverka(how_m);

	system("cls<NUL");

	auto rating = [&](int& i,Student& st) //  лямбда для вывода массива интов из студента
	{
		std::cout << "Вводите оценки студента по 1 числу за раз\n";
		for (int it = 0; it < st.rating.size(); it++)
		{
			
			std::cin >> st.rating[it];
			Proverka(st.rating[it]);
		}
	};

	for (int i = 0; i < how_m; i++) // ввод данных в структуру и запись структуры в массив
	{
		Student st;
		std::cout << "Введите имя студента №" << i + 1 << ": ";
		std::cin >> st.name;
		std::cout << "Введите на каком курсе студент №" << i + 1 << ": ";
		std::cin >> st.year;
		Proverka(st.year);
		rating(i,st);
		vect.push_back(st);
		system("cls<NUL");
	}
	
	std::sort(vect.begin(), vect.end()); // сортировка массива после ввода  с перегруженным <
}

void Print_Student(std::vector<Student> & vect) // вывод полного списка студентов
{
	system("cls<NUL");
	
	auto rating = [&](int& i) 
	{
		for (int it = 0; it < vect[i].rating.size(); it++)
		{
			std::cout<<vect[i].rating[it]<<" ";
			
		};
		std::cout<<std::endl;
	};

	std::cout << "Имя\tКурс\tОценки\n\n";

	for (int i = 0; i < vect.size(); i++)
	{
		std::cout << vect[i].name << "\t" << vect[i].year<<"\t";
		rating(i);
	}

	
	system("pause");
}

void Top_Rating_Student(std::vector<Student>& vect) // вывод студентов чей средний бал превышает общий средний бал
{
	system("cls<NUL");

	double mid_rating=0;

	for (int i = 0; i < vect.size(); i++)
	{
		mid_rating += (vect[i].rating[0] + vect[i].rating[1] + vect[i].rating[2] + vect[i].rating[3] + vect[i].rating[4]) / 5;
	}
	mid_rating /= vect.size(); // получение общего среднего бала


	auto rating = [&](int& i)
	{
		for (int it = 0; it < vect[i].rating.size(); it++)
		{
			std::cout << vect[i].rating[it] << " ";

		};
		std::cout << std::endl;
	};

	int none=0;// переменная счетчик для определения есть ли превышающий студент
	std::cout << "Имя\tКурс\tОценки\n\n";

	for (int i = 0; i < vect.size(); i++)
	{
		if ((vect[i].rating[0] + vect[i].rating[1] + vect[i].rating[2] + vect[i].rating[3] + vect[i].rating[4]) / 5 > mid_rating)
		{
			std::cout << vect[i].name << "\t" << vect[i].year << "\t";
			rating(i);

		}//вывод при условии привышения общего среднего бала
		else 
			none++;
		

		if (none == vect.size() )
		{
			std::cout << "Нету не одного студента привысившего средний бал"<<std::endl;
		}
	}

	system("pause");
}

bool operator <(Student& st1, Student& st2) // перегрузка для sort 
{
	return st1.name < st2.name;;
}

int main()
{
	setlocale(0, "");

	std::vector<Student> students;

	bool key=true;

	while (key)
	{
		system("cls<NUL");
		int x=0;
		

		std::cout << "\t\tВас приветствует программа учета студентов.\n" <<
			"1) Ввести студентов.\n" <<
			"2) Вывод всех студентов \n"<<
			"3) Вывод студентов с оценкой превышающий средний бал \n" <<
			"4) Выход\n\n";
		std::cin >> x;
		Proverka(x);

		switch (x)
		{
			case 1:
			{
				set_Student(students);
				break;
			}
			case 2:
			{
				Print_Student(students);
				break;
			}
			case 3:
			{
				Top_Rating_Student(students);
				break;
			}
			case 4:
			{
				key = false;
				break;
			}
			default:
			{
				std::cout << "Вы ввели неверный пункт меню.Повторите ввод." << std::endl;
				system("pause");
			}

		}

	}


	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

#include<iostream>

#include<array>

#include<vector>

#include<algorithm>

template <typename T>

T Proverka(T& x)

{

if (std::cin.fail())

{

std::cin.clear();

std::cin.ignore(32767, '\n');

std::cout << "Вы ввели недопустимое значение. Повторите ввод." << std::endl;

std::cin >> x;

return Proverka(x);

}

else

{

std::cin.ignore(32767, '\n');

return x;

}

struct Student

{

std::string name;

int year;

std::array<double, 5> rating;

};

void set_Student(std::vector<Student> &vect) // ввод данных для заполнения вектора студентами с данными

{

vect.erase(vect.begin(), vect.end()); // очистка вектора при повторном вводе

system("cls<NUL");

int how_m;

std::cout << "Скольких студентов вы хотите ввести? ";

std::cin >> how_m;

Proverka(how_m);

system("cls<NUL");

auto rating = [&](int& i,Student& st) // лямбда для вывода массива интов из студента

{

std::cout << "Вводите оценки студента по 1 числу за раз\n";

for (int it = 0; it < st.rating.size(); it++)

{

std::cin >> st.rating[it];

Proverka(st.rating[it]);

}

};

for (int i = 0; i < how_m; i++) // ввод данных в структуру и запись структуры в массив

{

Student st;

std::cout << "Введите имя студента №" << i + 1 << ": ";

std::cin >> st.name;

std::cout << "Введите на каком курсе студент №" << i + 1 << ": ";

std::cin >> st.year;

Proverka(st.year);

rating(i,st);

vect.push_back(st);

system("cls<NUL");

}

std::sort(vect.begin(), vect.end()); // сортировка массива после ввода с перегруженным <

}

void Print_Student(std::vector<Student> & vect) // вывод полного списка студентов

{

system("cls<NUL");

auto rating = [&](int& i)

{

for (int it = 0; it < vect[i].rating.size(); it++)

{

std::cout<<vect[i].rating[it]<<" ";

};

std::cout<<std::endl;

};

std::cout << "Имя\tКурс\tОценки\n\n";

for (int i = 0; i < vect.size(); i++)

{

std::cout << vect[i].name << "\t" << vect[i].year<<"\t";

rating(i);

}

system("pause");

}

void Top_Rating_Student(std::vector<Student>& vect) // вывод студентов чей средний бал превышает общий средний бал

{

system("cls<NUL");

double mid_rating=0;

for (int i = 0; i < vect.size(); i++)

{

mid_rating += (vect[i].rating[0] + vect[i].rating[1] + vect[i].rating[2] + vect[i].rating[3] + vect[i].rating[4]) / 5;

}

mid_rating /= vect.size(); // получение общего среднего бала

auto rating = [&](int& i)

{

for (int it = 0; it < vect[i].rating.size(); it++)

{

std::cout << vect[i].rating[it] << " ";

};

std::cout << std::endl;

};

int none=0;// переменная счетчик для определения есть ли превышающий студент

std::cout << "Имя\tКурс\tОценки\n\n";

for (int i = 0; i < vect.size(); i++)

{

if ((vect[i].rating[0] + vect[i].rating[1] + vect[i].rating[2] + vect[i].rating[3] + vect[i].rating[4]) / 5 > mid_rating)

{

std::cout << vect[i].name << "\t" << vect[i].year << "\t";

rating(i);

}//вывод при условии привышения общего среднего бала

else

none++;

if (none == vect.size() )

{

std::cout << "Нету не одного студента привысившего средний бал"<<std::endl;

}

system("pause");

}

bool operator <(Student& st1, Student& st2) // перегрузка для sort

{

return st1.name < st2.name;;

}

int main()

{

setlocale(0, "");

std::vector<Student> students;

bool key=true;

while (key)

{

system("cls<NUL");

int x=0;

std::cout << "\t\tВас приветствует программа учета студентов.\n" <<

"1) Ввести студентов.\n" <<

"2) Вывод всех студентов \n"<<

"3) Вывод студентов с оценкой превышающий средний бал \n" <<

"4) Выход\n\n";

std::cin >> x;

Proverka(x);

switch (x)

{

case 1:

{

set_Student(students);

break;

}

case 2:

{

Print_Student(students);

break;

}

case 3:

{

Top_Rating_Student(students);

break;

}

case 4:

{

key = false;

break;

}

default:

{

std::cout << "Вы ввели неверный пункт меню.Повторите ввод." << std::endl;

system("pause");

}

return 0;

}

Ответить

andrej:

14 сентября 2020 в 15:02

Задание №3 :

#include <iostream>
#include <string>
#include <array>
#include <algorithm>

using namespace std;
const short MAX_SIZE = 10;
struct Student
{
	string nahme;
	int year;
	array <int, 5> rating;
};
//=======================================================================
//ф-ия пользовательского ввода : принимает параметры желаемого диапазона ввода чисел (min , max)  и переменную,(x_usernumb)
//в которую записываем результат ввода по ссылке
//========================================================================
template <typename T>
void user_numb(T& x_usernumb, const int min, const int max)
{

    
    while (1)
    {

        std::cin >> x_usernumb;

        if (std::cin.fail()) 
        {
            std::cin.clear();
            std::cin.ignore(32767, '\n'); 
            cout << "Ne verno !! eshe raz : ";
            continue; 
        }

        std::cin.ignore(32767, '\n'); 
        if (std::cin.gcount() > 1) 
        {
            cout << "Tochnee !! Eshe raz :  ";
            continue; 
        }
        if (x_usernumb < min || x_usernumb > max) 
        {
            cout << "Vi vischli iz diapazona!! eshe raz  : ";
            continue;
        }
        break;
    }
}
//============================================================================
//функция ввода строки.работает со строкой переданной по ссылке
//в качестве параметра
//==============================================================================
void user_string(string& str)
{
    cout << "Vvedite familiju : ";
   
    while (1)
    {
       std:: getline(cin, str);
        bool rejected = false;
        for (int i = 0; i < str.length(); i++)
        {
            if (!isalpha(str[i]) )
            {
                rejected = true;
                cout << "Vvodite toljko bukvi! Escho raz :  ";
                break;
            }
        }
        if(!rejected)
        break;
    }
   
}
//===========================================================
//добавляем студента
//============================================================
void addStudent(array <Student,MAX_SIZE>& arr)
{
    bool rejected = false;
    for (Student& s : arr)
    {
        if (s.nahme == "")
        {
             user_string(s.nahme);
            std::cout << "Vvedite kurs   : ";
            user_numb(s.year, 1, 5);
            for (int i = 0; i < 5; i++)
            {
                std::cout << "Vvedite ocenku   : ";
                user_numb(s.rating[i], 1, 5);
            }
            rejected = false;
            break;
        }
        else
            rejected = true;
    }
    if (rejected)
        cout << "Svobodnix mest v spiske net  \n";
}
//=======================================================
//выводим весь отсортированный список
//=======================================================
void printStudent( array <Student, MAX_SIZE>& arr)
{
    sort(arr.begin(), arr.end(), [](const auto& a, const auto& b) {return (a.nahme < b.nahme); });
    for (Student& s : arr)
    {
        cout << s.nahme << '\n';
        cout << s.year << '\n';
        for (int i = 0; i < 5; ++i)
            cout << s.rating[i]<<" ";
        cout << '\n';
    }
 }
//============================================================
//средний бал одного студента
//============================================================
double student_Score( const Student& s)
{
    double st_score{ 0 };
    for (const auto& i:s.rating)
    
        st_score += i;
    return st_score / 5;
}
//=================================================================
//выводим общий средний балл
//============================================================
double general_Score(const array<Student, MAX_SIZE>& arr)
{
    double g_score{ 0 };
    for (const auto& s : arr)
        g_score += student_Score(s);
    return g_score / MAX_SIZE;
}
//======================================================================
//выводим лучших студентов
//======================================================================
void print_bestStudent(const array <Student, MAX_SIZE> arr)
{
    bool rejected = false;
    double g_score = general_Score(arr);
    for (const auto& s : arr)
    {
        if (g_score < student_Score(s))
        {
            cout << "Lucshij student : " << s.nahme << '\n';
            rejected = true;
        }
    }
    if (!rejected)
        cout << "Lucshih studentov net \n";
}
//==========================================================================
//удалить студента
//==========================================================================
void delete_Student(array <Student, MAX_SIZE>& arr)
{
    string str{};
    cout << "Vvedite familiju udaljaemogo studenta :  ";
    user_string(str);
    for (auto& s : arr)
    {
        if (s.nahme == str)
        {
            s.nahme = "";
            s.year = 0;
            for (int i = 0; i < 5; i++)
                s.rating[i] = 0;
        }
   }
  }

    
 
int main()
{
	array <Student, MAX_SIZE> stud;
    while (1)
    {
        cout << "Dlja dobavlenija studenta nazhmite '+' dlja udalenija nazhmite '-' "<<
            "dlja prosmotra rejtinga lucshih nazhmite '?' dlja prosmotra vsego spiska '='";
        char c;
        cin >> c;
        cin.ignore(32767,'\n');

        switch (c)
        {
        case '+': addStudent(stud); break;
        case '-': delete_Student(stud); break;
        case '=': printStudent(stud); break;
        case '?': print_bestStudent(stud); break;
        default:  cout << "Vi nazhali chto-to ne to.. eshe raz :  ";

        }
        
    }
   
    
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

#include <iostream>

#include <string>

#include <array>

#include <algorithm>

using namespace std;

const short MAX_SIZE = 10;

struct Student

{

string nahme;

int year;

array <int, 5> rating;

};

//=======================================================================

//ф-ия пользовательского ввода : принимает параметры желаемого диапазона ввода чисел (min , max) и переменную,(x_usernumb)

//в которую записываем результат ввода по ссылке

//========================================================================

template <typename T>

void user_numb(T& x_usernumb, const int min, const int max)

{

while (1)

{

std::cin >> x_usernumb;

if (std::cin.fail())

{

std::cin.clear();

std::cin.ignore(32767, '\n');

cout << "Ne verno !! eshe raz : ";

continue;

}

std::cin.ignore(32767, '\n');

if (std::cin.gcount() > 1)

{

cout << "Tochnee !! Eshe raz : ";

continue;

}

if (x_usernumb < min || x_usernumb > max)

{

cout << "Vi vischli iz diapazona!! eshe raz : ";

continue;

}

break;

}

//============================================================================

//функция ввода строки.работает со строкой переданной по ссылке

//в качестве параметра

//==============================================================================

void user_string(string& str)

{

cout << "Vvedite familiju : ";

while (1)

{

std:: getline(cin, str);

bool rejected = false;

for (int i = 0; i < str.length(); i++)

{

if (!isalpha(str[i]) )

{

rejected = true;

cout << "Vvodite toljko bukvi! Escho raz : ";

break;

}

if(!rejected)

break;

}

//===========================================================

//добавляем студента

//============================================================

void addStudent(array <Student,MAX_SIZE>& arr)

{

bool rejected = false;

for (Student& s : arr)

{

if (s.nahme == "")

{

user_string(s.nahme);

std::cout << "Vvedite kurs : ";

user_numb(s.year, 1, 5);

for (int i = 0; i < 5; i++)

{

std::cout << "Vvedite ocenku : ";

user_numb(s.rating[i], 1, 5);

}

rejected = false;

break;

}

else

rejected = true;

}

if (rejected)

cout << "Svobodnix mest v spiske net \n";

}

//=======================================================

//выводим весь отсортированный список

//=======================================================

void printStudent( array <Student, MAX_SIZE>& arr)

{

sort(arr.begin(), arr.end(), [](const auto& a, const auto& b) {return (a.nahme < b.nahme); });

for (Student& s : arr)

{

cout << s.nahme << '\n';

cout << s.year << '\n';

for (int i = 0; i < 5; ++i)

cout << s.rating[i]<<" ";

cout << '\n';

}

//============================================================

//средний бал одного студента

//============================================================

double student_Score( const Student& s)

{

double st_score{ 0 };

for (const auto& i:s.rating)

st_score += i;

return st_score / 5;

}

//=================================================================

//выводим общий средний балл

//============================================================

double general_Score(const array<Student, MAX_SIZE>& arr)

{

double g_score{ 0 };

for (const auto& s : arr)

g_score += student_Score(s);

return g_score / MAX_SIZE;

}

//======================================================================

//выводим лучших студентов

//======================================================================

void print_bestStudent(const array <Student, MAX_SIZE> arr)

{

bool rejected = false;

double g_score = general_Score(arr);

for (const auto& s : arr)

{

if (g_score < student_Score(s))

{

cout << "Lucshij student : " << s.nahme << '\n';

rejected = true;

}

if (!rejected)

cout << "Lucshih studentov net \n";

}

//==========================================================================

//удалить студента

//==========================================================================

void delete_Student(array <Student, MAX_SIZE>& arr)

{

string str{};

cout << "Vvedite familiju udaljaemogo studenta : ";

user_string(str);

for (auto& s : arr)

{

if (s.nahme == str)

{

s.nahme = "";

s.year = 0;

for (int i = 0; i < 5; i++)

s.rating[i] = 0;

}

int main()

{

array <Student, MAX_SIZE> stud;

while (1)

{

cout << "Dlja dobavlenija studenta nazhmite '+' dlja udalenija nazhmite '-' "<<

"dlja prosmotra rejtinga lucshih nazhmite '?' dlja prosmotra vsego spiska '='";

char c;

cin >> c;

cin.ignore(32767,'\n');

switch (c)

{

case '+': addStudent(stud); break;

case '-': delete_Student(stud); break;

case '=': printStudent(stud); break;

case '?': print_bestStudent(stud); break;

default: cout << "Vi nazhali chto-to ne to.. eshe raz : ";

}

Ответить

andrej:

10 сентября 2020 в 21:48

Задание №1

#include <iostream>
#include <vector>
#include <string>
#include <sstream>  // для превращения строки в число
#include <algorithm>

using std::vector; using std::cout; using std::cin; using std::string;
using std::stringstream;
//========================================================================================
//ф-ия принимает числа пользователя в строку(будут приняты только через пробел чтобы правильно 
//их расположить в массиве).в качестве аргумента принимает массив по ссылке и заполняет его числами..
//=========================================================================================
void string_to_numb(vector <double>& arr)
{
	stringstream strStream;
	double numb;
	string str{};
	cout << "Vvedite massiv drobnich chisel cherez probel v formate  #.# #.# ...   : ";
	while (1)
	{   
		arr.clear();
		strStream.clear();
		getline(cin, str);
		// Убеждаемся, что каждый символ является цифрой
		bool bValid = true;
		for (unsigned int nIndex = 0; nIndex < str.length(); nIndex++)
			if (!isdigit(str[nIndex]) && !isspace(str[nIndex]) && str[nIndex] != '.')
			{
				cout << "Ne verno !! Toljko drobnije chisla cherez '.' i probel ' ' : ";
				bValid = false;
				break;
			}
		if (!bValid)
			continue;

		strStream << str;
		while (!strStream.eof())
		{
			strStream >> numb;
			strStream.ignore(32767, ' ');
			if (strStream.gcount() > 1)
			{  //убеждаемся что числа введены через пробел!!
				cout << "Ne verno !!! Vvodite chisla cerez probel : ";
				bValid = false;
				break;
			}
			arr.push_back(numb);
		}
		if (!bValid)
			continue;
		
		break;
	}
}
//==================================================================================
//складываем введенные числа и делим на их кол-во
//=================================================================================
double averageGet(const vector<double>& arr)
{   
	double sum{ 0 };
	for (const auto& i : arr)
		sum += i;
	return (sum /= arr.size());
}

int main()
{
	double rezult{ 0 };
	vector <double> array;
	while (1)
	{
		string_to_numb(array);
		cout <<"Srednee arifmeticheskoe  : " << averageGet(array) << '\n';
		for_each(array.begin(), array.end(), [](const auto& a) {cout << a << '\n'; });
	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

#include <iostream>

#include <vector>

#include <string>

#include <sstream> // для превращения строки в число

#include <algorithm>

using std::vector; using std::cout; using std::cin; using std::string;

using std::stringstream;

//========================================================================================

//ф-ия принимает числа пользователя в строку(будут приняты только через пробел чтобы правильно

//их расположить в массиве).в качестве аргумента принимает массив по ссылке и заполняет его числами..

//=========================================================================================

void string_to_numb(vector <double>& arr)

{

stringstream strStream;

double numb;

string str{};

cout << "Vvedite massiv drobnich chisel cherez probel v formate #.# #.# ... : ";

while (1)

{

arr.clear();

strStream.clear();

getline(cin, str);

// Убеждаемся, что каждый символ является цифрой

bool bValid = true;

for (unsigned int nIndex = 0; nIndex < str.length(); nIndex++)

if (!isdigit(str[nIndex]) && !isspace(str[nIndex]) && str[nIndex] != '.')

{

cout << "Ne verno !! Toljko drobnije chisla cherez '.' i probel ' ' : ";

bValid = false;

break;

}

if (!bValid)

continue;

strStream << str;

while (!strStream.eof())

{

strStream >> numb;

strStream.ignore(32767, ' ');

if (strStream.gcount() > 1)

{ //убеждаемся что числа введены через пробел!!

cout << "Ne verno !!! Vvodite chisla cerez probel : ";

bValid = false;

break;

}

arr.push_back(numb);

}

if (!bValid)

continue;

break;

}

//==================================================================================

//складываем введенные числа и делим на их кол-во

//=================================================================================

double averageGet(const vector<double>& arr)

{

double sum{ 0 };

for (const auto& i : arr)

sum += i;

return (sum /= arr.size());

}

int main()

{

double rezult{ 0 };

vector <double> array;

while (1)

{

string_to_numb(array);

cout <<"Srednee arifmeticheskoe : " << averageGet(array) << '\n';

for_each(array.begin(), array.end(), [](const auto& a) {cout << a << '\n'; });

}

Ответить

Валера:

1 августа 2020 в 18:51

Задание номер 3.

#include <iostream>
#include <array>
#include <string>
#include <algorithm>

#define count 10

struct STUDENT
{
	std::string name;
	int year;
	std::array <int, 5> rating;
};

void readStudents(std::array<STUDENT, count>&students)
{
	for (int i = 0; i < students.size(); ++i)
	{
		std::cout << "student " << i+1 << "\n";
		std::cout << "name:";
		if (i != 0) std::cin.get();
		std::getline(std::cin, students[i].name);
		std::cout << "year:";
		std::cin >> students[i].year;

		std::cout << "rating:";
		std::cin >> students[i].rating[0] >> students[i].rating[1] >> students[i].rating[2] >> students[i].rating[3] >> students[i].rating[4];
		system("cls");
	}
}

auto compare = [](const STUDENT& s1, const STUDENT& s2)
{
	int i = 0;
	while (s1.name[i] == s2.name[i]) ++i;
	if (s1.name[i] < s2.name[i]) return true;
	return false;
};

double getStudentMiddleMark(const STUDENT& student)
{
	double middleMark = 0;
	for (const auto&el:student.rating)
	{
		middleMark += el;
	}
	return middleMark / 5;
}

double getMiddleMark(std::array<STUDENT,count>&students)
{
	double middleMark = 0;
	for (const auto& el : students)
	{
		middleMark += getStudentMiddleMark(el);
	}
	return middleMark / count;
}

void printBestStudents(std::array<STUDENT, count>& students)
{
	double totalMark = getMiddleMark(students);

	int i = 0;

	for (const auto& el : students)
	{
		if (getStudentMiddleMark(el) > totalMark)
		{
			std::cout << "name:" << el.name << "\n";
			++i;
		}
	}
	if (i == 0)
	{
		std::cout << "Not found";
	}
}

int main()
{
	std::array <STUDENT, count> students;

	readStudents(students);

	std::sort(students.begin(), students.end(),compare);

	printBestStudents(students);
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

#include <iostream>

#include <array>

#include <string>

#include <algorithm>

#define count 10

struct STUDENT

{

std::string name;

int year;

std::array <int, 5> rating;

};

void readStudents(std::array<STUDENT, count>&students)

{

for (int i = 0; i < students.size(); ++i)

{

std::cout << "student " << i+1 << "\n";

std::cout << "name:";

if (i != 0) std::cin.get();

std::getline(std::cin, students[i].name);

std::cout << "year:";

std::cin >> students[i].year;

std::cout << "rating:";

std::cin >> students[i].rating[0] >> students[i].rating[1] >> students[i].rating[2] >> students[i].rating[3] >> students[i].rating[4];

system("cls");

}

auto compare = [](const STUDENT& s1, const STUDENT& s2)

{

int i = 0;

while (s1.name[i] == s2.name[i]) ++i;

if (s1.name[i] < s2.name[i]) return true;

return false;

};

double getStudentMiddleMark(const STUDENT& student)

{

double middleMark = 0;

for (const auto&el:student.rating)

{

middleMark += el;

}

return middleMark / 5;

}

double getMiddleMark(std::array<STUDENT,count>&students)

{

double middleMark = 0;

for (const auto& el : students)

{

middleMark += getStudentMiddleMark(el);

}

return middleMark / count;

}

void printBestStudents(std::array<STUDENT, count>& students)

{

double totalMark = getMiddleMark(students);

int i = 0;

for (const auto& el : students)

{

if (getStudentMiddleMark(el) > totalMark)

{

std::cout << "name:" << el.name << "\n";

++i;

}

if (i == 0)

{

std::cout << "Not found";

}

int main()

{

std::array <STUDENT, count> students;

readStudents(students);

std::sort(students.begin(), students.end(),compare);

printBestStudents(students);

}

Ответить

Дмитрий:

17 февраля 2020 в 10:47

Задание номер 3.
Вроде, студенты со средним балом выше общего среднего бала будут существовать в любом случае.

Ответить

Алексей:

3 апреля 2020 в 21:51

Не обязательно, например: 5; 5; 5; 5.
среднее=5
Но при этом выше 5 оценок нет

Ответить

Анастасия:

13 января 2020 в 16:00

Моё решение задания №3 (всего 3 файла, 3 куска кода):

Файл Student_data.h:

#ifndef STUDENT_DATA
#define STUDENT_DATA

#include <iostream>
#include <string>
#include <array>

using std::string; using std::array;

// структура данных о студенте - ФИО, курс и успеваемость
struct Student
{
	// перечисление возможных оценок
	enum marks { one = 1, bad, satisfactorily, good, excellent };
	static const unsigned short number_of_marks_in_rating = 5;

	// делаем все данные публичными:
	string Name;
	unsigned Year;
	array<marks, number_of_marks_in_rating> Rating{marks::one, marks::one, marks::one, marks::one, marks::one};
	double Average_score;

	// конструктор по умолчанию нужен для создания "пустого" массива
	Student() : Name(), Year(0), Average_score(marks::one)
	{
	}
	// конструктор с параметрами
	Student(const string& name, const unsigned year, const array<marks, number_of_marks_in_rating>& rating):
		Name(name), Year(year), Rating(rating)
	{
		double summ{0};
		for (const auto& mark_from_rating : Rating)
			summ += mark_from_rating;
		Average_score = summ / number_of_marks_in_rating;
	}
	// перегрузка оператора вывода данных студента
	friend std::ostream& operator<<(std::ostream& out, const Student& student)
	{
		out << student.Name << " " << student.Year << " ";
		for (const auto& mark_from_rating : student.Rating)
			out << mark_from_rating << " ";
		out << '\n';
		return out;
	}
};

#endif

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

#ifndef STUDENT_DATA

#define STUDENT_DATA

#include <iostream>

#include <string>

#include <array>

using std::string; using std::array;

// структура данных о студенте - ФИО, курс и успеваемость

struct Student

{

// перечисление возможных оценок

enum marks { one = 1, bad, satisfactorily, good, excellent };

static const unsigned short number_of_marks_in_rating = 5;

// делаем все данные публичными:

string Name;

unsigned Year;

array<marks, number_of_marks_in_rating> Rating{marks::one, marks::one, marks::one, marks::one, marks::one};

double Average_score;

// конструктор по умолчанию нужен для создания "пустого" массива

Student() : Name(), Year(0), Average_score(marks::one)

{

}

// конструктор с параметрами

Student(const string& name, const unsigned year, const array<marks, number_of_marks_in_rating>& rating):

Name(name), Year(year), Rating(rating)

{

double summ{0};

for (const auto& mark_from_rating : Rating)

summ += mark_from_rating;

Average_score = summ / number_of_marks_in_rating;

}

// перегрузка оператора вывода данных студента

friend std::ostream& operator<<(std::ostream& out, const Student& student)

{

out << student.Name << " " << student.Year << " ";

for (const auto& mark_from_rating : student.Rating)

out << mark_from_rating << " ";

out << '\n';

return out;

}

};

#endif

Файл Students_array.h:

#ifndef STUDENTS_ARRAY
#define STUDENTS_ARRAY

#include <algorithm> // для использования алгоритмов сортировки
#include "Student_data.h"

using std::cout; using std::cin; using std::endl;

// класс-контейнер для обработки данных о студентах
class The_list_of_students
{
public:
	static const unsigned number_of_students = 10;
private:
	array<Student*, number_of_students> students; // массив указателей на данные о студентах
public:
	// конструктор по умолчанию
	The_list_of_students()
	{}

	// добавление данных о ещё одном студенте
	void add_student(const unsigned i,  Student* student)
	{
		students.at(i) = student;
	}

	// сортировка элементов вектора по имени
	void sort_by_name()
	{
		for (unsigned startIndex = 0; startIndex < (number_of_students - 1); ++startIndex)
		{
			int minimumIndex = startIndex;
			for (unsigned currentIndex = startIndex + 1; currentIndex < number_of_students; ++currentIndex)
			{
				if (students.at(currentIndex)->Name < students.at(minimumIndex)->Name)
					minimumIndex = currentIndex;
			}
			std::swap(students[startIndex], students[minimumIndex]);
		}
	}

	// печать студентов со средним баллом выше среднего
	void print_best_students()
	{
		cout << '\n';
		if (students.size() == 0) cout << "Список студентов пуст!" << '\n';
		else
		{
			double summ_of_average{ 0 };
			for (const auto student : students)
				summ_of_average += student->Average_score;
			double total_average_score = summ_of_average / number_of_students;
			bool best_students_exist{ false };
			for (const auto student : students)
				if (student->Average_score > total_average_score)
				{
					cout << *student;
					best_students_exist = true;
				}
			if (best_students_exist == false)
				cout << "Не найдено студентов со средним баллом, превышающим общий средний балл!\n";
		}
	}

	// деструктор
	~The_list_of_students()
	{
		for (auto student_ptr : students)
		delete student_ptr;
	}
};

#endif

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

#ifndef STUDENTS_ARRAY

#define STUDENTS_ARRAY

#include <algorithm> // для использования алгоритмов сортировки

#include "Student_data.h"

using std::cout; using std::cin; using std::endl;

// класс-контейнер для обработки данных о студентах

class The_list_of_students

{

public:

static const unsigned number_of_students = 10;

private:

array<Student*, number_of_students> students; // массив указателей на данные о студентах

public:

// конструктор по умолчанию

The_list_of_students()

{}

// добавление данных о ещё одном студенте

void add_student(const unsigned i, Student* student)

{

students.at(i) = student;

}

// сортировка элементов вектора по имени

void sort_by_name()

{

for (unsigned startIndex = 0; startIndex < (number_of_students - 1); ++startIndex)

{

int minimumIndex = startIndex;

for (unsigned currentIndex = startIndex + 1; currentIndex < number_of_students; ++currentIndex)

{

if (students.at(currentIndex)->Name < students.at(minimumIndex)->Name)

minimumIndex = currentIndex;

}

std::swap(students[startIndex], students[minimumIndex]);

}

// печать студентов со средним баллом выше среднего

void print_best_students()

{

cout << '\n';

if (students.size() == 0) cout << "Список студентов пуст!" << '\n';

else

{

double summ_of_average{ 0 };

for (const auto student : students)

summ_of_average += student->Average_score;

double total_average_score = summ_of_average / number_of_students;

bool best_students_exist{ false };

for (const auto student : students)

if (student->Average_score > total_average_score)

{

cout << *student;

best_students_exist = true;

}

if (best_students_exist == false)

cout << "Не найдено студентов со средним баллом, превышающим общий средний балл!\n";

}

// деструктор

~The_list_of_students()

{

for (auto student_ptr : students)

delete student_ptr;

}

};

#endif

Файл main.cpp:

#include "Students_array.h"
#include <sstream> // для работы со строковым потоком, чтобы превращать данные из строки в нужные данные разного типа

// функция возвращает истину, если строка соответствует ожидаемому формату "Ф И.О. год оценки рэйтинга" и ложь, если не соответствует
bool line_is_ok(const string& line_from_file)
{
	if (line_from_file.length() < 18) return false; //т.к. строка должна иметь вид "Ф И.О. курс ц1 ц1 ц3 ц4 ц5" - как минимум 18 символов
	unsigned short spaces_counter = 0; // счётчик пробелов
	unsigned short index = 0;          // индекс символов строки

	while ((index < line_from_file.size()) && (spaces_counter < 8))
		// 1ый пробел - окончание фамилии, 2ой- окончание имени, 3ий - года, потом через пробел идут пять оценок
	{
		if (isspace(line_from_file[index]))
			spaces_counter++;
		else
		{
			if ((spaces_counter == 0) && (!isalpha(line_from_file[index]))) return false;
			if ((spaces_counter == 1) && (!(isalpha(line_from_file[index]) || (line_from_file[index] == '.')))) return false;
			if ((spaces_counter >= 2) && (!isdigit(line_from_file[index]))) return false;
		}
		index++;
	}
	if (index < line_from_file.size()) return false; // если пробелов до конца строки было больше запланированного
	else return true;
}

// функция превращает строку в правильном формате в указатель на структуру данных о студенте
Student* convert_string_to_data(const string& correct_string)
{
	std::stringstream future_data;
	future_data << correct_string;

	string surname, second_part_of_name;
	future_data >> surname;
	surname += " ";
	future_data >> second_part_of_name;

	unsigned year{ 0 };
	future_data >> year;

	array<Student::marks, Student::number_of_marks_in_rating> rating;
	for (unsigned short i = 0; i < Student::number_of_marks_in_rating; i++)
	{
		unsigned short mark;
		future_data >> mark;
		rating[i] = static_cast<Student::marks>(mark);
	}

	return new Student(surname.append(second_part_of_name), year, rating);
}

// заполняем передаваемый массив данных о студентах данными из файла
void get_students_data(The_list_of_students& Students)
{
	unsigned short lines_index = 0; // счётчик строк
	cout << "Вводите данные о студентах в формате Surname Name курс оценка оценка оценка оценка оценка:\n";
	while (lines_index < The_list_of_students::number_of_students)  // нам нужно получить заданное количество правильных строк
	{
		string possible_data;
		cout << "Введите данные студента №" << lines_index + 1 << ": ";
		getline(cin, possible_data);
		if (line_is_ok(possible_data))
		{
			Student* student_ptr = convert_string_to_data(possible_data);
			Students.add_student(lines_index, student_ptr);
			lines_index++;
		}
		else cout << "Вы ввели строку в неправильном формате, придётся переписать ещё раз!" << '\n';
	}
}

int main()
{
	setlocale(LC_CTYPE, "rus");

	The_list_of_students Students;
	get_students_data(Students);
	Students.sort_by_name();
	cout << "\nУпорядоченные по алфавиту данные студентов, которые учатся лучше среднего:";
	Students.print_best_students();

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

#include "Students_array.h"

#include <sstream> // для работы со строковым потоком, чтобы превращать данные из строки в нужные данные разного типа

// функция возвращает истину, если строка соответствует ожидаемому формату "Ф И.О. год оценки рэйтинга" и ложь, если не соответствует

bool line_is_ok(const string& line_from_file)

{

if (line_from_file.length() < 18) return false; //т.к. строка должна иметь вид "Ф И.О. курс ц1 ц1 ц3 ц4 ц5" - как минимум 18 символов

unsigned short spaces_counter = 0; // счётчик пробелов

unsigned short index = 0; // индекс символов строки

while ((index < line_from_file.size()) && (spaces_counter < 8))

// 1ый пробел - окончание фамилии, 2ой- окончание имени, 3ий - года, потом через пробел идут пять оценок

{

if (isspace(line_from_file[index]))

spaces_counter++;

else

{

if ((spaces_counter == 0) && (!isalpha(line_from_file[index]))) return false;

if ((spaces_counter == 1) && (!(isalpha(line_from_file[index]) || (line_from_file[index] == '.')))) return false;

if ((spaces_counter >= 2) && (!isdigit(line_from_file[index]))) return false;

}

index++;

}

if (index < line_from_file.size()) return false; // если пробелов до конца строки было больше запланированного

else return true;

}

// функция превращает строку в правильном формате в указатель на структуру данных о студенте

Student* convert_string_to_data(const string& correct_string)

{

std::stringstream future_data;

future_data << correct_string;

string surname, second_part_of_name;

future_data >> surname;

surname += " ";

future_data >> second_part_of_name;

unsigned year{ 0 };

future_data >> year;

array<Student::marks, Student::number_of_marks_in_rating> rating;

for (unsigned short i = 0; i < Student::number_of_marks_in_rating; i++)

{

unsigned short mark;

future_data >> mark;

rating[i] = static_cast<Student::marks>(mark);

}

return new Student(surname.append(second_part_of_name), year, rating);

}

// заполняем передаваемый массив данных о студентах данными из файла

void get_students_data(The_list_of_students& Students)

{

unsigned short lines_index = 0; // счётчик строк

cout << "Вводите данные о студентах в формате Surname Name курс оценка оценка оценка оценка оценка:\n";

while (lines_index < The_list_of_students::number_of_students) // нам нужно получить заданное количество правильных строк

{

string possible_data;

cout << "Введите данные студента №" << lines_index + 1 << ": ";

getline(cin, possible_data);

if (line_is_ok(possible_data))

{

Student* student_ptr = convert_string_to_data(possible_data);

Students.add_student(lines_index, student_ptr);

lines_index++;

}

else cout << "Вы ввели строку в неправильном формате, придётся переписать ещё раз!" << '\n';

}

int main()

{

setlocale(LC_CTYPE, "rus");

The_list_of_students Students;

get_students_data(Students);

Students.sort_by_name();

cout << "\nУпорядоченные по алфавиту данные студентов, которые учатся лучше среднего:";

Students.print_best_students();

return 0;

}

Ответить

Анастасия:

11 января 2020 в 14:00

Моё решение задания №2:

#include <iostream>

using std::cout; using std::cin; using std::endl;

// получаем от пользователя шестизначное число
unsigned int get_6_digits_number()
{
	cout << "Вводите шестизначное число: ";
	int answer;
	cin >> answer;
	while (cin.fail() || (answer < 100000) || (answer > 999999))
	{
		cout << "Попробуйте ввести шестизначное число ещё раз: ";
		cin.clear();
		cin.ignore(1000, '\n');
		cin >> answer;
	}
	return static_cast<unsigned int>(answer);
}

// возвращает сумму цифр трёхзначного числа
unsigned short summ_of_3_digits(const unsigned int three_digits_number)
{
	unsigned int first_digit = three_digits_number / 100;
	unsigned int second_digit = (three_digits_number / 10) - (first_digit*10);
	unsigned int last_digit = three_digits_number % 10;
	return (first_digit + second_digit + last_digit);
}

// проверяем шестизначное число на счастливость (сумма первых трёх цифр равна сумме вторых трёх цифр)
bool is_happy(const unsigned int six_digits_number)
{
	return (summ_of_3_digits(six_digits_number / 1000) == summ_of_3_digits(six_digits_number % 1000))? true: false;
}

int main()
{
	setlocale(LC_CTYPE, "rus"); // подключаем кириллицу:

	cout << "Программа быстро проверяет введённое число на счастливость\n" << endl;

	while (true)
		if (is_happy(get_6_digits_number()))
			cout << "это счастливое число!" << endl;
		else 
			cout << "это обычное число" << endl;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

#include <iostream>

using std::cout; using std::cin; using std::endl;

// получаем от пользователя шестизначное число

unsigned int get_6_digits_number()

{

cout << "Вводите шестизначное число: ";

int answer;

cin >> answer;

while (cin.fail() || (answer < 100000) || (answer > 999999))

{

cout << "Попробуйте ввести шестизначное число ещё раз: ";

cin.clear();

cin.ignore(1000, '\n');

cin >> answer;

}

return static_cast<unsigned int>(answer);

}

// возвращает сумму цифр трёхзначного числа

unsigned short summ_of_3_digits(const unsigned int three_digits_number)

{

unsigned int first_digit = three_digits_number / 100;

unsigned int second_digit = (three_digits_number / 10) - (first_digit*10);

unsigned int last_digit = three_digits_number % 10;

return (first_digit + second_digit + last_digit);

}

// проверяем шестизначное число на счастливость (сумма первых трёх цифр равна сумме вторых трёх цифр)

bool is_happy(const unsigned int six_digits_number)

{

return (summ_of_3_digits(six_digits_number / 1000) == summ_of_3_digits(six_digits_number % 1000))? true: false;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // подключаем кириллицу:

cout << "Программа быстро проверяет введённое число на счастливость\n" << endl;

while (true)

if (is_happy(get_6_digits_number()))

cout << "это счастливое число!" << endl;

else

cout << "это обычное число" << endl;

}

Ответить

Анастасия:

11 января 2020 в 13:20

Моё решение задания №1:

#include <iostream>
#include <vector>
#include <string>
#include <sstream>  // для превращения строки в число

using std::cout; using std::cin; using std::endl;
using std::vector; using std::string;

// пытается превратить строку в число, выдаёт false, если не получилось
inline bool is_number(const string& str, double& number)
{
	std::istringstream istream(str);
	return (istream >> number) ? true : false;
}

// создаёт вектор дробных чисел из строки, введённой пользователем
vector<double> create_array_from_string(const string& users_input)
{
	vector<double> array{};
	string future_number{}; // будущее число в виде строки
	unsigned short points_in_number{ 0 }; // количество точек в будущем числе

	// будем собирать каждое число по символам-цифрам, каждый пробел добавляем число в массив и начинаем заново
	for (unsigned int i = 0; i < users_input.length(); i++)
	{
		// если после пробела знак минус или просто число или первая точка
		if (((future_number == "") && (users_input[i] == '-')) 
			  || (isdigit(users_input[i])) 
			  || ((users_input[i] == '.') && (points_in_number == 0)))
		{ 
			future_number.push_back(users_input[i]);
			if (users_input[i] == '.') 
				points_in_number++;
		}
		// если пробел или конец строки
		if ((users_input[i] == ' ') || (i == (users_input.length() - 1)))
		{
			double one_more_number{ 0 };
			if (is_number(future_number, one_more_number))
				array.push_back(one_more_number);
			future_number = "";
			points_in_number = 0;
		}
	}
	return array;
}

// получаем от пользователя последовательность чисел и, возможно, не только числа в виде строки
string get_users_input()
{
	cout << "Вводите последовательность  дробных чисел через пробел\n"
		 << "для разделения целой и дробной части используйте точку, прочие знаки и лишние точки будут проигнорированы\n"
		 << "для окончания ввода нажмите enter: ";
	string input;
	getline(cin, input);
	return input;
}

// вывод на экран среднего арифметического для последовательности
void print_average(const vector<double>& array)
{
	if (array.size() == 0)
		cout << "В последовательности нет чисел" << endl;
	else
	{
		double summ{ 0 };
		for (const auto& one_number : array)
			summ += one_number;
		cout << "Среднее арифметическое введённой последовательности: " << summ / array.size() << endl;
	}
}

int main()
{
	setlocale(LC_CTYPE, "rus"); // подключаем кириллицу:

	vector<double> array = create_array_from_string(get_users_input());
	print_average(array);

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

#include <iostream>

#include <vector>

#include <string>

#include <sstream> // для превращения строки в число

using std::cout; using std::cin; using std::endl;

using std::vector; using std::string;

// пытается превратить строку в число, выдаёт false, если не получилось

inline bool is_number(const string& str, double& number)

{

std::istringstream istream(str);

return (istream >> number) ? true : false;

}

// создаёт вектор дробных чисел из строки, введённой пользователем

vector<double> create_array_from_string(const string& users_input)

{

vector<double> array{};

string future_number{}; // будущее число в виде строки

unsigned short points_in_number{ 0 }; // количество точек в будущем числе

// будем собирать каждое число по символам-цифрам, каждый пробел добавляем число в массив и начинаем заново

for (unsigned int i = 0; i < users_input.length(); i++)

{

// если после пробела знак минус или просто число или первая точка

if (((future_number == "") && (users_input[i] == '-'))

|| (isdigit(users_input[i]))

|| ((users_input[i] == '.') && (points_in_number == 0)))

{

future_number.push_back(users_input[i]);

if (users_input[i] == '.')

points_in_number++;

}

// если пробел или конец строки

if ((users_input[i] == ' ') || (i == (users_input.length() - 1)))

{

double one_more_number{ 0 };

if (is_number(future_number, one_more_number))

array.push_back(one_more_number);

future_number = "";

points_in_number = 0;

}

return array;

}

// получаем от пользователя последовательность чисел и, возможно, не только числа в виде строки

string get_users_input()

{

cout << "Вводите последовательность дробных чисел через пробел\n"

<< "для разделения целой и дробной части используйте точку, прочие знаки и лишние точки будут проигнорированы\n"

<< "для окончания ввода нажмите enter: ";

string input;

getline(cin, input);

return input;

}

// вывод на экран среднего арифметического для последовательности

void print_average(const vector<double>& array)

{

if (array.size() == 0)

cout << "В последовательности нет чисел" << endl;

else

{

double summ{ 0 };

for (const auto& one_number : array)

summ += one_number;

cout << "Среднее арифметическое введённой последовательности: " << summ / array.size() << endl;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // подключаем кириллицу:

vector<double> array = create_array_from_string(get_users_input());

print_average(array);

return 0;

}

Ответить

Алена:

11 декабря 2019 в 13:15

Задача 2.

#include <iostream>

//числовая валидация пользовательского ввода для 6-значного числа
int getUserValue() 
{
	while (true)
	{
		int value;
		std::cin >> value;

		if (std::cin.fail()) //если извлечения не произошло
		{
			std::cin.clear(); //сбрасываем все флаги
			std::cin.ignore(32767, '\n'); //очищаем мусор из потока
			std::cout << "Ошибка! Некорректный ввод. Попробуйте еще раз.\n";
			continue; //начинаем сначала
		}

		std::cin.ignore(32767, '\n'); //очищаем мусор из потока, если такой остался после извлечения
		if (std::cin.gcount() > 1) //если очистили более 1 символа, т.е. был мусор
		{
			std::cout << "Ошибка! Некорректный ввод. Попробуйте еще раз.\n";
			continue; //начинаем сначала
		}

		if (value < 100'000 || value > 999'999) //индивидуальное требование к значению
		{
			std::cout << "Ошибка! Число должно быть шестизначное. Попробуйте еще раз.\n";
			continue; //начинаем сначала
		}

		return value; //успешный ввод
	}
}

//Функция возвращает true, если шестизначное число - «счастливое»
bool isLuckyTicket(int number)
{
	//сумма левых трех цифр
	int sumLeftHalf = number / 100'000 + (number % 100'000) / 10'000 + (number % 10'000) / 1'000;
	//сумма правых трех цифр
	int sumRightHalf = (number % 1'000) / 100 + (number % 100) / 10 + number % 10;
	
	if (sumLeftHalf == sumRightHalf)
		return true;
	else
		return false;
}

int main()
{
	setlocale(LC_ALL, "Rus");
	std::cout << "***Программа определяет, является ли шестизначное число «счастливым»***\n\n"
		<< "Введите шестизначное число: ";
	int userNumber = getUserValue();
	if (isLuckyTicket(userNumber))
		std::cout << "Ура! Поздравляем! " << userNumber << " - это счастливый билетик. Съешьте его! :)\n\n";
	else
		std::cout << "Не повезло... " << userNumber << " - это обычный билет, не счастливый :(\n\n";
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

#include <iostream>

//числовая валидация пользовательского ввода для 6-значного числа

int getUserValue()

{

while (true)

{

int value;

std::cin >> value;

if (std::cin.fail()) //если извлечения не произошло

{

std::cin.clear(); //сбрасываем все флаги

std::cin.ignore(32767, '\n'); //очищаем мусор из потока

std::cout << "Ошибка! Некорректный ввод. Попробуйте еще раз.\n";

continue; //начинаем сначала

}

std::cin.ignore(32767, '\n'); //очищаем мусор из потока, если такой остался после извлечения

if (std::cin.gcount() > 1) //если очистили более 1 символа, т.е. был мусор

{

std::cout << "Ошибка! Некорректный ввод. Попробуйте еще раз.\n";

continue; //начинаем сначала

}

if (value < 100'000 || value > 999'999) //индивидуальное требование к значению

{

std::cout << "Ошибка! Число должно быть шестизначное. Попробуйте еще раз.\n";

continue; //начинаем сначала

}

return value; //успешный ввод

}

//Функция возвращает true, если шестизначное число - «счастливое»

bool isLuckyTicket(int number)

{

//сумма левых трех цифр

int sumLeftHalf = number / 100'000 + (number % 100'000) / 10'000 + (number % 10'000) / 1'000;

//сумма правых трех цифр

int sumRightHalf = (number % 1'000) / 100 + (number % 100) / 10 + number % 10;

if (sumLeftHalf == sumRightHalf)

return true;

else

return false;

}

int main()

{

setlocale(LC_ALL, "Rus");

std::cout << "***Программа определяет, является ли шестизначное число «счастливым»***\n\n"

<< "Введите шестизначное число: ";

int userNumber = getUserValue();

if (isLuckyTicket(userNumber))

std::cout << "Ура! Поздравляем! " << userNumber << " - это счастливый билетик. Съешьте его! :)\n\n";

else

std::cout << "Не повезло... " << userNumber << " - это обычный билет, не счастливый :(\n\n";

}

Ответить

Алена:

6 декабря 2019 в 12:49

Задача 1.

#include <iostream>
#include <vector>

double getUserValue(std::vector<double>& someVector) //числовая валидация пользовательского ввода
{
	while (true)
	{
		double value;
		std::cin >> value;

		if (std::cin.fail()) //если извлечения не произошло
		{
			std::cin.clear(); //сбрасываем все флаги
			std::cin.ignore(32767, '\n'); //очищаем мусор из потока
			std::cout << "Ошибка! Некорректный ввод. Попробуйте ЗАНОВО.\n" 
				<< "Введите последовательность дробных чисел : ";
			someVector.clear(); //очистка вектора
			continue; //начинаем сначала
		}

		if (value < 0) //индивидуальное требование к значению
		{
			std::cout << "Ошибка! Отрицательное число. Попробуйте ЗАНОВО.\n"
				<< "Введите последовательность дробных чисел : ";
			someVector.clear(); //очистка вектора
			continue; //начинаем сначала
		}

		return value; //успешный ввод
	}
}

int main() 
{
	setlocale(LC_ALL, "Rus");
	std::cout << "***Программа вычисляет среднее арифметическое вводимой пользователем***\n"
		<< "***с клавиатуры последовательности дробных чисел***\n\n";
	std::cout << "Введите последовательность дробных чисел : ";
	std::vector<double> myVector; //Вектор, чтобы иметь возможность его очистить при некорректном вводе
	double sum = 0;
	while (std::cin.peek() != '\n') //считываем значения до знака новой строки
	{
		double temp = getUserValue(myVector);
		myVector.push_back(temp);
	}
	for (const auto &temp: myVector) //считаем отдельно, не в while, на случай, если вектор будет очищен
		sum += temp;
	std::cout << "Среднее арифметическое введенной последовательности : " << std::showpoint << sum / myVector.size();
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

#include <iostream>

#include <vector>

double getUserValue(std::vector<double>& someVector) //числовая валидация пользовательского ввода

{

while (true)

{

double value;

std::cin >> value;

if (std::cin.fail()) //если извлечения не произошло

{

std::cin.clear(); //сбрасываем все флаги

std::cin.ignore(32767, '\n'); //очищаем мусор из потока

std::cout << "Ошибка! Некорректный ввод. Попробуйте ЗАНОВО.\n"

<< "Введите последовательность дробных чисел : ";

someVector.clear(); //очистка вектора

continue; //начинаем сначала

}

if (value < 0) //индивидуальное требование к значению

{

std::cout << "Ошибка! Отрицательное число. Попробуйте ЗАНОВО.\n"

<< "Введите последовательность дробных чисел : ";

someVector.clear(); //очистка вектора

continue; //начинаем сначала

}

return value; //успешный ввод

}

int main()

{

setlocale(LC_ALL, "Rus");

std::cout << "***Программа вычисляет среднее арифметическое вводимой пользователем***\n"

<< "***с клавиатуры последовательности дробных чисел***\n\n";

std::cout << "Введите последовательность дробных чисел : ";

std::vector<double> myVector; //Вектор, чтобы иметь возможность его очистить при некорректном вводе

double sum = 0;

while (std::cin.peek() != '\n') //считываем значения до знака новой строки

{

double temp = getUserValue(myVector);

myVector.push_back(temp);

}

for (const auto &temp: myVector) //считаем отдельно, не в while, на случай, если вектор будет очищен

sum += temp;

std::cout << "Среднее арифметическое введенной последовательности : " << std::showpoint << sum / myVector.size();

}

Ответить

Shom:

25 ноября 2019 в 15:55

Задание №3

Файл Student.h

#include <iostream>
#include <wchar.h>                       // Для работы с кириллицей;
#include <iomanip>                       // Для форматирования вывода на экран; 

static const int sizeArrRaiting{5};      // Размер массива с оценками студента;
struct STUDENT                           // Структура с данными студента;
{
    std::wstring              Name;      // Имя студента; 
    int                       Year;      // Курс студента;
    int    Raiting[sizeArrRaiting];      // Массив с оценками;
};

class Student 
{
private:
    STUDENT     m_student;              // Создание объекта структуры;
    static const int  m_size{10};       // Размер массива структур с данными студентов;
    STUDENT m_array[m_size];            // Массив структур с данными студентов;
    double studentsGPA{0};              // Общий средний балл; 
    double arrStudentGPA[m_size];       // Массив со средними баллами студентов; 
    int validationInput();              // Метод валидации ввода;
    void newStudent();                  // Метод для ввода данных студентов;
    void alphabeticalSort();            // Метод сортировки студентов в алфавитном порядке;
    void calculationGPA();              // Метод, вычисляющий средний балл студента и общий;
    void print();                       // Метод вывода на экран;
    
public:
    Student();
};

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

#include <iostream>

#include <wchar.h> // Для работы с кириллицей;

#include <iomanip> // Для форматирования вывода на экран;

static const int sizeArrRaiting{5}; // Размер массива с оценками студента;

struct STUDENT // Структура с данными студента;

{

std::wstring Name; // Имя студента;

int Year; // Курс студента;

int Raiting[sizeArrRaiting]; // Массив с оценками;

};

class Student

{

private:

STUDENT m_student; // Создание объекта структуры;

static const int m_size{10}; // Размер массива структур с данными студентов;

STUDENT m_array[m_size]; // Массив структур с данными студентов;

double studentsGPA{0}; // Общий средний балл;

double arrStudentGPA[m_size]; // Массив со средними баллами студентов;

int validationInput(); // Метод валидации ввода;

void newStudent(); // Метод для ввода данных студентов;

void alphabeticalSort(); // Метод сортировки студентов в алфавитном порядке;

void calculationGPA(); // Метод, вычисляющий средний балл студента и общий;

void print(); // Метод вывода на экран;

public:

Student();

};

Файл Student.cpp

#include "Student.h"

Student::Student()
{
    newStudent();    
    alphabeticalSort();    
    calculationGPA();    
    print();
}

int Student::validationInput()      // Функция валидации ввода данных;
{
    int val;
    while (true)
    {
        std::wcin >> val;
        if (std::wcin.fail())
        {
            std::wcin.clear();
            std::wcin.ignore(32767, '\n');
            std::wcout << L"Ошибка ввода! Попробуйте ещё раз: ";
            continue;
        }
        std::wcin.ignore(32767, '\n');
        return val;
    }
}

void Student::newStudent()                             // Ввод данных студентов;
{
    for (int iii{0}; iii<m_size; ++iii)
    {
        std::wcout << L"Студент №" << iii+1 << L": \n";
        std::wcout << L"Введите фамилию и инициалы студента: ";
        std::getline(std::wcin, m_array[iii].Name);
        std::wcout << L"Введите курс студента: ";
        m_array[iii].Year = validationInput();
        for (int jjj{0}; jjj<sizeArrRaiting; ++jjj )
        {
            std::wcout << L"Введите оценку студента по предмету №" << jjj+1 << L": ";
            m_array[iii].Raiting[jjj] = validationInput();
        }
        std::wcout << L"\n";        
    }
    std::wcout << L"Ввод успешно завершён.\n\n";    
}

void Student::alphabeticalSort()                          // Сортировка студентов по алфавиту;
{
    for (int iii = 0; iii < m_size - 1; iii++)         
        for (int jjj = 0; jjj < m_size - iii - 1; jjj++) 
            if (m_array[jjj+1].Name < m_array[jjj].Name)
                 std::swap(m_array[jjj], m_array[jjj+1]);
}

void Student::calculationGPA()                            // Вычисление средних баллов;
{
    int sumAll{0};
    for (int iii{0}; iii<m_size; ++iii)
    {        
        int sum{0};
        for (int jjj{0}; jjj<sizeArrRaiting; ++jjj )
             sum += m_array[iii].Raiting[jjj];
                            
        arrStudentGPA[iii] = 
            static_cast<double>(sum) / static_cast<double>(sizeArrRaiting); 
        sumAll += sum;    
    }
    studentsGPA = 
        static_cast<double>(sumAll) / static_cast<double>(sizeArrRaiting * m_size);    
}

void Student::print()                                       // Вывод на экран;
{
    std::wcout << L"Общий средний балл студентов равен " << 
                  studentsGPA << L"\n\n";                  
                  
    bool key{true};
    for (int iii{0}; iii<m_size; ++iii)
    {
        if (arrStudentGPA[iii] > studentsGPA)
        {
            if (key) std::wcout << L"  ФИО студента  " << L"Курс " << 
                                   L"Средний балл\n";
            key = false;                       
            
            std::wcout << std::setw(16) << std::left  << m_array[iii].Name;
            std::wcout << std::setw(4)  << std::right << m_array[iii].Year;
            std::wcout << std::setw(12) << std::right << arrStudentGPA[iii] << 
                          L"\n";            
        }       
    }
    if (key) std::wcout << L"Нет студентов со средним баллом выше общего\n"; 
    std::wcout << L"\n";   
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

#include "Student.h"

Student::Student()

{

newStudent();

alphabeticalSort();

calculationGPA();

print();

}

int Student::validationInput() // Функция валидации ввода данных;

{

int val;

while (true)

{

std::wcin >> val;

if (std::wcin.fail())

{

std::wcin.clear();

std::wcin.ignore(32767, '\n');

std::wcout << L"Ошибка ввода! Попробуйте ещё раз: ";

continue;

}

std::wcin.ignore(32767, '\n');

return val;

}

void Student::newStudent() // Ввод данных студентов;

{

for (int iii{0}; iii<m_size; ++iii)

{

std::wcout << L"Студент №" << iii+1 << L": \n";

std::wcout << L"Введите фамилию и инициалы студента: ";

std::getline(std::wcin, m_array[iii].Name);

std::wcout << L"Введите курс студента: ";

m_array[iii].Year = validationInput();

for (int jjj{0}; jjj<sizeArrRaiting; ++jjj )

{

std::wcout << L"Введите оценку студента по предмету №" << jjj+1 << L": ";

m_array[iii].Raiting[jjj] = validationInput();

}

std::wcout << L"\n";

}

std::wcout << L"Ввод успешно завершён.\n\n";

}

void Student::alphabeticalSort() // Сортировка студентов по алфавиту;

{

for (int iii = 0; iii < m_size - 1; iii++)

for (int jjj = 0; jjj < m_size - iii - 1; jjj++)

if (m_array[jjj+1].Name < m_array[jjj].Name)

std::swap(m_array[jjj], m_array[jjj+1]);

}

void Student::calculationGPA() // Вычисление средних баллов;

{

int sumAll{0};

for (int iii{0}; iii<m_size; ++iii)

{

int sum{0};

for (int jjj{0}; jjj<sizeArrRaiting; ++jjj )

sum += m_array[iii].Raiting[jjj];

arrStudentGPA[iii] =

static_cast<double>(sum) / static_cast<double>(sizeArrRaiting);

sumAll += sum;

}

studentsGPA =

static_cast<double>(sumAll) / static_cast<double>(sizeArrRaiting * m_size);

}

void Student::print() // Вывод на экран;

{

std::wcout << L"Общий средний балл студентов равен " <<

studentsGPA << L"\n\n";

bool key{true};

for (int iii{0}; iii<m_size; ++iii)

{

if (arrStudentGPA[iii] > studentsGPA)

{

if (key) std::wcout << L" ФИО студента " << L"Курс " <<

L"Средний балл\n";

key = false;

std::wcout << std::setw(16) << std::left << m_array[iii].Name;

std::wcout << std::setw(4) << std::right << m_array[iii].Year;

std::wcout << std::setw(12) << std::right << arrStudentGPA[iii] <<

L"\n";

}

if (key) std::wcout << L"Нет студентов со средним баллом выше общего\n";

std::wcout << L"\n";

}

Файл main.cpp

#include "Student.h"
 
int main()
{       
    setlocale(LC_ALL, "");      // Подключение локали;
    
    Student s;                  // Создание объекта класса;
    
    return 0;
}

1

2

3

4

5

6

7

8

9

10

#include "Student.h"

int main()

{

setlocale(LC_ALL, ""); // Подключение локали;

Student s; // Создание объекта класса;

return 0;

}

Ответить

Shom:

18 ноября 2019 в 13:41

Задание №2.

#include <iostream>
 
int validationInput()      // Функция валидации ввода данных;
{
    int val;
    while (true)
    {
        std::cin >> val;
        if (std::cin.fail() || val<100000 || val>999999 )
        {
            std::cin.clear();
            std::cin.ignore(32767, '\n');
            std::cout << "Ошибка ввода! Попробуйте ещё раз: ";
            continue;
        }
        std::cin.ignore(32767, '\n');
        return val;
    }
}
 
int main()
{       
    std::cout << "Введите пшестизначное число: ";
    int num{validationInput()};
    int sum1 = num/100000 + (num%100000)/10000 + (num%10000)/1000;         // сумма первых трёх цифр числа;
    int sum2 = (num%1000)/100 + (num%100)/10 + num%10;                     // Сумма последних трёх цифр;     
    
    if (sum1 == sum2) std::cout << "Число " << num << " счастливое.\n";
    else std::cout << "Число " << num << " не является счастливым.\n";
    
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

#include <iostream>

int validationInput() // Функция валидации ввода данных;

{

int val;

while (true)

{

std::cin >> val;

if (std::cin.fail() || val<100000 || val>999999 )

{

std::cin.clear();

std::cin.ignore(32767, '\n');

std::cout << "Ошибка ввода! Попробуйте ещё раз: ";

continue;

}

std::cin.ignore(32767, '\n');

return val;

}

int main()

{

std::cout << "Введите пшестизначное число: ";

int num{validationInput()};

int sum1 = num/100000 + (num%100000)/10000 + (num%10000)/1000; // сумма первых трёх цифр числа;

int sum2 = (num%1000)/100 + (num%100)/10 + num%10; // Сумма последних трёх цифр;

if (sum1 == sum2) std::cout << "Число " << num << " счастливое.\n";

else std::cout << "Число " << num << " не является счастливым.\n";

return 0;

}

Ответить

Shom:

15 ноября 2019 в 19:22

Задание №1.

#include <iostream>
#include <vector>
 
double validationInput(auto& arr)      // Функция валидации ввода данных;
{
    double val;
    while (true)
    {
        std::cin >> val;
        if (std::cin.fail())
        {
            std::cin.clear();
            std::cin.ignore(32767, '\n');
            std::cout << "Ошибка ввода! Попробуйте ещё раз: ";
            arr.clear();                                        // очищаем вектор;
            continue;
        }        
        return val;
    }
}
 
int main()
{       
    std::cout << "Введите последовательность дробных чисел: ";       
    std::vector<double> vec;    
    double temp{validationInput(vec)};        
    while (std::cin.peek() != '\n')                            // цикл будет длиться пока буфер 
    {                                                          //     данных не опустеет;
        if (!vec.size()) vec.push_back(temp);                  // для добавления первого значения в вектор;
        temp = validationInput(vec);
        vec.push_back(temp);
    }
        
    temp = 0;                                                                        
    for (auto num : vec)  temp += num;                        // подсчитываем сумму значений вектора;
    
    std::cout << "Среднее арифметическое введенной последовательности: " <<
                  temp/vec.size() << "\n";
    
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

#include <iostream>

#include <vector>

double validationInput(auto& arr) // Функция валидации ввода данных;

{

double val;

while (true)

{

std::cin >> val;

if (std::cin.fail())

{

std::cin.clear();

std::cin.ignore(32767, '\n');

std::cout << "Ошибка ввода! Попробуйте ещё раз: ";

arr.clear(); // очищаем вектор;

continue;

}

return val;

}

int main()

{

std::cout << "Введите последовательность дробных чисел: ";

std::vector<double> vec;

double temp{validationInput(vec)};

while (std::cin.peek() != '\n') // цикл будет длиться пока буфер

{ // данных не опустеет;

if (!vec.size()) vec.push_back(temp); // для добавления первого значения в вектор;

temp = validationInput(vec);

vec.push_back(temp);

}

temp = 0;

for (auto num : vec) temp += num; // подсчитываем сумму значений вектора;

std::cout << "Среднее арифметическое введенной последовательности: " <<

temp/vec.size() << "\n";

return 0;

}

Ответить

Владимир:

9 ноября 2019 в 16:00

Задание №2

#include <iostream>
#include <cmath>
#include <Windows.h> 

bool check(int& num) // проверяем корректность ввода
{
	std::cin >> num;
	std::cin.ignore(32767, '\n'); // удаляем значения из входного буфера

	if (std::cin.fail() || num < 100000 || num > 999999) { // если извлечение неудачное
		std::cin.clear(); // возвращаем cin в 'обычный' режим 
		std::cout << "Значение некорректно. Повторите ввод!\n";
	}
	else return false;
}

void luckyNumber() // проверка на "счастье"
{
	int num; // шестизначное число
	while (check(num)); // проверка числа
	int a(0), b(0); // переменные для 10^i степени
	int sum1(0), sum2(0); // суммы первой и второй тройки цифр

	for (int i(0); i < 6; ++i) {
		a = pow(10, i);
		b = pow(10, 1 + i);

		if (i < 3)	sum1 += (num % b - num % a) / a;
		else		sum2 += (num % b - num % a) / a;
	}
	std::cout << "сумма первых трёх цифр : " << sum1 << ", сумма последних трёх цифр : " << sum2 << "\n";

	if (sum1 == sum2)
		std::cout << "число " << num << " является \"счастливым\"\n";
	else
		std::cout << "число " << num << " не является \"счастливым\"\n";
}

bool makeChoice(char& choice) // предлагаем повторить упражнение
{
	std::cout << "хотите продолжить? да/нет - y/n : ";
	std::cin >> choice;
	std::cin.ignore(32767, '\n'); // удаляем значения из входного буфера
	std::cout << "\n";
	return (choice == 'y') ? true : false;
}

int main()
{
	SetConsoleCP(1251); SetConsoleOutputCP(1251);
	char choice; // символ определяющий выбор действия

	do {
		std::cout << "Введите шестизначное число : ";
		luckyNumber(); // проверка числа на счастливость
	} while (makeChoice(choice)); // выбираем действие да/нет на продолжение

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

#include <iostream>

#include <cmath>

#include <Windows.h>

bool check(int& num) // проверяем корректность ввода

{

std::cin >> num;

std::cin.ignore(32767, '\n'); // удаляем значения из входного буфера

if (std::cin.fail() || num < 100000 || num > 999999) { // если извлечение неудачное

std::cin.clear(); // возвращаем cin в 'обычный' режим

std::cout << "Значение некорректно. Повторите ввод!\n";

}

else return false;

}

void luckyNumber() // проверка на "счастье"

{

int num; // шестизначное число

while (check(num)); // проверка числа

int a(0), b(0); // переменные для 10^i степени

int sum1(0), sum2(0); // суммы первой и второй тройки цифр

for (int i(0); i < 6; ++i) {

a = pow(10, i);

b = pow(10, 1 + i);

if (i < 3) sum1 += (num % b - num % a) / a;

else sum2 += (num % b - num % a) / a;

}

std::cout << "сумма первых трёх цифр : " << sum1 << ", сумма последних трёх цифр : " << sum2 << "\n";

if (sum1 == sum2)

std::cout << "число " << num << " является \"счастливым\"\n";

else

std::cout << "число " << num << " не является \"счастливым\"\n";

}

bool makeChoice(char& choice) // предлагаем повторить упражнение

{

std::cout << "хотите продолжить? да/нет - y/n : ";

std::cin >> choice;

std::cin.ignore(32767, '\n'); // удаляем значения из входного буфера

std::cout << "\n";

return (choice == 'y') ? true : false;

}

int main()

{

SetConsoleCP(1251); SetConsoleOutputCP(1251);

char choice; // символ определяющий выбор действия

do {

std::cout << "Введите шестизначное число : ";

luckyNumber(); // проверка числа на счастливость

} while (makeChoice(choice)); // выбираем действие да/нет на продолжение

return 0;

}

Ответить

Владимир:

9 ноября 2019 в 15:58

Задание №1

#include <iostream>
#include <vector>
#include <string>
#include <Windows.h> 

bool check(std::string& str, double& dbl, std::vector<std::string>& v_str, char* ch)
{
	if (!(dbl = strtod(str.c_str(), &ch))) { // если при конвертир. произошла ошибка
		if (str != "0" && str != "-0") // исключаем из этого процесса эти символы (тоже дают ошибки)
			v_str.push_back(str); // все str-ошибки записываем в вектор (кроме 0 и -0)
		str.clear(); // очищаем str для следующего числа
	}
	else return false;
}

void arithmetic()
{
	std::vector<std::string> v_str; // вектор чисел-ошибок
	std::vector<double> v_dbl; // вектор чисел по проверке
	std::string str; // следующее число в виде стринг
	double dbl; // очередное число в виде дабл
	int count(0); // счетчик чисел, т.к. на длину массива чисел при ошибках не стоит полагаться
	char* ch{}; // для функции strtod() в функции check()

	while (std::cin.peek() != '\n') { // пока не конец строки продолжаем цикл
		if (std::cin.peek() == ' ') { // если за последним числом затесался пробел, то
			std::cin.get(); // считываем его и отбрасываем
			continue; // пропускаем эту итерацию
		}
		std::cin >> str; // считываем строку (число) до пробела
		++count; // считаем количество чисел

		if (check(str, dbl, v_str, ch)); // проверка наличия чисел с ошибками
		else v_dbl.push_back(dbl); // если нет ошибки, числ�

Часть №10: Практические задания по С++

Easy: Задание №1

Medium: Задание №2

Hard: Задание №3

Комментариев: 25