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

Finchi:

5 сентября 2022 в 10:19

Задание №1

#include <iostream>
#include <vector>
#include <string>
#include <Windows.h>
int main()
{
	setlocale(LC_ALL, "russian");
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);
	std::cout << "Введите строку: ";
	std::string input, word;
	std::getline(std::cin, input);
	std::vector <std::string> words;
	for (int i = 0; i < input.length(); i++)
	{
		if (input.at(i) != ' ' && input.at(i)!='!' && input.at(i) != '.' && input.at(i) != '?' && input.at(i) != ',')
			word += input.at(i);
		else
		{
			words.push_back(word);
			word.clear();
			word += input.at(i);
			words.push_back(word);
			word.clear();
		}
	}
	words.push_back(word);
	for (int i = words.size()-1; i >= 0; i--)
		std::cout << words.at(i);
	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 <vector>

#include <string>

#include <Windows.h>

int main()

{

setlocale(LC_ALL, "russian");

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

std::cout << "Введите строку: ";

std::string input, word;

std::getline(std::cin, input);

std::vector <std::string> words;

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

{

if (input.at(i) != ' ' && input.at(i)!='!' && input.at(i) != '.' && input.at(i) != '?' && input.at(i) != ',')

word += input.at(i);

else

{

words.push_back(word);

word.clear();

word += input.at(i);

words.push_back(word);

word.clear();

}

words.push_back(word);

for (int i = words.size()-1; i >= 0; i--)

std::cout << words.at(i);

return 0;

}

Задание №2

#include <iostream>
#include <vector>
#include <array>
#include <random>
#include <algorithm>
int main()
{
	setlocale(LC_ALL, "russian");
	std::mt19937 mercene_vortex(std::random_device{}());
	std::array<int, 50> first, second;
	std::vector<int> third;
	for (int i = 0; i < first.size(); i++)
	{
		first.at(i) = mercene_vortex() % 100;
		second.at(i) = mercene_vortex() % 100;
	}
	for (int i = 0; i < first.size(); i++)
	{
		auto iter1 = std::find(second.begin(), second.end(), first.at(i));
		if (iter1 != second.end())
		{
			auto iter2 = std::find(third.begin(), third.end(), *iter1);
			if (iter2 == third.end())
				third.push_back(*iter1);
		}
	}
	std::cout << "first:\n";
	for (auto i : first)
		std::cout << i << " ";
	std::cout << "\n";
	std::cout << "second:\n";
	for (auto i : second)
		std::cout << i << " ";
	std::cout << "\n";
	std::cout << "third:\n";
	for (auto i : third)
		std::cout << i << " ";
	std::cout << "\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

#include <iostream>

#include <vector>

#include <array>

#include <random>

#include <algorithm>

int main()

{

setlocale(LC_ALL, "russian");

std::mt19937 mercene_vortex(std::random_device{}());

std::array<int, 50> first, second;

std::vector<int> third;

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

{

first.at(i) = mercene_vortex() % 100;

second.at(i) = mercene_vortex() % 100;

}

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

{

auto iter1 = std::find(second.begin(), second.end(), first.at(i));

if (iter1 != second.end())

{

auto iter2 = std::find(third.begin(), third.end(), *iter1);

if (iter2 == third.end())

third.push_back(*iter1);

}

std::cout << "first:\n";

for (auto i : first)

std::cout << i << " ";

std::cout << "\n";

std::cout << "second:\n";

for (auto i : second)

std::cout << i << " ";

std::cout << "\n";

std::cout << "third:\n";

for (auto i : third)

std::cout << i << " ";

std::cout << "\n";

return 0;

}

Задание №3

#include <iostream>
int main()
{
	setlocale(LC_ALL, "russian");
	std::cout << "Загадайте число от 0 до 100, компьютер попробует угадать его!\n";
	char choise{};
	int counter = 0, number = 50, begin = 0, end = 100;
	do
	{
		counter++;
		std::cout << "Попытка №" << counter << ": " << number << '\n';
		std::cout << "Если компьютер угадал число, нажмите \"y\"\n";
		std::cout << "Если ваше число больше, то нажмите \">\"\n";
		std::cout << "Если ваше число меньше, то нажмите \"<\"\n";
		do
		{
			std::cout << "Ваш выбор: ";
			std::cin >> choise;
			std::cin.clear();
			std::cin.ignore(32767, '\n');
		} while (choise != 'y' && choise != '<' && choise != '>');
		if (choise == '<')
		{
			end = number;
			number = (begin + number) / 2;
		}
		if (choise == '>')
		{
			begin = number;
			number = (end + number) / 2;
		}
	} while (choise != 'y');
	std::cout << "Компьютер угадал число: " << number;
	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

#include <iostream>

int main()

{

setlocale(LC_ALL, "russian");

std::cout << "Загадайте число от 0 до 100, компьютер попробует угадать его!\n";

char choise{};

int counter = 0, number = 50, begin = 0, end = 100;

do

{

counter++;

std::cout << "Попытка №" << counter << ": " << number << '\n';

std::cout << "Если компьютер угадал число, нажмите \"y\"\n";

std::cout << "Если ваше число больше, то нажмите \">\"\n";

std::cout << "Если ваше число меньше, то нажмите \"<\"\n";

do

{

std::cout << "Ваш выбор: ";

std::cin >> choise;

std::cin.clear();

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

} while (choise != 'y' && choise != '<' && choise != '>');

if (choise == '<')

{

end = number;

number = (begin + number) / 2;

}

if (choise == '>')

{

begin = number;

number = (end + number) / 2;

}

} while (choise != 'y');

std::cout << "Компьютер угадал число: " << number;

return 0;

}

Ответить

WAR:

10 сентября 2021 в 22:06

Задание №2:

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <ctime>

void print(std::vector<int> &v, int num) {
    std::cout << "\nArray #" << num << " is: ";
    for(auto &i : v) std::cout << i << ' ';
}

void fillArr(std::vector<int> &v) {
    for(int i{0}; i < v.size(); ++i) v[i] = rand()%10;
}

int input(int num) {
    int size{0};
    while(size < 1) {
        std::cout << "Enter size array #" << num << ": ";
        std::cin >> size;
        if(std::cin.fail()) {
		    std::cin.clear();
		    std::cin.ignore(32767, '\n');
		    std::cout << "Error! Invalid input! Repeat input!\n";
        }
    }
    return size;
}

int main()
{
    srand(time(0));
    int size = input(1);
    int size2 = input(2);
    std::vector<int> vec(size), vec2(size2);
    fillArr(vec);
    fillArr(vec2);
    print(vec, 1);
    print(vec2, 2);
    std::sort(vec.begin(), vec.end());
    std::sort(vec2.begin(), vec2.end());
    auto last = std::unique(vec.begin(), vec.end());
    vec.erase(last, vec.end());
    last = std::unique(vec2.begin(), vec2.end());
    vec2.erase(last, vec2.end());
    
    std::vector<int> res;
    std::set_intersection(vec.begin(), vec.end(),
                          vec2.begin(), vec2.end(),
                          std::back_inserter(res));
    std::cout << "\nIntersection: ";
    print(res, 3);
    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

#include <iostream>

#include <vector>

#include <algorithm>

#include <iterator>

#include <ctime>

void print(std::vector<int> &v, int num) {

std::cout << "\nArray #" << num << " is: ";

for(auto &i : v) std::cout << i << ' ';

}

void fillArr(std::vector<int> &v) {

for(int i{0}; i < v.size(); ++i) v[i] = rand()%10;

}

int input(int num) {

int size{0};

while(size < 1) {

std::cout << "Enter size array #" << num << ": ";

std::cin >> size;

if(std::cin.fail()) {

std::cin.clear();

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

std::cout << "Error! Invalid input! Repeat input!\n";

}

return size;

}

int main()

{

srand(time(0));

int size = input(1);

int size2 = input(2);

std::vector<int> vec(size), vec2(size2);

fillArr(vec);

fillArr(vec2);

print(vec, 1);

print(vec2, 2);

std::sort(vec.begin(), vec.end());

std::sort(vec2.begin(), vec2.end());

auto last = std::unique(vec.begin(), vec.end());

vec.erase(last, vec.end());

last = std::unique(vec2.begin(), vec2.end());

vec2.erase(last, vec2.end());

std::vector<int> res;

std::set_intersection(vec.begin(), vec.end(),

vec2.begin(), vec2.end(),

std::back_inserter(res));

std::cout << "\nIntersection: ";

print(res, 3);

return 0;

}

Ответить

WAR:

9 сентября 2021 в 16:56

Задание №1 (правильная версия):

#include <iostream>
#include <string>
#include <cctype>

std::string revStr(std::string  &s) {
	std::string res;
	int ind = s.length() - 1;
	while(!isalnum(s[ind])) { res += s[ind]; --ind; }
	int count = ind;
	for(int i = ind; i >= 0; --i) {
		if(s[i] == ' ') {
			count -= i;
			res += s.substr(i+1, count) + ' ';
			count = i;
		}
	}
	res += s.substr(0, count);
	return res;
}

int main() {
std::string str;
std::cout << "Enter string of some words: ";
std::getline(std::cin, str);
std::cout << "Reverse this string is: " << revStr(str);
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

#include <iostream>

#include <string>

#include <cctype>

std::string revStr(std::string &s) {

std::string res;

int ind = s.length() - 1;

while(!isalnum(s[ind])) { res += s[ind]; --ind; }

int count = ind;

for(int i = ind; i >= 0; --i) {

if(s[i] == ' ') {

count -= i;

res += s.substr(i+1, count) + ' ';

count = i;

}

res += s.substr(0, count);

return res;

}

int main() {

std::string str;

std::cout << "Enter string of some words: ";

std::getline(std::cin, str);

std::cout << "Reverse this string is: " << revStr(str);

return 0;

}

Ответить

WAR:

3 августа 2021 в 19:30

Задание №1:

#include <iostream>
#include <string>

std::string reverseStr(std::string &s) {
std::string res(s.rbegin(), s.rend());
return res;
}

int main() {
std::string str;
std::cout<<"Enter string: ";
std::getline(std::cin, str);
std::cout << reverseStr(str);
return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#include <iostream>

#include <string>

std::string reverseStr(std::string &s) {

std::string res(s.rbegin(), s.rend());

return res;

}

int main() {

std::string str;

std::cout<<"Enter string: ";

std::getline(std::cin, str);

std::cout << reverseStr(str);

return 0;

}

Ответить

Rock:

19 июня 2021 в 03:02

Задание 1:

#include<iostream>
#include<string>
#include <windows.h>

void Revers(std::string &str)
{
	str += " ";
	std::string revers=str;
	int j = 0;
	int i = 0;
	
	for (; i < str.size(); i++)
	{
		if (str[i] == ' ')
		{
			int iterator = 0;
			for (; j <= i; )
			{
				
				revers[str.size() - i + iterator-1] = str[j];
				j++;
				iterator++;
			}
		}
	}
	std::cout << revers;
}


int main()
{
	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);
	std::string str;

	std::getline(std::cin, str);

	Revers(str);

	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

#include<iostream>

#include<string>

#include <windows.h>

void Revers(std::string &str)

{

str += " ";

std::string revers=str;

int j = 0;

int i = 0;

for (; i < str.size(); i++)

{

if (str[i] == ' ')

{

int iterator = 0;

for (; j <= i; )

{

revers[str.size() - i + iterator-1] = str[j];

j++;

iterator++;

}

std::cout << revers;

}

int main()

{

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

std::string str;

std::getline(std::cin, str);

Revers(str);

return 0;

}

Задание 2:

#include<iostream>
#include<ctime>
#include<vector>

std::vector<int> Сombination(int x[],int y[], int size_1, int size_2)
{

	std::cout << "Объединение...\n";
	

	int size = std::max(size_1, size_2);
	bool add= true;
	
	std::vector<int> z;

	for (int i = 0; i < size_1; i++)
	{
		add = true;

		for (int j = i+1; j < size_1; j++)
		{
			if (x[i] == x[j])
				add = false;
		}

		if (add)
		{
			z.push_back(x[i]);
		}
	}

	for (int i = 0; i < size_2; i++)
	{
		add = true;

		for (int j = 0; j < z.size(); j++)
		{
			if (y[i] == z[j])
				add = false;
		}

		if (add)
		{
			z.push_back(y[i]);
		}

	}
	

	return z;
}

void Filling(int *a,int size)
{
	for (int i = 0; i < size; i++)
	{
		a[i] =rand()%10;
		
	}
	
}


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

	srand(time(0));

	int size_1 = rand()%10+1, size_2 = rand() % 10+1;



	int* x = new int[size_1];
	int* y = new int[size_2];
	Filling(x, size_1);
	Filling(y, size_2);

	std::cout << "Первый массив : ";
	for (int i = 0; i < size_1; i++)
	{
		std::cout << x[i] << " ";
	}
	std::cout << "\n";

	std::cout << "Второй массив : ";
	for (int i = 0; i < size_2; i++)
	{
		std::cout << y[i] << " ";
	}
	std::cout << "\n";

	
	std::vector<int> z = Сombination(x, y, size_1, size_2);


	std::cout << "Третий массив : ";
	for (int i = 0; i < z.size(); i++)
	{
		std::cout << z[i] << " ";
	}
	
	delete[] x;
	delete[] y;

	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

#include<iostream>

#include<ctime>

#include<vector>

std::vector<int> Сombination(int x[],int y[], int size_1, int size_2)

{

std::cout << "Объединение...\n";

int size = std::max(size_1, size_2);

bool add= true;

std::vector<int> z;

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

{

add = true;

for (int j = i+1; j < size_1; j++)

{

if (x[i] == x[j])

add = false;

}

if (add)

{

z.push_back(x[i]);

}

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

{

add = true;

for (int j = 0; j < z.size(); j++)

{

if (y[i] == z[j])

add = false;

}

if (add)

{

z.push_back(y[i]);

}

return z;

}

void Filling(int *a,int size)

{

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

{

a[i] =rand()%10;

}

int main()

{

setlocale(0, "");

srand(time(0));

int size_1 = rand()%10+1, size_2 = rand() % 10+1;

int* x = new int[size_1];

int* y = new int[size_2];

Filling(x, size_1);

Filling(y, size_2);

std::cout << "Первый массив : ";

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

{

std::cout << x[i] << " ";

}

std::cout << "\n";

std::cout << "Второй массив : ";

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

{

std::cout << y[i] << " ";

}

std::cout << "\n";

std::vector<int> z = Сombination(x, y, size_1, size_2);

std::cout << "Третий массив : ";

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

{

std::cout << z[i] << " ";

}

delete[] x;

delete[] y;

return 0;

}

Задание 3:

#include<iostream>

bool game_next = true;

class Game
{
	int comp_number = 50, next_step = 25, count = 0;
	bool end_game = false;

public:
	
	void start()
	{
		system("cls");

		std::cout << "Ваша задача загадать число в уме и помочь компьютеру угадать его направляя его командами\n"
			<<"\"up\",\"down\",\"yes\" (выше,ниже,правильное число)\n";

		while (!end_game)
		{
			std::cout << "Компьютер предпологает число - " << comp_number<<std::endl;
			std::string answer;
			std::cin >> answer;
			logic(answer);
		}

		std::cout << "Компьютер угадал правильное число за " << count << "действий.\n";

		char restart;

		std::cout << "Желаете ли сыграть снова?(Y/N)";

		std::cin >> restart;
		if (restart == 'N' || restart == 'n') { game_next = false; }
	
	}


	void logic(std::string & answer)
	{
		if ( next_step == 0) { next_step++; }

		if (answer == "up")
		{
			comp_number += next_step;
			next_step /= 2;
			count++;
		}
		else if (answer == "down")
		{
			comp_number -= next_step;
			next_step /= 2;
			count++;
		}
		else if (answer == "yes")
		{
			end_game = true;
			count++;
		}
	}


};

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

	while(game_next)
	{
		Game s;
		s.start();
	}



	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

#include<iostream>

bool game_next = true;

class Game

{

int comp_number = 50, next_step = 25, count = 0;

bool end_game = false;

public:

void start()

{

system("cls");

std::cout << "Ваша задача загадать число в уме и помочь компьютеру угадать его направляя его командами\n"

<<"\"up\",\"down\",\"yes\" (выше,ниже,правильное число)\n";

while (!end_game)

{

std::cout << "Компьютер предпологает число - " << comp_number<<std::endl;

std::string answer;

std::cin >> answer;

logic(answer);

}

std::cout << "Компьютер угадал правильное число за " << count << "действий.\n";

char restart;

std::cout << "Желаете ли сыграть снова?(Y/N)";

std::cin >> restart;

if (restart == 'N' || restart == 'n') { game_next = false; }

}

void logic(std::string & answer)

{

if ( next_step == 0) { next_step++; }

if (answer == "up")

{

comp_number += next_step;

next_step /= 2;

count++;

}

else if (answer == "down")

{

comp_number -= next_step;

next_step /= 2;

count++;

}

else if (answer == "yes")

{

end_game = true;

count++;

}

};

int main()

{

setlocale(0, "");

while(game_next)

{

Game s;

s.start();

}

return 0;

}

Ответить

Максим:

4 февраля 2021 в 14:13

Задание 3

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <utility>

using cattle = std::pair<int, bool>; // true - listed cow or bull, false - not listed

int get_int_user_input(int min, int max) {
	int input;
	while (!(std::cin >> input) || (input < min || input > max)) {
		std::cout << "Out of range, try again: ";
		std::cin.clear();
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	}
	return input;
}

void convert_int_into_vector(std::vector<cattle> &vector, int number) {
	for (int iter{}, multiplier{ 1000 }; iter != vector.size(); ++iter, multiplier /= 10) {
		vector[iter].first = (number / multiplier) % 10;
	}
}

void new_cattle_list(std::vector<cattle>& needed_number) {
	for (int iter{}; iter != needed_number.size(); ++iter) {
		needed_number[iter].second = false;
	}
}

int seek_cows(std::vector<cattle>& needed_number_tmp, std::vector<cattle>& guess_array) {
	int cows{};
	for (int iter{}; iter != needed_number_tmp.size(); ++iter) {
		if (guess_array[iter].first == needed_number_tmp[iter].first) {
			cows++;
			needed_number_tmp[iter].second = true; // list this cow
			guess_array[iter].second = true; // list this cow
		}
	}
	return cows;
}

int seek_bulls(std::vector<cattle>& needed_number_tmp, const std::vector<cattle>& guess_array) {
	int bulls{};
	for (int iter_upper{}; iter_upper != needed_number_tmp.size(); ++iter_upper) {
		if (guess_array[iter_upper].second == false) { // if not listed as cow
			for (int iter_lower{}; iter_lower != needed_number_tmp.size(); ++iter_lower) {
				if (guess_array[iter_upper].first == needed_number_tmp[iter_lower].first) {
					if (needed_number_tmp[iter_lower].second == false) { // if it not listed as bull already
						++bulls;
						needed_number_tmp[iter_lower].second = true; // list this bull
						break;
					}
				}
			}
		}
	}
	return bulls;
}

int get_random_number(int min, int max) {
	static const double fraction{ 1.0 / (static_cast<double>(RAND_MAX) + 1.0) };
	return static_cast<int>(rand() * fraction * (max - min + 1.0) + min);
}

int main(int argc, char* argv[]) {
	std::srand(static_cast<unsigned int>(std::time(0)));
	rand();

	std::cout << "Game: Cows and Buls\n";
	std::vector<cattle> needed_number{
		{get_random_number(1, 9), false},
		{get_random_number(0, 9), false},
		{get_random_number(0, 9), false},
		{get_random_number(0, 9), false} };

	int guess,
		cows,
		bulls;
	do {
		std::cout << "Enter your guess: ";
		guess = get_int_user_input(1000, 9999);
		std::vector<cattle> guess_vector(needed_number.size());
		convert_int_into_vector(guess_vector, guess);

		cows = seek_cows(needed_number, guess_vector);
		bulls = seek_bulls(needed_number, guess_vector);

		new_cattle_list(needed_number);
		std::cout << "Cows: " << cows << "\nBulls: " << bulls << '\n';
	} while (cows != 4);
		
	std::cout << "You won!\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

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 <iostream>

#include <cstdlib>

#include <ctime>

#include <vector>

#include <utility>

using cattle = std::pair<int, bool>; // true - listed cow or bull, false - not listed

int get_int_user_input(int min, int max) {

int input;

while (!(std::cin >> input) || (input < min || input > max)) {

std::cout << "Out of range, try again: ";

std::cin.clear();

std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

}

return input;

}

void convert_int_into_vector(std::vector<cattle> &vector, int number) {

for (int iter{}, multiplier{ 1000 }; iter != vector.size(); ++iter, multiplier /= 10) {

vector[iter].first = (number / multiplier) % 10;

}

void new_cattle_list(std::vector<cattle>& needed_number) {

for (int iter{}; iter != needed_number.size(); ++iter) {

needed_number[iter].second = false;

}

int seek_cows(std::vector<cattle>& needed_number_tmp, std::vector<cattle>& guess_array) {

int cows{};

for (int iter{}; iter != needed_number_tmp.size(); ++iter) {

if (guess_array[iter].first == needed_number_tmp[iter].first) {

cows++;

needed_number_tmp[iter].second = true; // list this cow

guess_array[iter].second = true; // list this cow

}

return cows;

}

int seek_bulls(std::vector<cattle>& needed_number_tmp, const std::vector<cattle>& guess_array) {

int bulls{};

for (int iter_upper{}; iter_upper != needed_number_tmp.size(); ++iter_upper) {

if (guess_array[iter_upper].second == false) { // if not listed as cow

for (int iter_lower{}; iter_lower != needed_number_tmp.size(); ++iter_lower) {

if (guess_array[iter_upper].first == needed_number_tmp[iter_lower].first) {

if (needed_number_tmp[iter_lower].second == false) { // if it not listed as bull already

++bulls;

needed_number_tmp[iter_lower].second = true; // list this bull

break;

}

return bulls;

}

int get_random_number(int min, int max) {

static const double fraction{ 1.0 / (static_cast<double>(RAND_MAX) + 1.0) };

return static_cast<int>(rand() * fraction * (max - min + 1.0) + min);

}

int main(int argc, char* argv[]) {

std::srand(static_cast<unsigned int>(std::time(0)));

rand();

std::cout << "Game: Cows and Buls\n";

std::vector<cattle> needed_number{

{get_random_number(1, 9), false},

{get_random_number(0, 9), false},

{get_random_number(0, 9), false} };

int guess,

cows,

bulls;

do {

std::cout << "Enter your guess: ";

guess = get_int_user_input(1000, 9999);

std::vector<cattle> guess_vector(needed_number.size());

convert_int_into_vector(guess_vector, guess);

cows = seek_cows(needed_number, guess_vector);

bulls = seek_bulls(needed_number, guess_vector);

new_cattle_list(needed_number);

std::cout << "Cows: " << cows << "\nBulls: " << bulls << '\n';

} while (cows != 4);

std::cout << "You won!\n";

return 0;

}

Ответить

Kir:

8 января 2021 в 20:45

Задание 3

#include <iostream>
#include <vector>
#include <algorithm>
#include "RandNumber.h"
#include "UserInput.h"

/*
Вы, в качестве пользователя,
 * загадываете число от 0 до 100.
 * Программа должна его угадать,
 *  делая предположения,
 * а вы должны сообщать ей,
 * является ли её число слишком большим,
 * слишком маленьким
 * или "Правильно, угадал!".

В конце программа
 * должна вывести на экран
 * количество предположений,
 * которые ей потребовались для того, чтобы угадать ваше число.

Примечание:
 * Вам, как программисту,
 *  придется выбирать стратегию угадывания
 *  компьютером числа пользователя.
 *  Самая простая стратегия
 *  заключается в переборе чисел от 0 до 100
 *  (например: 1, 2, 3 и т.д.), но это очень долго.
 *  Лучшим вариантом является деление диапазона пополам:

   начинаем с 50;

   если число пользователя больше,
 * то вновь делим диапазон оставшихся чисел на 2
 *  и добавляем к предыдущему предположению,
 * получая, таким образом, 75;

   если число пользователя меньше,
 * то (делим 50 на 2) указываем 25;

   и, таким образом, делим диапазон до тех пор,
 *  пока не доберемся до верного результата.

У вас также может быть и другая/своя стратегия.

 */



int main()
{
	int maxNumber = 100;
	int minNumber = 0;
	GreaterLowerRight userDecision;
	std::vector<int> computerDecisions;
	while (true)
	{
		int computerDecision = getRandomNumber(minNumber, maxNumber);
		auto result = std::find(computerDecisions.begin(), computerDecisions.end(), computerDecision);
		if (result != computerDecisions.end())
			continue;
		computerDecisions.push_back(computerDecision);
		std::cout << computerDecision << '\n';
		std::cout << "Greater(G), Lower(L), Right(R) : " << '\n';
		userDecision = getGreaterOrLower();
		if (userDecision == GreaterLowerRight::LOWER)
			minNumber = computerDecision;
		else if (userDecision == GreaterLowerRight::GREATER)
			maxNumber = computerDecision;
		else if (userDecision == GreaterLowerRight::RIGHT)
			break;
	}
	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

#include <iostream>

#include <vector>

#include <algorithm>

#include "RandNumber.h"

#include "UserInput.h"

/*

Вы, в качестве пользователя,

* загадываете число от 0 до 100.

* Программа должна его угадать,

* делая предположения,

* а вы должны сообщать ей,

* является ли её число слишком большим,

* слишком маленьким

* или "Правильно, угадал!".

В конце программа

* должна вывести на экран

* количество предположений,

* которые ей потребовались для того, чтобы угадать ваше число.

Примечание:

* Вам, как программисту,

* придется выбирать стратегию угадывания

* компьютером числа пользователя.

* Самая простая стратегия

* заключается в переборе чисел от 0 до 100

* (например: 1, 2, 3 и т.д.), но это очень долго.

* Лучшим вариантом является деление диапазона пополам:

начинаем с 50;

если число пользователя больше,

* то вновь делим диапазон оставшихся чисел на 2

* и добавляем к предыдущему предположению,

* получая, таким образом, 75;

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

* то (делим 50 на 2) указываем 25;

и, таким образом, делим диапазон до тех пор,

* пока не доберемся до верного результата.

У вас также может быть и другая/своя стратегия.

*/

int main()

{

int maxNumber = 100;

int minNumber = 0;

GreaterLowerRight userDecision;

std::vector<int> computerDecisions;

while (true)

{

int computerDecision = getRandomNumber(minNumber, maxNumber);

auto result = std::find(computerDecisions.begin(), computerDecisions.end(), computerDecision);

if (result != computerDecisions.end())

continue;

computerDecisions.push_back(computerDecision);

std::cout << computerDecision << '\n';

std::cout << "Greater(G), Lower(L), Right(R) : " << '\n';

userDecision = getGreaterOrLower();

if (userDecision == GreaterLowerRight::LOWER)

minNumber = computerDecision;

else if (userDecision == GreaterLowerRight::GREATER)

maxNumber = computerDecision;

else if (userDecision == GreaterLowerRight::RIGHT)

break;

}

return 0;

}

UserInput.h

#ifndef USERINPUT_H
#define USERINPUT_H

template<typename T>
void setUserNumber(T& userNumber, T min, T max)
{
	while (true)
	{
		std::cin >> userNumber;

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

		if (userNumber < min)
		{
			std::cout << "Ошибка! Число меньше минимума. Попробуйте ещё раз: ";
			continue;
		}

		if (userNumber > max)
		{
			std::cout << "Ошибка! Число больше максимума. Попробуйте ещё раз: ";
			continue;
		}
		std::cin.get();
		break;
	}
}

template<typename T>
void setUserNumber(T& userNumber)
{
	while (true)
	{
		std::cin >> userNumber;

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

		std::cin.get();
		break;
	}
}



bool isCorrectInput(std::string& numbers)//проверка корректности ввода
{
	for (unsigned int i = 0; i < numbers.length(); ++i)
	{
		if (!isdigit(numbers[i])) //если не число
		{
			if (!isspace(numbers[i])) //если не пробел
			{
				std::cout << "Введены недопустимы символы. Повторите ввод: "; //здесь отсечем double и отрицательные числа
				return false;
				break;
			}
		}
	}
	return true;
}
void setUserIntNumberByString(std::string& number)
{
	while (true)
	{
		//считывание чисел
		getline(std::cin, number);
		//проверяем введенные значения
		if (!isCorrectInput(number))
		{
			continue;
		}
		break;
	}
}

bool setYesNo()
{
	char userDecision;
	while (true)
	{
		std::cin >> userDecision;

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

		std::cin.get();
		switch(userDecision)
		{
		case 'Y':
		case 'y':
			return true;
		case 'N':
		case 'n':
			return false;
		default:
		{
			std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (Y/N)";
		}
		}
		continue;
	}

}

enum class GreaterLowerRight
{
	GREATER,
	LOWER,
	RIGHT
};

GreaterLowerRight getGreaterOrLower()
{
	char userDecision;
	while (true)
	{
		std::cin >> userDecision;

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

		std::cin.get();
		switch(userDecision)
		{
		case 'G':
		case 'g':
			return GreaterLowerRight::GREATER;
		case 'L':
		case 'l':
			return GreaterLowerRight::LOWER;
		case 'R':
		case 'r':
			return GreaterLowerRight::RIGHT;
			break;
		default:
		{
			std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (H)ot, C(old), (R)ight: ";
			break;
		}
		}
		continue;
	}

}

#endif /* USERINPUT_H */

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

#ifndef USERINPUT_H

#define USERINPUT_H

template<typename T>

void setUserNumber(T& userNumber, T min, T max)

{

while (true)

{

std::cin >> userNumber;

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

{

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

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

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

continue;

}

if (userNumber < min)

{

std::cout << "Ошибка! Число меньше минимума. Попробуйте ещё раз: ";

continue;

}

if (userNumber > max)

{

std::cout << "Ошибка! Число больше максимума. Попробуйте ещё раз: ";

continue;

}

std::cin.get();

break;

}

template<typename T>

void setUserNumber(T& userNumber)

{

while (true)

{

std::cin >> userNumber;

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

{

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

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

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

continue;

}

std::cin.get();

break;

}

bool isCorrectInput(std::string& numbers)//проверка корректности ввода

{

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

{

if (!isdigit(numbers[i])) //если не число

{

if (!isspace(numbers[i])) //если не пробел

{

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

return false;

break;

}

return true;

}

void setUserIntNumberByString(std::string& number)

{

while (true)

{

//считывание чисел

getline(std::cin, number);

//проверяем введенные значения

if (!isCorrectInput(number))

{

continue;

}

break;

}

bool setYesNo()

{

char userDecision;

while (true)

{

std::cin >> userDecision;

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

{

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

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

std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (Y/N)";

continue;

}

std::cin.get();

switch(userDecision)

{

case 'Y':

case 'y':

return true;

case 'N':

case 'n':

return false;

default:

{

std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (Y/N)";

}

continue;

}

enum class GreaterLowerRight

{

GREATER,

LOWER,

RIGHT

};

GreaterLowerRight getGreaterOrLower()

{

char userDecision;

while (true)

{

std::cin >> userDecision;

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

{

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

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

std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (Y/N)";

continue;

}

std::cin.get();

switch(userDecision)

{

case 'G':

case 'g':

return GreaterLowerRight::GREATER;

case 'L':

case 'l':

return GreaterLowerRight::LOWER;

case 'R':

case 'r':

return GreaterLowerRight::RIGHT;

break;

default:

{

std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (H)ot, C(old), (R)ight: ";

break;

}

continue;

}

#endif /* USERINPUT_H */

RandNumber.h

#ifndef RANDNUMBER_H
#define RANDNUMBER_H

int getRandomNumber(int min, int max);
int getRandomNumber(int scale);

#endif /* RANDNUMBER_H */

1

2

3

4

5

6

7

#ifndef RANDNUMBER_H

#define RANDNUMBER_H

int getRandomNumber(int min, int max);

int getRandomNumber(int scale);

#endif /* RANDNUMBER_H */

RandNumber.cpp

#include "RandNumber.h"
#include <random> // для std::random_device и std::mt19937

int getRandomNumber(int min, int max)
{
	//инициализация часов
	static bool init = false;
	if (init == false)
	{
		srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения
		init = true;
	}

	static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды
	// Равномерно распределяем вычисление значения из нашего диапазона
	return static_cast<int> (rand() * fraction * (max - min + 1) + min);
}

int getRandomNumber(int scale)
{
	return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1));
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

#include "RandNumber.h"

#include <random> // для std::random_device и std::mt19937

int getRandomNumber(int min, int max)

{

//инициализация часов

static bool init = false;

if (init == false)

{

srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения

init = true;

}

static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды

// Равномерно распределяем вычисление значения из нашего диапазона

return static_cast<int> (rand() * fraction * (max - min + 1) + min);

}

int getRandomNumber(int scale)

{

return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1));

}

Ответить

Kir:

8 января 2021 в 12:34

Задание 2

main.cpp

#include <iostream>
#include <vector>
#include <algorithm>
#include "RandNumber.h"

/*
Напишите программу,
 *  которая создает два массива
 * и заполняет их случайными числами.
 *  Затем она должна возвратить третий массив,
 *  который содержит только общие для обоих массивов значения (без дублирований).
 */

template <typename T>
void printVector(const std::vector<T>& vect) //вывод массива на экран
{
	for (const auto& elem : vect)
	{
		std::cout << elem << ' ';
	}
}

template <typename T>
void fillVectorRndNums(std::vector<T>& vect, int rndNumsCount, T rndScale) //заполнение массива рандомными числами (вектор, число элементов, разрядность рандомного числа)
{
	for (int i = 0; i < rndNumsCount; ++i)
	{
		vect.push_back(getRandomNumber(rndScale));
	}
}

int main()
{
	std::vector<int> vect1; //массив 1
	fillVectorRndNums(vect1, 10, 1); //заполнение 10ю рандомными числами разрядностью 1
	std::vector<int> vect2; //массив 2
	fillVectorRndNums(vect2, 10, 1); //заполнение 10ю рандомными числами разрядностью 1
	std::vector<int> resultVect; //результирующий вектор
	for (const auto& elem1 : vect1)
	{
		for (const auto& elem2 : vect2)
		{
			if (elem1 == elem2)
			{
				auto findResult = std::find(resultVect.begin(), resultVect.end(), elem1); //проверка наличия числа в результирующем векторе
				if (findResult == resultVect.end())
				{
					resultVect.push_back(elem1);
					std::sort(resultVect.begin(), resultVect.end()); //хоть какая то оптимизация перед поиском, хоть find и работает линейно
				}
			}
		}
	}
	printVector(vect1);
	std::cout << '\n';
	printVector(vect2);
	std::cout << '\n';
	printVector(resultVect);
	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

#include <iostream>

#include <vector>

#include <algorithm>

#include "RandNumber.h"

/*

Напишите программу,

* которая создает два массива

* и заполняет их случайными числами.

* Затем она должна возвратить третий массив,

* который содержит только общие для обоих массивов значения (без дублирований).

*/

template <typename T>

void printVector(const std::vector<T>& vect) //вывод массива на экран

{

for (const auto& elem : vect)

{

std::cout << elem << ' ';

}

template <typename T>

void fillVectorRndNums(std::vector<T>& vect, int rndNumsCount, T rndScale) //заполнение массива рандомными числами (вектор, число элементов, разрядность рандомного числа)

{

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

{

vect.push_back(getRandomNumber(rndScale));

}

int main()

{

std::vector<int> vect1; //массив 1

fillVectorRndNums(vect1, 10, 1); //заполнение 10ю рандомными числами разрядностью 1

std::vector<int> vect2; //массив 2

fillVectorRndNums(vect2, 10, 1); //заполнение 10ю рандомными числами разрядностью 1

std::vector<int> resultVect; //результирующий вектор

for (const auto& elem1 : vect1)

{

for (const auto& elem2 : vect2)

{

if (elem1 == elem2)

{

auto findResult = std::find(resultVect.begin(), resultVect.end(), elem1); //проверка наличия числа в результирующем векторе

if (findResult == resultVect.end())

{

resultVect.push_back(elem1);

std::sort(resultVect.begin(), resultVect.end()); //хоть какая то оптимизация перед поиском, хоть find и работает линейно

}

printVector(vect1);

std::cout << '\n';

printVector(vect2);

std::cout << '\n';

printVector(resultVect);

return 0;

}

RandNumber.h

#include "RandNumber.h"
#ifndef RANDNUMBER_H
#define RANDNUMBER_H

int getRandomNumber(int min, int max);
int getRandomNumber(int scale);

#endif /* RANDNUMBER_H */

1

2

3

4

5

6

7

8

#include "RandNumber.h"

#ifndef RANDNUMBER_H

#define RANDNUMBER_H

int getRandomNumber(int min, int max);

int getRandomNumber(int scale);

#endif /* RANDNUMBER_H */

RandNumber.cpp

#include "RandNumber.h"
#include <random> // для std::random_device и std::mt19937

int getRandomNumber(int min, int max)
{
	//инициализация часов
	static bool init = false;
	if (init == false)
	{
		srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения
		init = true;
	}

	static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды
	// Равномерно распределяем вычисление значения из нашего диапазона
	return static_cast<int> (rand() * fraction * (max - min + 1) + min);
}

int getRandomNumber(int scale)
{
	return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1));
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

#include "RandNumber.h"

#include <random> // для std::random_device и std::mt19937

int getRandomNumber(int min, int max)

{

//инициализация часов

static bool init = false;

if (init == false)

{

srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения

init = true;

}

static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды

// Равномерно распределяем вычисление значения из нашего диапазона

return static_cast<int> (rand() * fraction * (max - min + 1) + min);

}

int getRandomNumber(int scale)

{

return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1));

}

Ответить

Kir:

8 января 2021 в 10:59

Задание 1

#include <iostream>
#include <vector>

/*
Напишите программу,
 * которая запрашивает у пользователя строку,
 * содержащую несколько слов.
 * Затем выведите пользователю ту же строку,
 * но в обратном порядке. Например:

Введите строку:
Меня зовут Анатолий!
Результат:
!Анатолий зовут Меня
 */

int main()
{
	std::cout << "Введите строку: ";
	std::string str;
	getline(std::cin, str);
	std::cout << "Результат: \n";
	std::string word = ""; // буфер для слова
	std::vector< std::string> sentence;
	for (int i = 0; i < str.size(); ++i) //парсинг строки
	{
		if (ispunct(str[i]) || (isspace(str[i]))) //новое слово если знак пунктуации или пробел
		{
			if (word.size() > 0) sentence.push_back(word); //добавляем в массив слово, только если оно было найдено до этого
			sentence.push_back(std::string(1, str[i])); //доавление в массив знака пунктуации или пробела
			word.clear(); //очищаем буфер с текущим словом
			continue;
		}
		else
		{
			word = word + str[i]; //сборка слова по символам
		}
		if (i == str.size() - 1) //если в конце предложения не стояло знака пунктуации или пробела
		{
			sentence.push_back(word);
		}
	}
	// вывод предложения наоборот на экран
	for (int i = sentence.size() - 1; i >= 0; --i)
	{
		std::cout << sentence[i];
	}

	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

#include <iostream>

#include <vector>

/*

Напишите программу,

* которая запрашивает у пользователя строку,

* содержащую несколько слов.

* Затем выведите пользователю ту же строку,

* но в обратном порядке. Например:

Введите строку:

Меня зовут Анатолий!

Результат:

!Анатолий зовут Меня

*/

int main()

{

std::cout << "Введите строку: ";

std::string str;

getline(std::cin, str);

std::cout << "Результат: \n";

std::string word = ""; // буфер для слова

std::vector< std::string> sentence;

for (int i = 0; i < str.size(); ++i) //парсинг строки

{

if (ispunct(str[i]) || (isspace(str[i]))) //новое слово если знак пунктуации или пробел

{

if (word.size() > 0) sentence.push_back(word); //добавляем в массив слово, только если оно было найдено до этого

sentence.push_back(std::string(1, str[i])); //доавление в массив знака пунктуации или пробела

word.clear(); //очищаем буфер с текущим словом

continue;

}

else

{

word = word + str[i]; //сборка слова по символам

}

if (i == str.size() - 1) //если в конце предложения не стояло знака пунктуации или пробела

{

sentence.push_back(word);

}

// вывод предложения наоборот на экран

for (int i = sentence.size() - 1; i >= 0; --i)

{

std::cout << sentence[i];

}

return 0;

}

Ответить

Kir:

7 января 2021 в 23:10

Задание 3

main.cpp

#include <vector>
#include <algorithm>
#include "UserInput.h"
#include "RandNumber.h"

/*
Игра «Быки и коровы». Правила:

   программа генерирует случайным образом 4-значное число;

   пользователю предлагают угадать сгенерированное программой число;

   за каждую угаданную пользователем цифру, стоящую на правильной позиции, он получает «корову»;

   за каждую угаданную пользователем цифру, стоящую на неправильной позиции, он получает «быка»;

   после каждого предположения пользователю должно выводиться количество «коров» и «быков», которые он заработал;

   игра окончена тогда, когда пользователь угадал все цифры.

Например, компьютер загадал число 9978:

Добро пожаловать в игру «Быки и коровы»!
Введите число:
9965
2 коровы, 0 быков
9989
2 коровы, 1 бык
...
 */

using Bulls = std::vector<int>;
using Cows = std::vector<int>;

bool isCowExistByIndex(const std::string& userNumStr, const std::string& rndNumStr, Cows& cows, Bulls& bulls, int index) //проверка правильных позиций
{
	if (userNumStr[index] == rndNumStr[index])
	{
		auto result = std::find(cows.begin(), cows.end(), index);
		if (result == cows.end())
		{
			cows.push_back(index);
			return true;
		}
	}
	return false;

}

void checkBullByIndex(const std::string& userNumStr, const std::string& rndNumStr, Cows& cows, Bulls& bulls, int index) //проверка наличия впринцепи цифры
{
	auto result = std::find(cows.begin(), cows.end(), index);
	if (result == cows.end())
	{
		for (int j = 0; j < rndNumStr.length(); ++j)
		{
			result = std::find(bulls.begin(), bulls.end(), j);
			if (result == bulls.end())
			{
				if (userNumStr[index] == rndNumStr[j]) bulls.push_back(j);
			}
		}
	}
}

void checkByCowBull(const std::string& userNumStr, const std::string& rndNumStr, Cows& cows, Bulls& bulls)
{
	for (int i = 0; i < userNumStr.length(); ++i)
	{
		//проверка правильных позиций
		if (isCowExistByIndex(userNumStr, rndNumStr, cows, bulls, i)) continue;
		//проверка наличия впринцепи цифры
		checkBullByIndex(userNumStr, rndNumStr, cows, bulls, i);
	}
}

void printCowsCount(int cowsCount) //вывод на экран количества коров
{
	std::cout << cowsCount << ' ';
	switch (cowsCount)
	{
	case 0:
		std::cout << "коров";
		break;
	case 1:
		std::cout << "коровa";
		break;
	default:
		std::cout << "коровы";
		break;
	}
}

void printBullsCount(int bullsCount) //вывод на экран количества быков
{
	std::cout << bullsCount << ' ';
	switch (bullsCount)
	{
	case 0:
		std::cout << "быков";
		break;
	case 1:
		std::cout << "бык";
		break;
	default:
		std::cout << "быка";
		break;
	}
}

int main()
{
	int rndNum{getRandomNumber(1000, 9999)};
	std::string rndNumStr = std::to_string(rndNum); //переводим в строки числа, чтобы сравнивать через char
	int userNum{0};
	std::string userNumStr;
	Cows cows; //массив в котором указаны индексы цифр на своих местах.
	Bulls bulls; //массивы в котором указаны индексы цифр которые присутствуют, но не на своих местах
	// Эти массивы нужны, чтобы индексы не проверялись повторно.
	std::cout << "Добро пожаловать в игру «Быки и коровы»!\nВведите число: \n";
	std::cout << rndNum;
	while (true)
	{
		userNumStr.clear();
		setUserNumber(userNum, 1000, 9999); //получение от игрока числа
		userNumStr = std::to_string(userNum);
		checkByCowBull(userNumStr, rndNumStr, cows, bulls); // проверка числа
		//вывод на экран количества коров и быков
		int cowsCount = cows.size(); //число коров
		int bullsCount = bulls.size(); //число быков
		printCowsCount(cowsCount);
		std::cout << ", ";
		printBullsCount(bullsCount);
		std::cout << "\n";
		//окончание игры при равенстве чичслу коров числу цифр
		if (cowsCount == rndNumStr.size())
		{
			break;
		}
	}
	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

#include <vector>

#include <algorithm>

#include "UserInput.h"

#include "RandNumber.h"

/*

Игра «Быки и коровы». Правила:

программа генерирует случайным образом 4-значное число;

пользователю предлагают угадать сгенерированное программой число;

за каждую угаданную пользователем цифру, стоящую на правильной позиции, он получает «корову»;

за каждую угаданную пользователем цифру, стоящую на неправильной позиции, он получает «быка»;

после каждого предположения пользователю должно выводиться количество «коров» и «быков», которые он заработал;

игра окончена тогда, когда пользователь угадал все цифры.

Например, компьютер загадал число 9978:

Добро пожаловать в игру «Быки и коровы»!

Введите число:

9965

2 коровы, 0 быков

9989

2 коровы, 1 бык

...

*/

using Bulls = std::vector<int>;

using Cows = std::vector<int>;

bool isCowExistByIndex(const std::string& userNumStr, const std::string& rndNumStr, Cows& cows, Bulls& bulls, int index) //проверка правильных позиций

{

if (userNumStr[index] == rndNumStr[index])

{

auto result = std::find(cows.begin(), cows.end(), index);

if (result == cows.end())

{

cows.push_back(index);

return true;

}

return false;

}

void checkBullByIndex(const std::string& userNumStr, const std::string& rndNumStr, Cows& cows, Bulls& bulls, int index) //проверка наличия впринцепи цифры

{

auto result = std::find(cows.begin(), cows.end(), index);

if (result == cows.end())

{

for (int j = 0; j < rndNumStr.length(); ++j)

{

result = std::find(bulls.begin(), bulls.end(), j);

if (result == bulls.end())

{

if (userNumStr[index] == rndNumStr[j]) bulls.push_back(j);

}

void checkByCowBull(const std::string& userNumStr, const std::string& rndNumStr, Cows& cows, Bulls& bulls)

{

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

{

//проверка правильных позиций

if (isCowExistByIndex(userNumStr, rndNumStr, cows, bulls, i)) continue;

//проверка наличия впринцепи цифры

checkBullByIndex(userNumStr, rndNumStr, cows, bulls, i);

}

void printCowsCount(int cowsCount) //вывод на экран количества коров

{

std::cout << cowsCount << ' ';

switch (cowsCount)

{

case 0:

std::cout << "коров";

break;

case 1:

std::cout << "коровa";

break;

default:

std::cout << "коровы";

break;

}

void printBullsCount(int bullsCount) //вывод на экран количества быков

{

std::cout << bullsCount << ' ';

switch (bullsCount)

{

case 0:

std::cout << "быков";

break;

case 1:

std::cout << "бык";

break;

default:

std::cout << "быка";

break;

}

int main()

{

int rndNum{getRandomNumber(1000, 9999)};

std::string rndNumStr = std::to_string(rndNum); //переводим в строки числа, чтобы сравнивать через char

int userNum{0};

std::string userNumStr;

Cows cows; //массив в котором указаны индексы цифр на своих местах.

Bulls bulls; //массивы в котором указаны индексы цифр которые присутствуют, но не на своих местах

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

std::cout << "Добро пожаловать в игру «Быки и коровы»!\nВведите число: \n";

std::cout << rndNum;

while (true)

{

userNumStr.clear();

setUserNumber(userNum, 1000, 9999); //получение от игрока числа

userNumStr = std::to_string(userNum);

checkByCowBull(userNumStr, rndNumStr, cows, bulls); // проверка числа

//вывод на экран количества коров и быков

int cowsCount = cows.size(); //число коров

int bullsCount = bulls.size(); //число быков

printCowsCount(cowsCount);

std::cout << ", ";

printBullsCount(bullsCount);

std::cout << "\n";

//окончание игры при равенстве чичслу коров числу цифр

if (cowsCount == rndNumStr.size())

{

break;

}

return 0;

}

RandNumber.h

#ifndef RANDNUMBER_H
#define RANDNUMBER_H

int getRandomNumber(int min, int max);
int getRandomNumber(int scale);

#endif /* RANDNUMBER_H */

1

2

3

4

5

6

7

#ifndef RANDNUMBER_H

#define RANDNUMBER_H

int getRandomNumber(int min, int max);

int getRandomNumber(int scale);

#endif /* RANDNUMBER_H */

RandNumber.cpp

int getRandomNumber(int min, int max)
{
	//инициализация часов
	static bool init = false;
	if (init == false)
	{
		srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения
		init = true;
	}

	static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды
	// Равномерно распределяем вычисление значения из нашего диапазона
	return static_cast<int> (rand() * fraction * (max - min + 1) + min);
}

int getRandomNumber(int scale)
{
	return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1));
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

int getRandomNumber(int min, int max)

{

//инициализация часов

static bool init = false;

if (init == false)

{

srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения

init = true;

}

static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды

// Равномерно распределяем вычисление значения из нашего диапазона

return static_cast<int> (rand() * fraction * (max - min + 1) + min);

}

int getRandomNumber(int scale)

{

return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1));

}

UserInput.h

#ifndef USERINPUT_H
#define USERINPUT_H

template<typename T>
void setUserNumber(T& userNumber, T min, T max)
{
	while (true)
	{
		std::cin >> userNumber;

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

		if (userNumber < min)
		{
			std::cout << "Ошибка! Число меньше минимума. Попробуйте ещё раз: ";
			continue;
		}

		if (userNumber > max)
		{
			std::cout << "Ошибка! Число больше максимума. Попробуйте ещё раз: ";
			continue;
		}
		std::cin.get();
		break;
	}
}

template<typename T>
void setUserNumber(T& userNumber)
{
	while (true)
	{
		std::cin >> userNumber;

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

		std::cin.get();
		break;
	}
}



bool isCorrectInput(std::string& numbers)//проверка корректности ввода
{
	for (unsigned int i = 0; i < numbers.length(); ++i)
	{
		if (!isdigit(numbers[i])) //если не число
		{
			if (!isspace(numbers[i])) //если не пробел
			{
				std::cout << "Введены недопустимы символы. Повторите ввод: "; //здесь отсечем double и отрицательные числа
				return false;
				break;
			}
		}
	}
	return true;
}
void setUserIntNumberByString(std::string& number)
{
	while (true)
	{
		//считывание чисел
		getline(std::cin, number);
		//проверяем введенные значения
		if (!isCorrectInput(number))
		{
			continue;
		}
		break;
	}
}

bool setYesNo()
{
	char userDecision;
	while (true)
	{
		std::cin >> userDecision;

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

		std::cin.get();
		switch(userDecision)
		{
		case 'Y':
		case 'y':
			return true;
		case 'N':
		case 'n':
			return false;
		default:
		{
			std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (Y/N)";
		}
		}
		continue;
	}

}

#endif /* USERINPUT_H */

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

#ifndef USERINPUT_H

#define USERINPUT_H

template<typename T>

void setUserNumber(T& userNumber, T min, T max)

{

while (true)

{

std::cin >> userNumber;

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

{

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

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

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

continue;

}

if (userNumber < min)

{

std::cout << "Ошибка! Число меньше минимума. Попробуйте ещё раз: ";

continue;

}

if (userNumber > max)

{

std::cout << "Ошибка! Число больше максимума. Попробуйте ещё раз: ";

continue;

}

std::cin.get();

break;

}

template<typename T>

void setUserNumber(T& userNumber)

{

while (true)

{

std::cin >> userNumber;

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

{

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

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

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

continue;

}

std::cin.get();

break;

}

bool isCorrectInput(std::string& numbers)//проверка корректности ввода

{

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

{

if (!isdigit(numbers[i])) //если не число

{

if (!isspace(numbers[i])) //если не пробел

{

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

return false;

break;

}

return true;

}

void setUserIntNumberByString(std::string& number)

{

while (true)

{

//считывание чисел

getline(std::cin, number);

//проверяем введенные значения

if (!isCorrectInput(number))

{

continue;

}

break;

}

bool setYesNo()

{

char userDecision;

while (true)

{

std::cin >> userDecision;

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

{

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

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

std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (Y/N)";

continue;

}

std::cin.get();

switch(userDecision)

{

case 'Y':

case 'y':

return true;

case 'N':

case 'n':

return false;

default:

{

std::cout << "Ошибка! Некорректный ввод. Попробуйте ещё раз (Y/N)";

}

continue;

}

#endif /* USERINPUT_H */

Ответить

Евгений:

20 ноября 2020 в 10:47

// Task № 1

#include <iostream>
#include <vector>
#include <sstream>

void reverse_string(std::string* source)
{
    if (!source->empty())
    {
        std::istringstream iss(*source);
        std::size_t word_count = 1u; //The string should have at least one word

        for (auto symbol : *source)
            if (symbol == ' ')
                word_count++; 

        std::vector<std::string> words(word_count, "");
        std::string word;

        while (iss >> word)
            words.emplace_back(word);

        std::reverse(words.begin(), words.end());
        source->clear();

        for (auto&& w : words)
            *source += (w + " ");
    }
}

int main()
{
    std::string str { "I like to learn C++ with Ravesli" };
    reverse_string(&str);
    std::cout << str << '\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

#include <iostream>

#include <vector>

#include <sstream>

void reverse_string(std::string* source)

{

if (!source->empty())

{

std::istringstream iss(*source);

std::size_t word_count = 1u; //The string should have at least one word

for (auto symbol : *source)

if (symbol == ' ')

word_count++;

std::vector<std::string> words(word_count, "");

std::string word;

while (iss >> word)

words.emplace_back(word);

std::reverse(words.begin(), words.end());

source->clear();

for (auto&& w : words)

*source += (w + " ");

}

int main()

{

std::string str { "I like to learn C++ with Ravesli" };

reverse_string(&str);

std::cout << str << '\n';

return 0;

}

Ответить

RockNRullz:

18 июня 2020 в 20:18

Задание №3:

#include <iostream>
#include <math.h>

int main()
{
	setlocale(LC_ALL, "Rus");
	size_t attempt(0), val(50); // attempt - число попыток, val - начальное число
	double range = ceil(val / 2); // диапазон оставшихся чисел, функция ceil() округляет число до целых к большему
	while (true)
	{
		std::cout << "Это число " << val << '?' << std::endl;
		std::cout << "1 - Больше, 2 - Меньше, 3 - Угадал: ";
		size_t answer; //вариант ответа
		std::cin >> answer;
		switch (answer)
		{
		case 1: val += range; (val >= 100) ? val = 100 : val; break;
		case 2: val -= range; (val > 101) ? val = 0 : val; break; // (val > 101) ? val = 0 : val - чтобы не было переполнения
		case 3: std::cout << "Число было угадано с " << attempt << " попытки" << std::endl; break;
		default: continue;
		}
		++attempt;
		if (answer == 3) // если компьютер угадал число
			break;
		range = ceil(range / 2); // уменьшаем диапазон
	}
	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

#include <iostream>

#include <math.h>

int main()

{

setlocale(LC_ALL, "Rus");

size_t attempt(0), val(50); // attempt - число попыток, val - начальное число

double range = ceil(val / 2); // диапазон оставшихся чисел, функция ceil() округляет число до целых к большему

while (true)

{

std::cout << "Это число " << val << '?' << std::endl;

std::cout << "1 - Больше, 2 - Меньше, 3 - Угадал: ";

size_t answer; //вариант ответа

std::cin >> answer;

switch (answer)

{

case 1: val += range; (val >= 100) ? val = 100 : val; break;

case 2: val -= range; (val > 101) ? val = 0 : val; break; // (val > 101) ? val = 0 : val - чтобы не было переполнения

case 3: std::cout << "Число было угадано с " << attempt << " попытки" << std::endl; break;

default: continue;

}

++attempt;

if (answer == 3) // если компьютер угадал число

break;

range = ceil(range / 2); // уменьшаем диапазон

}

return 0;

}

Ответить

Анастасия:

5 июня 2020 в 15:45

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

#include <iostream>
#include <Windows.h> // для sleep

enum class Prompts {less = 1, guessed, more };

// получаем подсказку от пользователя:
Prompts getUserPrompt()
{
	std::cout << "Задуманное Вами число:\n" << static_cast<unsigned short>(Prompts::less) << " - меньше\n"
	          << static_cast<unsigned short>(Prompts::guessed) << " - угадано\n"
		      << static_cast<unsigned short>(Prompts::more) << " - больше\n";
	unsigned prompt;
	std::cin >> prompt;
	while (std::cin.fail() || (prompt < static_cast<unsigned short>(Prompts::less)) || (prompt > static_cast<unsigned short>(Prompts::more)))
	{
		std::cin.clear();
		std::cin.ignore(32767, '\n');
		std::cout << "Ваш ответ должен быть от " << static_cast<unsigned short>(Prompts::less) << " до " << static_cast<unsigned short>(Prompts::more) << ": ";
		std::cin >> prompt;
	}
	return static_cast<Prompts>(prompt);
}

// цикл игры с одним числом:
void playGame()
{
	const unsigned minNumber{ 0 }; const unsigned maxNumber{ 100 };
	std::cout << "Загадайте целое число от " << minNumber << " до " << maxNumber << ",\n компьютер будет его отгадывать с Вашей помощью...\n";
	Sleep(5000);                                    // даём пользователю время прочитать текст и придумать число

	int min{ minNumber }, max{ maxNumber },         // переменные для ограничений диапазона догадок
		     attempt{ min + ((max - min) / 2) };    // переменная для числа-догадки
	unsigned tryCount{ 0 };                         // счётчик попыток
	bool guessed = false;
	while (!guessed)                                // пока компьютер не угадает число
	{
		++tryCount;
		attempt = min + ((max - min) / 2);          // генерируем число-догадку как середину возможного диапазона
		if ((min == max)||(attempt < min)||(attempt > max))
			break;                                  // если остаётся единственный вариант, или пользователь жульничает, подсказка не нужна
		std::cout << "\nКомпьютер предполагает, что это число " << attempt << std::endl;
		Sleep(1000);                                // даём пользователю время осознать этот факт
		switch (getUserPrompt())                    // получаем подсказку и действуем в зависимости от неё
		{
		case Prompts::less:
			max = attempt - 1;
			break;
		case Prompts::more:
			min = attempt + 1;
			break;
		default:
			guessed = true;
		}
	}
	if ((attempt < min) || (attempt > max))
		std::cout << "Вы загадали число вне диапазона возможных значений!\n";
	else
	    std::cout << "Чтобы отгадать число " << attempt << ", компьютеру понадобилось " << tryCount << " попыток/попытки.\n";
}

int main()
{
	setlocale(LC_CTYPE, "rus");
	playGame();
	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

#include <iostream>

#include <Windows.h> // для sleep

enum class Prompts {less = 1, guessed, more };

// получаем подсказку от пользователя:

Prompts getUserPrompt()

{

std::cout << "Задуманное Вами число:\n" << static_cast<unsigned short>(Prompts::less) << " - меньше\n"

<< static_cast<unsigned short>(Prompts::guessed) << " - угадано\n"

<< static_cast<unsigned short>(Prompts::more) << " - больше\n";

unsigned prompt;

std::cin >> prompt;

while (std::cin.fail() || (prompt < static_cast<unsigned short>(Prompts::less)) || (prompt > static_cast<unsigned short>(Prompts::more)))

{

std::cin.clear();

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

std::cout << "Ваш ответ должен быть от " << static_cast<unsigned short>(Prompts::less) << " до " << static_cast<unsigned short>(Prompts::more) << ": ";

std::cin >> prompt;

}

return static_cast<Prompts>(prompt);

}

// цикл игры с одним числом:

void playGame()

{

const unsigned minNumber{ 0 }; const unsigned maxNumber{ 100 };

std::cout << "Загадайте целое число от " << minNumber << " до " << maxNumber << ",\n компьютер будет его отгадывать с Вашей помощью...\n";

Sleep(5000); // даём пользователю время прочитать текст и придумать число

int min{ minNumber }, max{ maxNumber }, // переменные для ограничений диапазона догадок

attempt{ min + ((max - min) / 2) }; // переменная для числа-догадки

unsigned tryCount{ 0 }; // счётчик попыток

bool guessed = false;

while (!guessed) // пока компьютер не угадает число

{

++tryCount;

attempt = min + ((max - min) / 2); // генерируем число-догадку как середину возможного диапазона

if ((min == max)||(attempt < min)||(attempt > max))

break; // если остаётся единственный вариант, или пользователь жульничает, подсказка не нужна

std::cout << "\nКомпьютер предполагает, что это число " << attempt << std::endl;

Sleep(1000); // даём пользователю время осознать этот факт

switch (getUserPrompt()) // получаем подсказку и действуем в зависимости от неё

{

case Prompts::less:

max = attempt - 1;

break;

case Prompts::more:

min = attempt + 1;

break;

default:

guessed = true;

}

if ((attempt < min) || (attempt > max))

std::cout << "Вы загадали число вне диапазона возможных значений!\n";

else

std::cout << "Чтобы отгадать число " << attempt << ", компьютеру понадобилось " << tryCount << " попыток/попытки.\n";

}

int main()

{

setlocale(LC_CTYPE, "rus");

playGame();

return 0;

}

Ответить

Анастасия:

5 июня 2020 в 14:31

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

#include <iostream>
#include <vector>
#include <cstdlib>   // для функций выбора случайного числа srand() и rand()
#include <ctime>     // чтобы в randomize опираться на время запуска программы
#include <algorithm> // для подключения алгоритмов STL (std::find)

// создаёт массив заданной длины с элементами от 1 до заданного максимального
std::vector<int> createRandomArray(const unsigned length, const int maxNumber)
{
    std::vector<int> array{};
    for (unsigned i = 0; i < length; ++i)
        array.push_back((rand() % maxNumber) + 1);
    return array;
}

// создаёт массив-пересечение двух массивов, содержащий присутствующие и там и там элементы без повторов
std::vector<int> createIntersectionArray(const std::vector<int>& array1, const std::vector<int>& array2)
{
    std::vector<int> arrResult{};

    // лямбда-функция возвращает истину, если элемент присутствует в массиве:
    auto found{ [](const int element, const std::vector<int>& array)
               {return (std::find(array.begin(), array.end(), element) < array.end()); } };
    
    for (const auto& element : array1)
        // ищем элементы первого массива во втором и добавляем в массив-пересечение, если их там ещё нет
        if (found(element, array2) && !found(element, arrResult))
            arrResult.push_back(element);
    
    return arrResult;
}

// печатает элементы переданного вектора через пробел
void printArray(const std::vector<int>& array)
{
    for (const auto& element : array)
        std::cout << element << " ";
    std::cout << std::endl;
}

int main()
{
    srand(static_cast<unsigned int>(time(0)));  // аналог randomize с привязкой ко времени запуска

    const unsigned arraySize{ 20 };             // длина геренируемых массивов
    const int maxElement{ 50 };                 // ограничение на максимальное число в случайном массиве

    std::vector<int> array1{ createRandomArray(arraySize, maxElement) };
    std::cout << "Array 1:\n";
    printArray(array1);

    std::vector<int> array2{ createRandomArray(arraySize, maxElement) };
    std::cout << "Array 2:\n";
    printArray(array2);
    
    std::cout << "Intersection array:\n";
    printArray(createIntersectionArray(array1, array2));

    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

#include <iostream>

#include <vector>

#include <cstdlib> // для функций выбора случайного числа srand() и rand()

#include <ctime> // чтобы в randomize опираться на время запуска программы

#include <algorithm> // для подключения алгоритмов STL (std::find)

// создаёт массив заданной длины с элементами от 1 до заданного максимального

std::vector<int> createRandomArray(const unsigned length, const int maxNumber)

{

std::vector<int> array{};

for (unsigned i = 0; i < length; ++i)

array.push_back((rand() % maxNumber) + 1);

return array;

}

// создаёт массив-пересечение двух массивов, содержащий присутствующие и там и там элементы без повторов

std::vector<int> createIntersectionArray(const std::vector<int>& array1, const std::vector<int>& array2)

{

std::vector<int> arrResult{};

// лямбда-функция возвращает истину, если элемент присутствует в массиве:

auto found{ [](const int element, const std::vector<int>& array)

{return (std::find(array.begin(), array.end(), element) < array.end()); } };

for (const auto& element : array1)

// ищем элементы первого массива во втором и добавляем в массив-пересечение, если их там ещё нет

if (found(element, array2) && !found(element, arrResult))

arrResult.push_back(element);

return arrResult;

}

// печатает элементы переданного вектора через пробел

void printArray(const std::vector<int>& array)

{

for (const auto& element : array)

std::cout << element << " ";

std::cout << std::endl;

}

int main()

{

srand(static_cast<unsigned int>(time(0))); // аналог randomize с привязкой ко времени запуска

const unsigned arraySize{ 20 }; // длина геренируемых массивов

const int maxElement{ 50 }; // ограничение на максимальное число в случайном массиве

std::vector<int> array1{ createRandomArray(arraySize, maxElement) };

std::cout << "Array 1:\n";

printArray(array1);

std::vector<int> array2{ createRandomArray(arraySize, maxElement) };

std::cout << "Array 2:\n";

printArray(array2);

std::cout << "Intersection array:\n";

printArray(createIntersectionArray(array1, array2));

return 0;

}

Ответить

Анастасия:

5 июня 2020 в 14:29

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

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

// возвращает истину, если переданный символ - знак пунктуации
inline bool isPunctuation(const char sign)
{
    switch (sign)
    {
    case '!':
    case '?':
    case '-':
    case ',':
    case '.':
    case ':':
    case ';':
    case '(':
    case ')':
        return true;
    default:
        return false;
    }
}

// печатает переданный текст наоборот, сохраняя слова
void converseString(const std::string& text)
{
    if (text.length() == 0)
        std::cout << "Вы ничего не написали =(\n";
    else
    {
        std::string word{}, result{};
        int counter = text.length() - 1;  // идём от последнего символа до начала строки
        while (counter >= 0)
        {
            while ((text[counter] != ' ') && !isPunctuation(text[counter])) // пока не наткнёмся на пробел или пунктуацию
            {   // добавляем буквы в начало слова
                std::string letter{ text[counter] };
                word.insert(0, letter);
                --counter;
                if (counter < 0) break;  // начало строки, больше нет символов для проверки
            }
            if (word.length())           // есть слово
            {
                result += word;
                word = "";
            }
            else                         // нет слова, то есть текущий символ - пробел или пунктуация
            {
                result += text[counter];
                --counter;
            }
        }
        std::cout << "Результат:\n" << result << std::endl;
    }
}

int main()
{
    SetConsoleCP(1251); SetConsoleOutputCP(1251);

    std::cout << "Программа выводит слова в обратном порядке.\nНапишите что-нибудь:\n";
    std::string text;
    std::getline(std::cin, text);
    converseString(text);

    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

#include <iostream>

#include <Windows.h>

#include <string>

// возвращает истину, если переданный символ - знак пунктуации

inline bool isPunctuation(const char sign)

{

switch (sign)

{

case '!':

case '?':

case '-':

case ',':

case '.':

case ':':

case ';':

case '(':

case ')':

return true;

default:

return false;

}

// печатает переданный текст наоборот, сохраняя слова

void converseString(const std::string& text)

{

if (text.length() == 0)

std::cout << "Вы ничего не написали =(\n";

else

{

std::string word{}, result{};

int counter = text.length() - 1; // идём от последнего символа до начала строки

while (counter >= 0)

{

while ((text[counter] != ' ') && !isPunctuation(text[counter])) // пока не наткнёмся на пробел или пунктуацию

{ // добавляем буквы в начало слова

std::string letter{ text[counter] };

word.insert(0, letter);

--counter;

if (counter < 0) break; // начало строки, больше нет символов для проверки

}

if (word.length()) // есть слово

{

result += word;

word = "";

}

else // нет слова, то есть текущий символ - пробел или пунктуация

{

result += text[counter];

--counter;

}

std::cout << "Результат:\n" << result << std::endl;

}

int main()

{

SetConsoleCP(1251); SetConsoleOutputCP(1251);

std::cout << "Программа выводит слова в обратном порядке.\nНапишите что-нибудь:\n";

std::string text;

std::getline(std::cin, text);

converseString(text);

return 0;

}

Ответить

Анастасия:

5 июня 2020 в 21:54

Мне удалось подключить ispunct для кириллицы благодаря примерам ниже) Вот последняя версия кода для задания №1, можно только её прикрепить:

#include <iostream>
#include <Windows.h>
#include <string>
#include <cctype>                   // для ispunct()

// печатает переданный текст наоборот, сохраняя слова
void converseString(const std::string& text)
{
    if (text.length() == 0)
        std::cout << "Вы ничего не написали =(\n";
    else
    {
        std::string word{}, result{};
        int counter = text.length() - 1;  // идём от последнего символа до начала строки
        while (counter >= 0)
        {
            while ((text[counter] != ' ') && !ispunct(text[counter])) // пока не наткнёмся на пробел или пунктуацию
            {   // добавляем буквы в начало слова
                std::string letter{ text[counter] };
                word.insert(0, letter);
                --counter;
                if (counter < 0) break;  // начало строки, больше нет символов для проверки
            }
            if (word.length())           // есть слово
            {
                result += word;
                word = "";
            }
            else                         // нет слова, то есть текущий символ - пробел или пунктуация
            {
                result += text[counter];
                --counter;
            }
        }
        std::cout << "Результат:\n" << result << std::endl;
    }
}

int main()
{
    setlocale(LC_CTYPE, "rus");                           // как вариант setlocale(0, ""); - чтобы ispunct работало с кириллицей
    SetConsoleCP(1251); SetConsoleOutputCP(1251);

    std::cout << "Программа выводит слова в обратном порядке.\nНапишите что-нибудь:\n";
    std::string text;
    std::getline(std::cin, text);
    converseString(text);

    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

#include <iostream>

#include <Windows.h>

#include <string>

#include <cctype> // для ispunct()

// печатает переданный текст наоборот, сохраняя слова

void converseString(const std::string& text)

{

if (text.length() == 0)

std::cout << "Вы ничего не написали =(\n";

else

{

std::string word{}, result{};

int counter = text.length() - 1; // идём от последнего символа до начала строки

while (counter >= 0)

{

while ((text[counter] != ' ') && !ispunct(text[counter])) // пока не наткнёмся на пробел или пунктуацию

{ // добавляем буквы в начало слова

std::string letter{ text[counter] };

word.insert(0, letter);

--counter;

if (counter < 0) break; // начало строки, больше нет символов для проверки

}

if (word.length()) // есть слово

{

result += word;

word = "";

}

else // нет слова, то есть текущий символ - пробел или пунктуация

{

result += text[counter];

--counter;

}

std::cout << "Результат:\n" << result << std::endl;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // как вариант setlocale(0, ""); - чтобы ispunct работало с кириллицей

SetConsoleCP(1251); SetConsoleOutputCP(1251);

std::cout << "Программа выводит слова в обратном порядке.\nНапишите что-нибудь:\n";

std::string text;

std::getline(std::cin, text);

converseString(text);

return 0;

}

Ответить

Shom:

4 мая 2020 в 11:18

Задание №3.

// Linux Mint 18.3, g++-7, c++17, IDE "CodeLite";  
  
#include <iostream>
//#include <windows.h>                          // Раскоментировать для подключения 
                                                //  кириллицы в Windows; 

int main()
{  
    //SetConsoleCP(1251);                         // Пользователям Windows для подключения
    //SetConsoleOutputCP(1251);                   //   кириллицы раскоментировать эти две строки;
    
    std::cout << "       *** Программа угадывает число. ***\n\n"; 
    
    std::cout << "Загадайте число от 0 до 100.\n\n";
    std::cout << "Клавиши управления:\n"
                 "  '1' - слишком большое\n"
                 "  '2' - слишком маленькое\n"
                 "  '3' - Правильно, угадал!\n\n";
    
    int num{50};                                  // Предпологаемое число;
    int numOld{100};                              // Предыдущее предпологаемое число; 
    int val;                                      // Шаг перемещения;
    char answer;                                  // Значение последней нажатой клавиши управления;
    bool key{true};                               // Переменная для прерывания главного цикла;
    size_t count{0};                              // Счётчик попыток;
    
    while (key)                                   // Главный цикл программы; 
    {    
        std::cout << "Вы загадали " << num << "?  ";      // Выводим предпологаемое число;
        ++count;                                  // Увеличиваем счётчик предположений на единицу;
        
        while (1)                                 // Валидация пользовательского ввода; 
        {            
             std::cin  >> answer;                 // Запрашиваем ответ у пользователя;
             if (answer == '1' || answer == '2' || answer == '3') break;  // Прерываем цикл, если ответ
             std::cout << "Некорректный ответ. Повторите попытку:  ";     //     устраивает;
        }
                
        val = abs((numOld - num)/2);              // Вычисляем шаг перемещения по диапазону чисел;  
        numOld = num;                             // Сохраняем прошлое предпологаемое число;
        switch (answer)                           // Анализируем ответ пользователя;
        {
            case '1': num -= val;                 // Уменьшаем предпологаемое число;
                      if (num == numOld) --num;   // Для перемещения в наименьшем диапозоне;
                      break;
            case '2': num += val;                 // Увеличиваем предпологаемое число;
                      if (num == numOld) ++num;
                      break; 
            case '3': key = false;                // Изменяем значение переменной для выхода из 
                      break;                      //   основного цикла программы;
            default : break;           
        }        
    }
    
    std::cout << "\nЧисло было угадано с " << count << "-й попытки.\n\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

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

// Linux Mint 18.3, g++-7, c++17, IDE "CodeLite";

#include <iostream>

//#include <windows.h> // Раскоментировать для подключения

// кириллицы в Windows;

int main()

{

//SetConsoleCP(1251); // Пользователям Windows для подключения

//SetConsoleOutputCP(1251); // кириллицы раскоментировать эти две строки;

std::cout << " *** Программа угадывает число. ***\n\n";

std::cout << "Загадайте число от 0 до 100.\n\n";

std::cout << "Клавиши управления:\n"

" '1' - слишком большое\n"

" '2' - слишком маленькое\n"

" '3' - Правильно, угадал!\n\n";

int num{50}; // Предпологаемое число;

int numOld{100}; // Предыдущее предпологаемое число;

int val; // Шаг перемещения;

char answer; // Значение последней нажатой клавиши управления;

bool key{true}; // Переменная для прерывания главного цикла;

size_t count{0}; // Счётчик попыток;

while (key) // Главный цикл программы;

{

std::cout << "Вы загадали " << num << "? "; // Выводим предпологаемое число;

++count; // Увеличиваем счётчик предположений на единицу;

while (1) // Валидация пользовательского ввода;

{

std::cin >> answer; // Запрашиваем ответ у пользователя;

if (answer == '1' || answer == '2' || answer == '3') break; // Прерываем цикл, если ответ

std::cout << "Некорректный ответ. Повторите попытку: "; // устраивает;

}

val = abs((numOld - num)/2); // Вычисляем шаг перемещения по диапазону чисел;

numOld = num; // Сохраняем прошлое предпологаемое число;

switch (answer) // Анализируем ответ пользователя;

{

case '1': num -= val; // Уменьшаем предпологаемое число;

if (num == numOld) --num; // Для перемещения в наименьшем диапозоне;

break;

case '2': num += val; // Увеличиваем предпологаемое число;

if (num == numOld) ++num;

break;

case '3': key = false; // Изменяем значение переменной для выхода из

break; // основного цикла программы;

default : break;

}

std::cout << "\nЧисло было угадано с " << count << "-й попытки.\n\n";

return 0;

}

Ответить

Анастасия:

6 июня 2020 в 12:27

у Вас нет проверки адекватности пользователя, то есть он мог загадать что-то вне рамок диапазона, у Вас после 100 и до 0 программа работает как перебор всех подряд значений, а нужно это пресекать с вердиктом. И ещё не очень хорошо, что нет гибкости для изменения данных задачи — 0, 100, 50 фигурируют как магические числа.
Но в целом работать с программой приятно, мне понравилось вот это "Вы загадали?", я как-то не додумалась до такой ёмкой фразы.

Ответить
1. Shom:
  
  18 июня 2020 в 10:17
  
  Спасибо за комментарий! Всё верно: даже за рамками оговоренных правил игры программа продолжает работать. Медленно, но продолжает)
  Согласен, если по-серёзному делать, то числа диапазона вариантов надо было вынести в константы. Но так-ка программа маленькая, то решил, что комментариев будет достаточно для определения их предназначения.
  
  Ответить

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

Easy: Задание №1

Medium: Задание №2

Hard: Задание №3

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