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

Обновл. 16 Сен 2021 |

24739

ǀ 45

Здесь размещены задания по С++, которые вы можете выполнить. Каждое задание имеет свой уровень сложности. Готовых ответов не будет, поэтому welcome в комментарии!

Оглавление:

Задание №1
Задание №2
Задание №3

Easy: Задание №1

Напишите программу, которая вычисляет дату следующего дня.

Пример результата выполнения программы:

Введите цифрами дату (число месяц год): 31 12 2018 Последний день месяца! Завтра 01.01.2019

Medium: Задание №2

Напишите программу, которая конвертирует введенное пользователем десятичное число в шестнадцатеричную систему счисления.

Hard: Задание №3

В игру «100 спичек» вы играете с компьютером. Из кучки, первоначально содержащей 100 спичек, двое играющих поочередно берут по несколько спичек: не менее одной и не более десяти. Проигрывает тот, кто взял последнюю спичку. Количество спичек, которое берет компьютер, определите с помощью генерации случайных чисел.

Оценить статью:

(19 оценок, среднее: 4,79 из 5)

Загрузка...

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

Finchi:

2 сентября 2022 в 13:23

Задание №1

#include <iostream>
#include <string>
class Date
{
public:
	Date(int day, int month, int year)
		: m_day(day), m_month(month), m_year(year)
	{}
	void get_date()
	{
		real_date();
		std::string s_day = std::to_string(m_day), s_month = std::to_string(m_month), s_year = std::to_string(m_year);
		if (m_day < 10)
			s_day.insert(s_day.begin(), '0');
		if (m_month < 10)
			s_month.insert(s_month.begin(), '0');
		std::cout << s_day << '.' << s_month << '.' << s_year;
	}
private:
	int m_day, m_month, m_year;
	void real_date()
	{
		while (m_day > 31 && (m_month == 1 || m_month == 3 || m_month == 5 || m_month == 7
			|| m_month == 8 || m_month == 10 || m_month == 12))
		{
			m_day -= 31;
			m_month++;
		}
		while (m_day > 30 && (m_month == 4 || m_month == 6 || m_month == 9 || m_month == 11))
		{
			m_day -= 30;
			m_month++;
		}
		while (m_day > 28 && m_month == 2 && !is_leap_current())
		{
			m_day -= 28;
			m_month++;
		}
		while (m_day > 29 && m_month == 2 && is_leap_current())
		{
			m_day -= 29;
			m_month++;
		}
		while (m_month > 12)
		{
			m_month -= 12;
			m_year++;
		}
		if (!(((m_day <= 31 && (m_month == 1 || m_month == 3 || m_month == 5 || m_month == 7
			|| m_month == 8 || m_month == 10 || m_month == 12)) || (m_day <= 30 && (m_month == 4 || m_month == 6 || m_month == 9
				|| m_month == 11)) || (m_day <= 28 && m_month == 2 && !is_leap_current()) || (m_day <= 29 && m_month == 2
					&& is_leap_current())) && (m_month <= 12)))
			real_date();
	}
	bool is_leap_current()
	{
		return(m_year % 400 == 0 || (m_year % 100 != 0 && m_year % 4 == 0));
	}
};
int main()
{
	setlocale(LC_ALL, "russian");
	std::cout << "Введите дату (dd mm yyyy): ";
	std::string s_day, s_month, s_year;
	std::cin >> s_day;
	std::cin >> s_month;
	std::cin >> s_year;
	int day = std::stoi(s_day), month = std::stoi(s_month), year = std::stoi(s_year);
	int next_day = day + 1;
	std::cout << "Дата следующего дня: ";
	Date tommorow(next_day, month, year);
	tommorow.get_date();
	return 0;
}

#include <iostream>

#include <string>

class Date

{

public:

Date(int day, int month, int year)

: m_day(day), m_month(month), m_year(year)

{}

void get_date()

{

real_date();

std::string s_day = std::to_string(m_day), s_month = std::to_string(m_month), s_year = std::to_string(m_year);

if (m_day < 10)

s_day.insert(s_day.begin(), '0');

if (m_month < 10)

s_month.insert(s_month.begin(), '0');

std::cout << s_day << '.' << s_month << '.' << s_year;

}

private:

int m_day, m_month, m_year;

void real_date()

{

while (m_day > 31 && (m_month == 1 || m_month == 3 || m_month == 5 || m_month == 7

|| m_month == 8 || m_month == 10 || m_month == 12))

{

m_day -= 31;

m_month++;

}

while (m_day > 30 && (m_month == 4 || m_month == 6 || m_month == 9 || m_month == 11))

{

m_day -= 30;

m_month++;

}

while (m_day > 28 && m_month == 2 && !is_leap_current())

{

m_day -= 28;

m_month++;

}

while (m_day > 29 && m_month == 2 && is_leap_current())

{

m_day -= 29;

m_month++;

}

while (m_month > 12)

{

m_month -= 12;

m_year++;

}

if (!(((m_day <= 31 && (m_month == 1 || m_month == 3 || m_month == 5 || m_month == 7

|| m_month == 8 || m_month == 10 || m_month == 12)) || (m_day <= 30 && (m_month == 4 || m_month == 6 || m_month == 9

|| m_month == 11)) || (m_day <= 28 && m_month == 2 && !is_leap_current()) || (m_day <= 29 && m_month == 2

&& is_leap_current())) && (m_month <= 12)))

real_date();

}

bool is_leap_current()

{

return(m_year % 400 == 0 || (m_year % 100 != 0 && m_year % 4 == 0));

}

};

int main()

{

setlocale(LC_ALL, "russian");

std::cout << "Введите дату (dd mm yyyy): ";

std::string s_day, s_month, s_year;

std::cin >> s_day;

std::cin >> s_month;

std::cin >> s_year;

int day = std::stoi(s_day), month = std::stoi(s_month), year = std::stoi(s_year);

int next_day = day + 1;

std::cout << "Дата следующего дня: ";

Date tommorow(next_day, month, year);

tommorow.get_date();

return 0;

}

Задание №2

#include <iostream>
#include <string>
#include <algorithm>
std::string to_hex(int dec)
{
	std::string result;
	while (dec != 0)
	{
		int modulo = dec % 16;
		dec /= 16;
		switch (modulo)
		{
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
		case 6:
		case 7:
		case 8:
		case 9:
			result += std::to_string(modulo);
			break;
		case 10:
			result += 'A';
			break;
		case 11:
			result += 'B';
			break;
		case 12:
			result += 'C';
			break;
		case 13:
			result += 'D';
			break;
		case 14:
			result += 'E';
			break;
		case 15:
			result += 'F';
			break;
		default:
			std::cout << "Ошибка в std::string to_hex(int dec)\n";
			exit(0);
			break;
		}
	}
	std::reverse(result.begin(), result.end());
	return result;
}
int main()
{
	setlocale(LC_ALL, "russian");
	std::cout << "Введите десятичное число: ";
	int number;
	std::cin >> number;
	std::cout << "Шестнадцатеричное число: " << to_hex(number);
	return 0;
}

#include <iostream>

#include <string>

#include <algorithm>

std::string to_hex(int dec)

{

std::string result;

while (dec != 0)

{

int modulo = dec % 16;

dec /= 16;

switch (modulo)

{

case 0:

case 1:

case 2:

case 3:

case 4:

case 5:

case 6:

case 7:

case 8:

case 9:

result += std::to_string(modulo);

break;

case 10:

result += 'A';

break;

case 11:

result += 'B';

break;

case 12:

result += 'C';

break;

case 13:

result += 'D';

break;

case 14:

result += 'E';

break;

case 15:

result += 'F';

break;

default:

std::cout << "Ошибка в std::string to_hex(int dec)\n";

exit(0);

break;

}

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

return result;

}

int main()

{

setlocale(LC_ALL, "russian");

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

int number;

std::cin >> number;

std::cout << "Шестнадцатеричное число: " << to_hex(number);

return 0;

}

Задание №3

#include <iostream>
#include <random>
class Matches
{
public:
	Matches() = default;
	void play()
	{
		std::cout << "Игра началась, изначально 100 спичек.\nПервый ход ваш.\n";
		do
		{
			int take_matches;
			do
			{
				std::cout << "Введите количество спичек, которое хотите взять (1-10): ";
				std::cin >> take_matches;
			} while (take_matches < 1 || take_matches > 10);
			m_matches -= take_matches;
			if(m_matches<=0)
			{
				std::cout << "Вы проиграли!\n";
				break;
			}
			std::cout << "Теперь ход компьютера...\n";
			std::mt19937 mercene_vortex(std::random_device{}());
			take_matches = 1 + mercene_vortex() % 10;
			m_matches -= take_matches;
			if (m_matches <= 0)
			{
				std::cout << "Вы выиграли!\n";
				break;
			}
		} while (m_matches > 0);
		play_again();
	}
private:
	int m_matches = 100;
	void play_again()
	{
		char choise;
		do
		{
			std::cout << "Хотите сыграть еще раз? (y/n): ";
			std::cin >> choise;
			std::cin.clear();
			std::cin.ignore(32767, '\n');
		} while (choise!='y' && choise!='n');
		if (choise == 'y')
		{
			m_matches = 100;
			play();
		}
		else
			exit(0);
	}
};
int main()
{
	setlocale(LC_ALL, "russian");
	Matches().play();
	return 0;
}

#include <iostream>

#include <random>

class Matches

{

public:

Matches() = default;

void play()

{

std::cout << "Игра началась, изначально 100 спичек.\nПервый ход ваш.\n";

{

int take_matches;

{

std::cout << "Введите количество спичек, которое хотите взять (1-10): ";

std::cin >> take_matches;

} while (take_matches < 1 || take_matches > 10);

m_matches -= take_matches;

if(m_matches<=0)

{

std::cout << "Вы проиграли!\n";

break;

}

std::cout << "Теперь ход компьютера...\n";

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

take_matches = 1 + mercene_vortex() % 10;

m_matches -= take_matches;

if (m_matches <= 0)

{

std::cout << "Вы выиграли!\n";

break;

}

} while (m_matches > 0);

play_again();

}

private:

int m_matches = 100;

void play_again()

{

char choise;

{

std::cout << "Хотите сыграть еще раз? (y/n): ";

std::cin >> choise;

std::cin.clear();

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

} while (choise!='y' && choise!='n');

if (choise == 'y')

{

m_matches = 100;

play();

}

else

exit(0);

}

};

int main()

{

setlocale(LC_ALL, "russian");

Matches().play();

return 0;

}

Ответить

Dmitry:

1 сентября 2022 в 12:09

Задание №3:

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

using namespace std;

class Play
{
private:
	bool b = true;
	int matches = 100;

private:

	void getMatchesPlayear()
	{
	a:
		cout << "Сколько спичек возьмешь?\n";
		int mach;
		cin >> mach;
			if (cin.fail() || mach <= 0 || mach > 10 || mach > matches)
			{
				cin.clear();
				cin.ignore(32767, '\n');
				cerr << "Чтото не так, попробуй еще!\n";
				goto a;
			}

		matches -= mach;

		if (matches == 0)
		{
			cout << "Ты проиграл! \n";
		}

		else
		{
			cout << "Осталось " << matches << " спичек.\n";
		}
	}

	void getMatchesBOT()
	{
		int machBOT;

		if (matches > 10)
		{
			machBOT = 1 + rand() % 10;
		}
		else if (matches < 10)
		{
			machBOT = 1 + rand() % matches - 1;
		}

		cout << "Компютер взял " << machBOT << " спичек.\n";

		matches -= machBOT;

		if (matches == 0)
		{
			cout << "Компютер проиграл! \n";
		}

		else
		{
			cout << "Осталось " << matches << " спичек.\n";
		}
	}

public:
	void game()
	{

		cout << "*******100 СПИЧЕК******** \n\n";

		cout << "Двое играющих поочередно берут по несколько спичек : не менее одной и не более десяти.\n" <<
			"Проигрывает тот, кто взял последнюю спичку.\n\n";

		while (matches > 0)
		{
			if (b == true)
			{
				getMatchesPlayear();
				b = false;
			}
			else
			{
				getMatchesBOT();
				b = true;
			}
		}

		cout << "Сиграем еще разок? (Y/N)\n";
		char a;
		cin >> a;
		if (a == 'Y' || a == 'y')
		{
			matches = 100;
			system("cls");
			game();
		}		
	}
};

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

	srand(time(0));

	Play game;
	
	game.game();

	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

#include <iostream>

#include <random>

#include <Windows.h>

using namespace std;

class Play

{

private:

bool b = true;

int matches = 100;

private:

void getMatchesPlayear()

{

cout << "Сколько спичек возьмешь?\n";

int mach;

cin >> mach;

if (cin.fail() || mach <= 0 || mach > 10 || mach > matches)

{

cin.clear();

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

cerr << "Чтото не так, попробуй еще!\n";

goto a;

}

matches -= mach;

if (matches == 0)

{

cout << "Ты проиграл! \n";

}

else

{

cout << "Осталось " << matches << " спичек.\n";

}

void getMatchesBOT()

{

int machBOT;

if (matches > 10)

{

machBOT = 1 + rand() % 10;

}

else if (matches < 10)

{

machBOT = 1 + rand() % matches - 1;

}

cout << "Компютер взял " << machBOT << " спичек.\n";

matches -= machBOT;

if (matches == 0)

{

cout << "Компютер проиграл! \n";

}

else

{

cout << "Осталось " << matches << " спичек.\n";

}

public:

void game()

{

cout << "*******100 СПИЧЕК******** \n\n";

cout << "Двое играющих поочередно берут по несколько спичек : не менее одной и не более десяти.\n" <<

"Проигрывает тот, кто взял последнюю спичку.\n\n";

while (matches > 0)

{

if (b == true)

{

getMatchesPlayear();

b = false;

}

else

{

getMatchesBOT();

b = true;

}

cout << "Сиграем еще разок? (Y/N)\n";

char a;

cin >> a;

if (a == 'Y' || a == 'y')

{

matches = 100;

system("cls");

game();

}

};

int main()

{

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

srand(time(0));

Play game;

game.game();

return 0;

}

Ответить

WAR:

6 сентября 2021 в 19:01

Задание №3:

#ifdef _WIN32
#include <Windows.h>
#else
#include <unistd.h>
#endif
#include <iostream>
#include <ctime>
#include <string>

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

int input(std::string &s, int min, int max) {
    int n{0};
    while(n < min || n > max) {
        std::cout << s;
        std::cin >> n;
        if(std::cin.fail()) {
            std::cin.clear();
            std::cin.ignore(32767, '\n');
            std::cout << "Error! Invalid input! Repeat input!\n";
        }
    }
    return n;
}

int main() {
    std::cout << "Hello! This game - Matchsticks!";
    srand((time(NULL)));
    getRandom();
    std::string str{"\nEnter amount matchsticks (least 20 and not more 100): "};
    int matchsticks = input(str, 20, 100);
    int takeP{0}, takeC{0};
    bool actP{false}, actC{false};
    int who = getRandom();
    who % 2 == 0 ? actP = true : actC = true;
    str = "\n\nEnter number from 1 until 10: ";
    while(true) {
        Sleep(3000);
        system("cls");
        if(actP) {
            takeP = input(str, 1, 10);
            matchsticks -= takeP;
            if(matchsticks < 1) matchsticks = 0;
            std::cout << "\nYou take: " << takeP << " matchsticks";
            std::cout << "\nMatchsticks left: " << matchsticks;
            if(matchsticks < 1) break;
            actP = false; actC = true;
        }
        if(actC) {
            takeC = getRandom();
            matchsticks -= takeC;
            if(matchsticks < 1) matchsticks = 0;
            std::cout << "\nComputer take: " << takeC << " matchsticks";
            std::cout << "\nMatchsticks left: " << matchsticks;
            if(matchsticks < 1) break;
            actC = false; actP = true;
        }
    }
    actC ? std::cout << "\n\nGame over! You won!" :
           std::cout << "\n\nGame over! Computer won!";
    std::cout << "\n\n";
    system("pause");
    return 0;
}

#ifdef _WIN32

#include <Windows.h>

#else

#include <unistd.h>

#endif

#include <iostream>

#include <ctime>

#include <string>

int getRandom(int min = 1, int max = 10) {

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

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

}

int input(std::string &s, int min, int max) {

int n{0};

while(n < min || n > max) {

std::cout << s;

std::cin >> n;

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

std::cin.clear();

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

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

}

return n;

}

int main() {

std::cout << "Hello! This game - Matchsticks!";

srand((time(NULL)));

getRandom();

std::string str{"\nEnter amount matchsticks (least 20 and not more 100): "};

int matchsticks = input(str, 20, 100);

int takeP{0}, takeC{0};

bool actP{false}, actC{false};

int who = getRandom();

who % 2 == 0 ? actP = true : actC = true;

str = "\n\nEnter number from 1 until 10: ";

while(true) {

Sleep(3000);

system("cls");

if(actP) {

takeP = input(str, 1, 10);

matchsticks -= takeP;

if(matchsticks < 1) matchsticks = 0;

std::cout << "\nYou take: " << takeP << " matchsticks";

std::cout << "\nMatchsticks left: " << matchsticks;

if(matchsticks < 1) break;

actP = false; actC = true;

}

if(actC) {

takeC = getRandom();

matchsticks -= takeC;

if(matchsticks < 1) matchsticks = 0;

std::cout << "\nComputer take: " << takeC << " matchsticks";

std::cout << "\nMatchsticks left: " << matchsticks;

if(matchsticks < 1) break;

actC = false; actP = true;

}

actC ? std::cout << "\n\nGame over! You won!" :

std::cout << "\n\nGame over! Computer won!";

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

system("pause");

return 0;

}

Ответить

WAR:

5 сентября 2021 в 17:31

Задание №1:

#include <iostream>
#include <string>

void input(int *arr, int &day, int &month, int &year) {
	bool ok = false;
	while (!ok) {
		std::cout << "Enter digits (day, month and year): ";
		std::cin >> day >> month >> year;
		if (std::cin.fail()) {
			std::cin.clear();
			std::cin.ignore(32767, '\n');
			std::cout << "Error! Invalid input! Repeat input!\n";
		}
		(year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) ? arr[1] = 29 : arr[1] = 28;
		if (day < 1 || day > 31) std::cout << "Day not can be less 1 and more 31!\n";
		else if (month < 1 || month > 12) std::cout << "Month not can be less 1 and more 12!\n";
		else if (day > arr[month-1]) std::cout << "In this month days not can be more " << arr[month-1] << "!\n";
		else ok = true;
	}
}

int main()
{
	int mD[]{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
	int d{ 0 }, m{ 0 }, y{ 0 };
	input(mD, d, m, y);
	std::cout << d << ' ' << m << ' ' << y << '\n';
	bool last_d{ false };
	if (d == mD[m-1]) {
		if (m == 12) { d = m = 1; ++y; }
		else { d = 1; ++m; }
		last_d = true;
	}
	else ++d;

	std::string str_d, str_m;
	d < 10 ? str_d = "0" + std::to_string(d) : str_d = std::to_string(d);
	m < 10 ? str_m = "0" + std::to_string(m) : str_m = std::to_string(m);

	last_d ? std::cout << "Last day month! Tomorrow: " << str_d << "." << str_m << "." << y << std::endl :
			 std::cout << "Tomorrow: " << str_d << "." << str_m << "." << y << std::endl;
	std::cout << '\n';
	system("pause");
    return 0;
}

#include <iostream>

#include <string>

void input(int *arr, int &day, int &month, int &year) {

bool ok = false;

while (!ok) {

std::cout << "Enter digits (day, month and year): ";

std::cin >> day >> month >> year;

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

std::cin.clear();

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

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

}

(year % 400 == 0 || (year % 4 == 0 && year % 100 != 0)) ? arr[1] = 29 : arr[1] = 28;

if (day < 1 || day > 31) std::cout << "Day not can be less 1 and more 31!\n";

else if (month < 1 || month > 12) std::cout << "Month not can be less 1 and more 12!\n";

else if (day > arr[month-1]) std::cout << "In this month days not can be more " << arr[month-1] << "!\n";

else ok = true;

}

int main()

{

int mD[]{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

int d{ 0 }, m{ 0 }, y{ 0 };

input(mD, d, m, y);

std::cout << d << ' ' << m << ' ' << y << '\n';

bool last_d{ false };

if (d == mD[m-1]) {

if (m == 12) { d = m = 1; ++y; }

else { d = 1; ++m; }

last_d = true;

}

else ++d;

std::string str_d, str_m;

d < 10 ? str_d = "0" + std::to_string(d) : str_d = std::to_string(d);

m < 10 ? str_m = "0" + std::to_string(m) : str_m = std::to_string(m);

last_d ? std::cout << "Last day month! Tomorrow: " << str_d << "." << str_m << "." << y << std::endl :

std::cout << "Tomorrow: " << str_d << "." << str_m << "." << y << std::endl;

std::cout << '\n';

system("pause");

return 0;

}

Ответить

WAR:

3 сентября 2021 в 12:41

Задание №2 (исправил ошибку с выводом введенного номера):

#include <iostream>
#include <string>

int input() {
    int n{-1};
    while(n < 0) {
        std::cout<<"\nEnter number: ";
        std::cin >> n;
        if(std::cin.fail()) {
            std::cin.clear();
            std::cin.ignore(32767, '\n');
            n = -1;
            std::cout << "Error! Invalid input! Repeat input!\n";
        }
    }
    return n;
}

int main() {
    //std::cout << "Hello, world!\n";
    char ch = '0';
    char arr[16];
    int count{-1};
    while(++count < 16) {
        if(count == 10) ch = 'A';
        arr[count] = ch;
        ++ch;
    }
    for(char i : arr) std::cout << i << ' ';
    int num = input();
    if(num == 0) std::cout << "Number " << num << " in hex is: " << num;
    else {
        std::string hex;
        int ind;
        int num2 = num;
        while(num > 0) {
            ind = num % 16;
            hex.insert(0, 1, arr[ind]);
            num /= 16;
        }
        std::cout << "Number " << num2 << " in hex is: " << hex;
    }
    std::cout << "\n\n";
    system("pause");
    return 0;
}

#include <iostream>

#include <string>

int input() {

int n{-1};

while(n < 0) {

std::cout<<"\nEnter number: ";

std::cin >> n;

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

std::cin.clear();

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

n = -1;

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

}

return n;

}

int main() {

//std::cout << "Hello, world!\n";

char ch = '0';

char arr[16];

int count{-1};

while(++count < 16) {

if(count == 10) ch = 'A';

arr[count] = ch;

++ch;

}

for(char i : arr) std::cout << i << ' ';

int num = input();

if(num == 0) std::cout << "Number " << num << " in hex is: " << num;

else {

std::string hex;

int ind;

int num2 = num;

while(num > 0) {

ind = num % 16;

hex.insert(0, 1, arr[ind]);

num /= 16;

}

std::cout << "Number " << num2 << " in hex is: " << hex;

}

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

system("pause");

return 0;

}

Ответить

Rock:

31 марта 2021 в 11:44

Задание 1:

#include<iostream>

void next_day(int day, int month, int year);

void write_date_again()
{
	std::cout << "Вы ввели что то не так повторите ввод данных (число месяц год):";

	int day, month, year;
	std::cin >> day >> month >> year;

	next_day(day, month, year);
}

void next_day(int day, int month, int year)
{


	bool last_day = false;
	int max_day;
	switch (month)
	{
	case 1:  max_day = 31; break;
	case 2:  year % 4 != 0 ? max_day = 28 : max_day = 29; break;
	case 3:  max_day = 31; break;
	case 4:  max_day = 30; break;
	case 5:  max_day = 31; break;
	case 6:  max_day = 30; break;
	case 7:  max_day = 31; break;
	case 8:  max_day = 31; break;
	case 9:  max_day = 30; break;
	case 10: max_day = 31; break;
	case 11: max_day = 30; break;
	case 12: max_day = 31; break;
	default: write_date_again(); return;
	}

	if (day > max_day||day<0)
	{
		write_date_again();
		return;
	}


	if (day == max_day)
	{
		if (month == 12) { day = 1; month = 1; year++;  }
		else { day = 1; month++; year++; }
		last_day = true;
	}
	else
	{
		
		day++; 

	}

	if (last_day)
	{
		std::cout <<"Последний день месяца! "<< "Завтра " << day << "." << month << "." << year << std::endl;
	}
	else
	{
		std::cout << "Завтра " << day << "." << month << "." << year << std::endl;
	}
}

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

	int day, month, year;

	std::cout << "Введите цифрами дату (число месяц год):";
	std::cin >> day >> month>> year;

	next_day(day, month, year);
	
	return 0;
}

#include<iostream>

void next_day(int day, int month, int year);

void write_date_again()

{

std::cout << "Вы ввели что то не так повторите ввод данных (число месяц год):";

int day, month, year;

std::cin >> day >> month >> year;

next_day(day, month, year);

}

void next_day(int day, int month, int year)

{

bool last_day = false;

int max_day;

switch (month)

{

case 1: max_day = 31; break;

case 2: year % 4 != 0 ? max_day = 28 : max_day = 29; break;

case 3: max_day = 31; break;

case 4: max_day = 30; break;

case 5: max_day = 31; break;

case 6: max_day = 30; break;

case 7: max_day = 31; break;

case 8: max_day = 31; break;

case 9: max_day = 30; break;

case 10: max_day = 31; break;

case 11: max_day = 30; break;

case 12: max_day = 31; break;

default: write_date_again(); return;

}

if (day > max_day||day<0)

{

write_date_again();

return;

}

if (day == max_day)

{

if (month == 12) { day = 1; month = 1; year++; }

else { day = 1; month++; year++; }

last_day = true;

}

else

{

day++;

}

if (last_day)

{

std::cout <<"Последний день месяца! "<< "Завтра " << day << "." << month << "." << year << std::endl;

}

else

{

std::cout << "Завтра " << day << "." << month << "." << year << std::endl;

}

int main()

{

setlocale(0, "");

int day, month, year;

std::cout << "Введите цифрами дату (число месяц год):";

std::cin >> day >> month>> year;

next_day(day, month, year);

return 0;

}

Задание 2:

#include<iostream>
#include<sstream>

std::string intropritator(long long mod);

void convert_to_HEX(long long x,std::string & HEX)
{
	long long result, modulo;

	if (x > 16 || x < 0)
	{
		result = x / 16;
		modulo = x % 16;

		HEX += intropritator(modulo); // получаем 16-е значение

		if (result > 15)  // проверка на то нужно ли общетать число дальше
			convert_to_HEX(result, HEX); // рекурсивное вычисление
		else
		{
			HEX += intropritator(result); // если рекурсия не нужна то последний результат деления становится частью числа через интерпретатор

			for (int i = 0; i < HEX.size() / 2; i++) // зеркальное отоброжение чилса ибо конкатенация записывает его в обратном порядке
			{
				std::swap(HEX[i], HEX[HEX.size() - i - 1]);
			}
		}
	}
	else
		if (x > 0)
			HEX += intropritator(x); // если число меньше 16 то никаких действий выполнять не надо
		else
			std::cout << "Вводите положительные числа!";
	
}

std::string intropritator(long long mod)
{
	std::ostringstream ost;

	switch (mod)
	{
	case 0:
	case 1:
	case 2:
	case 3:
	case 4:
	case 5:
	case 6:
	case 7:
	case 8:
	case 9:ost << mod; return ost.str();

	case 10: return "A";
	case 11: return "B";
	case 12: return "C";
	case 13: return "D";
	case 14: return "E";
	case 15: return "F";
	default: std::cerr << "Что то пошло не так!";
		return "Error";
	}
}

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

	std::string HEX;
	int number;

	std::cout << "Введите число для получения его в шестнадцатиричном виде: ";
	std::cin >> number;

	convert_to_HEX(number, HEX);

	std::cout << HEX;

	return 0;
}

#include<iostream>

#include<sstream>

std::string intropritator(long long mod);

void convert_to_HEX(long long x,std::string & HEX)

{

long long result, modulo;

if (x > 16 || x < 0)

{

result = x / 16;

modulo = x % 16;

HEX += intropritator(modulo); // получаем 16-е значение

if (result > 15) // проверка на то нужно ли общетать число дальше

convert_to_HEX(result, HEX); // рекурсивное вычисление

else

{

HEX += intropritator(result); // если рекурсия не нужна то последний результат деления становится частью числа через интерпретатор

for (int i = 0; i < HEX.size() / 2; i++) // зеркальное отоброжение чилса ибо конкатенация записывает его в обратном порядке

{

std::swap(HEX[i], HEX[HEX.size() - i - 1]);

}

else

if (x > 0)

HEX += intropritator(x); // если число меньше 16 то никаких действий выполнять не надо

else

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

}

std::string intropritator(long long mod)

{

std::ostringstream ost;

switch (mod)

{

case 0:

case 1:

case 2:

case 3:

case 4:

case 5:

case 6:

case 7:

case 8:

case 9:ost << mod; return ost.str();

case 10: return "A";

case 11: return "B";

case 12: return "C";

case 13: return "D";

case 14: return "E";

case 15: return "F";

default: std::cerr << "Что то пошло не так!";

return "Error";

}

int main()

{

setlocale(0, "");

std::string HEX;

int number;

std::cout << "Введите число для получения его в шестнадцатиричном виде: ";

std::cin >> number;

convert_to_HEX(number, HEX);

std::cout << HEX;

return 0;

}

Задание 3:

Поведение бота не рандомно я прописал ему некий интеллект

#include<iostream>
#include<ctime>


class Game
{
private:

	 int match = 100;
	 int winner;


	 void game_info()
	 {
		 std::cout << "Вас приветствует игра 100 спичек, ваша задача брать с компьютером по очереди спички из кучи.\n" <<
			 "Брать вы можете по 1-10 спичек за раз. Кто возьмет последнюю спичку тот и проиграл!\n";
		 system("pause");
		 system("cls<NUL");
	 }

	
	 void Player_get_match()
	 {
		 winner = 0;
		 int get_match;
		 std::cout << "Напишите сколько вы хотите взять спичек из кучи (1-10) :";
		 std::cin >> get_match;

		 if (get_match > 10 || get_match <= 0)
		 {
			 system("cls<NUL");
			 std::cout << "Вы ввели неверное число! Повторите ввод"<<std::endl;
			 Player_get_match();
			 return;
		 }
		 if (get_match > match)
		 {
			 system("cls<NUL");
			 std::cout << "Столько спичек в кучке нету! Повторите ввод" << std::endl;
			 Player_get_match();
			 return;
		 }

		 match -= get_match;
		 
		 std::cout << "В кучке осталось " << match << " спичек" << std::endl;
		 system("pause");
		 system("cls<NUL");
	 }

	 void Bot_get_match()
	 {
		 int get_match;
		 winner = 1;
		 if (match > 11)
		 {
			 if (match > 22 )
			 {
				 int x;
				 x = match - 23;
				 if (x > 10||x==0)
					 x = 1 + rand() % 10;

				 get_match = x;
				 bot_info(get_match);
			 }
			 else
			 {
				 if (match > 12)
				 {
					 get_match = match - 12;
					 bot_info(get_match);
				 }
				 else
				 {
					 get_match = 1 + rand() % 10;
					 bot_info(get_match);
				 }
			 }


		 }
		 else
		 {
			 if (match > 1)
				  get_match = match - 1;
			 else
				  get_match = 1;
			 bot_info(get_match);
		 }
	 }

	 void bot_info(int get_match)
	 {
		 std::cout << "Компьютер берет " << get_match << " спичек из кучи" << std::endl;
		 match -= get_match;
		 std::cout << "В кучке осталось " << match << " спичек" << std::endl;
		 system("pause");
		 system("cls<NUL");
	 }


	 bool end_game()
	 {
		 if (match > 0)
			 return false;
		 else
			 return true;
	 }

	 void game_ended()
	 {
		 std::cout << "Игра окончена"<<std::endl;
		 if (winner)
		 {
			 std::cout << "Вы победили! Поздравляем!" << std::endl;
			 system("pause");
		 }
		 else
		 {
			 std::cout << "Вы проиграли! Компьютер оказался сильнее!"<<std::endl;
			 system("pause");
		 }

	 }


public:

	void start()
	{
		game_info();
		while (!end_game())
		{
			Player_get_match();
			if (end_game())
				break;
			Bot_get_match();
		}
			game_ended();
	}
};


int main()
{
	setlocale(0, "");
	srand(time(NULL));
	
	Game game;
	game.start();

}

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

#include<iostream>

#include<ctime>

class Game

{

private:

int match = 100;

int winner;

void game_info()

{

std::cout << "Вас приветствует игра 100 спичек, ваша задача брать с компьютером по очереди спички из кучи.\n" <<

"Брать вы можете по 1-10 спичек за раз. Кто возьмет последнюю спичку тот и проиграл!\n";

system("pause");

system("cls<NUL");

}

void Player_get_match()

{

winner = 0;

int get_match;

std::cout << "Напишите сколько вы хотите взять спичек из кучи (1-10) :";

std::cin >> get_match;

if (get_match > 10 || get_match <= 0)

{

system("cls<NUL");

std::cout << "Вы ввели неверное число! Повторите ввод"<<std::endl;

Player_get_match();

return;

}

if (get_match > match)

{

system("cls<NUL");

std::cout << "Столько спичек в кучке нету! Повторите ввод" << std::endl;

Player_get_match();

return;

}

match -= get_match;

std::cout << "В кучке осталось " << match << " спичек" << std::endl;

system("pause");

system("cls<NUL");

}

void Bot_get_match()

{

int get_match;

winner = 1;

if (match > 11)

{

if (match > 22 )

{

int x;

x = match - 23;

if (x > 10||x==0)

x = 1 + rand() % 10;

get_match = x;

bot_info(get_match);

}

else

{

if (match > 12)

{

get_match = match - 12;

bot_info(get_match);

}

else

{

get_match = 1 + rand() % 10;

bot_info(get_match);

}

else

{

if (match > 1)

get_match = match - 1;

else

get_match = 1;

bot_info(get_match);

}

void bot_info(int get_match)

{

std::cout << "Компьютер берет " << get_match << " спичек из кучи" << std::endl;

match -= get_match;

std::cout << "В кучке осталось " << match << " спичек" << std::endl;

system("pause");

system("cls<NUL");

}

bool end_game()

{

if (match > 0)

return false;

else

return true;

}

void game_ended()

{

std::cout << "Игра окончена"<<std::endl;

if (winner)

{

std::cout << "Вы победили! Поздравляем!" << std::endl;

system("pause");

}

else

{

std::cout << "Вы проиграли! Компьютер оказался сильнее!"<<std::endl;

system("pause");

}

public:

void start()

{

game_info();

while (!end_game())

{

Player_get_match();

if (end_game())

break;

Bot_get_match();

}

game_ended();

}

};

int main()

{

setlocale(0, "");

srand(time(NULL));

Game game;

game.start();

}

Ответить

Pro grammer:

22 апреля 2022 в 09:02

зачем так усложнять.

#include <bits/stdc++.h>
using namespace std;
int n = 100, x, y, z, a, b, c;
int main()
{
setlocale(LC_ALL, "");
   cout <<""Дается 100 спичек. Вы играете с компьютером. Каждый должен вытянуть спички не меньше одной и не больше десяти." << endl << "НАЧАЛИ:" << endl;
    while(n >= 0){
	 eror:
	  cin >> x;
	   if (x > 10 or x < 1) {
		cout << "Не правильный ввод!" << endl;
	     goto eror;
	}
	 if(x > y) {
	  cout << "По правилам нельзя!"<< endl;
		goto eror;
	}
	 n = n - x;
	  cout << n << "\t";
	   if(n == 0){
	     cout << "you looser!";
          break;
}
	    srand(static_cast<unsigned int>(time(0)));
		 pop:
		  y = rand() % 10 + 1;
		   if (n < y) goto pop;  
            n = n - y;
             if (n == 0) {
	          cout << "you win!";
               break;	   
}
       cout << n << "\t";
}
   return 0;
}

#include <bits/stdc++.h>

using namespace std;

int n = 100, x, y, z, a, b, c;

int main()

{

setlocale(LC_ALL, "");

cout <<""Дается 100 спичек. Вы играете с компьютером. Каждый должен вытянуть спички не меньше одной и не больше десяти." << endl << "НАЧАЛИ:" << endl;

while(n >= 0){

eror:

cin >> x;

if (x > 10 or x < 1) {

cout << "Не правильный ввод!" << endl;

goto eror;

}

if(x > y) {

cout << "По правилам нельзя!"<< endl;

goto eror;

}

n = n - x;

cout << n << "\t";

if(n == 0){

cout << "you looser!";

break;

}

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

pop:

y = rand() % 10 + 1;

if (n < y) goto pop;

n = n - y;

if (n == 0) {

cout << "you win!";

break;

}

cout << n << "\t";

}

return 0;

}

Ответить

Максим:

29 января 2021 в 16:25

Задание 3

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <limits>
#include <vector>
#include <functional>

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);
}

bool turn_order_roll(){
	int player_roll{},
		bot_roll{};
	std::cout << "Roll a dice to form turn order...";
	while (player_roll == bot_roll) {
		player_roll = get_random_number(1, 6);
		bot_roll = get_random_number(1, 6);
	}
	std::cout << "You rolled: " << player_roll << '\n' <<
		"Bot rolled: " << bot_roll << '\n';
	bool first{ (player_roll > bot_roll) ? true : false };
	std::cout << ((first) ? "You will take sticks first.\n\n" : "Bot will take sticks first.\n\n");
	return first;
}

int player_turn(int sticks_left) {
	std::cout << "Your turn: ";
	int player_sticks_take;
	while (!(std::cin >> player_sticks_take) || 
		(player_sticks_take < 1 || player_sticks_take > 10 || player_sticks_take > sticks_left)) {
		std::cout << "You are breaking rules, take again: ";
		std::cin.clear();
		std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	}
	std::cout << "You took " << player_sticks_take << " sticks.\n";
	return player_sticks_take;
}

int bot_turn(int sticks_left) {
	int bot_sticks_take;
	if (sticks_left <= 11) {
		bot_sticks_take = sticks_left - 1;
	}
	else if (sticks_left <= 22) {
		bot_sticks_take = sticks_left - 12;
	}
	else {
		bot_sticks_take = get_random_number(1, 10);
	}
	std::cout << "Bot took " << bot_sticks_take << " sticks.\n";
	return bot_sticks_take;
}

bool game(int sticks_max) {

	std::vector<std::function<int(int)>> turn_order(2);
	// saving turn order for possibility to easily add move players or bots in future

	std::vector<std::function<int(int)>>::iterator player_turn_iter;
	if (turn_order_roll()) {
		player_turn_iter = turn_order.begin();
		*player_turn_iter = player_turn;
		*(turn_order.begin() + 1) = bot_turn;
	}
	else {
		player_turn_iter = turn_order.begin() + 1;
		*turn_order.begin() = bot_turn;
		*player_turn_iter = player_turn;
	}

	std::vector<std::function<int(int)>>::iterator turn_current{ turn_order.begin() };
	for (int sticks{ sticks_max }; sticks > 1; ++turn_current) {
		if (turn_current == turn_order.end()) {
			turn_current = turn_order.begin();
		}
		std::cout << "There are " << sticks << " sticks left.\n";
		sticks -= (*turn_current)(sticks);
	}
	if (turn_current == turn_order.end()) {
		turn_current = turn_order.begin();
	}

	std::cout << ((turn_current == player_turn_iter) ? "You took last stick.\n" : "Bot took last stick.\n");
	return (turn_current != player_turn_iter) ? true : false;
}

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

	std::cout << "Stick the game\n";
	int sticks_max;
	std::cout << "Enter sticks max: ";
	std::cin >> sticks_max;

	std::cout << "Rules:\n"
		"\tThere are " << sticks_max << " sticks.\n"
		"\tPlayer and Bot can take from 1 to 10 sticks\n"
		"\tIf you take last skick - you lose\n";
		"Start.\n\n";

	bool player_won{ game(sticks_max) };
	std::cout << ((player_won == true) ? "You won!" : "You lose..") << '\n';

	return 0;
}

100

101

102

103

104

105

106

107

108

#include <iostream>

#include <cstdlib>

#include <ctime>

#include <limits>

#include <vector>

#include <functional>

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);

}

bool turn_order_roll(){

int player_roll{},

bot_roll{};

std::cout << "Roll a dice to form turn order...";

while (player_roll == bot_roll) {

player_roll = get_random_number(1, 6);

bot_roll = get_random_number(1, 6);

}

std::cout << "You rolled: " << player_roll << '\n' <<

"Bot rolled: " << bot_roll << '\n';

bool first{ (player_roll > bot_roll) ? true : false };

std::cout << ((first) ? "You will take sticks first.\n\n" : "Bot will take sticks first.\n\n");

return first;

}

int player_turn(int sticks_left) {

std::cout << "Your turn: ";

int player_sticks_take;

while (!(std::cin >> player_sticks_take) ||

(player_sticks_take < 1 || player_sticks_take > 10 || player_sticks_take > sticks_left)) {

std::cout << "You are breaking rules, take again: ";

std::cin.clear();

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

}

std::cout << "You took " << player_sticks_take << " sticks.\n";

return player_sticks_take;

}

int bot_turn(int sticks_left) {

int bot_sticks_take;

if (sticks_left <= 11) {

bot_sticks_take = sticks_left - 1;

}

else if (sticks_left <= 22) {

bot_sticks_take = sticks_left - 12;

}

else {

bot_sticks_take = get_random_number(1, 10);

}

std::cout << "Bot took " << bot_sticks_take << " sticks.\n";

return bot_sticks_take;

}

bool game(int sticks_max) {

std::vector<std::function<int(int)>> turn_order(2);

// saving turn order for possibility to easily add move players or bots in future

std::vector<std::function<int(int)>>::iterator player_turn_iter;

if (turn_order_roll()) {

player_turn_iter = turn_order.begin();

*player_turn_iter = player_turn;

*(turn_order.begin() + 1) = bot_turn;

}

else {

player_turn_iter = turn_order.begin() + 1;

*turn_order.begin() = bot_turn;

*player_turn_iter = player_turn;

}

std::vector<std::function<int(int)>>::iterator turn_current{ turn_order.begin() };

for (int sticks{ sticks_max }; sticks > 1; ++turn_current) {

if (turn_current == turn_order.end()) {

turn_current = turn_order.begin();

}

std::cout << "There are " << sticks << " sticks left.\n";

sticks -= (*turn_current)(sticks);

}

if (turn_current == turn_order.end()) {

turn_current = turn_order.begin();

}

std::cout << ((turn_current == player_turn_iter) ? "You took last stick.\n" : "Bot took last stick.\n");

return (turn_current != player_turn_iter) ? true : false;

}

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

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

rand();

std::cout << "Stick the game\n";

int sticks_max;

std::cout << "Enter sticks max: ";

std::cin >> sticks_max;

std::cout << "Rules:\n"

"\tThere are " << sticks_max << " sticks.\n"

"\tPlayer and Bot can take from 1 to 10 sticks\n"

"\tIf you take last skick - you lose\n";

"Start.\n\n";

bool player_won{ game(sticks_max) };

std::cout << ((player_won == true) ? "You won!" : "You lose..") << '\n';

return 0;

}

Ответить

Анастасия:

3 мая 2020 в 16:16

Моё решение задания №3, добавила как опцию высокий уровень сложности, когда компьютер просчитывает свой ход:

#include <iostream>
#include <Windows.h>   // для Sleep()
#include <ctime>       // чтобы в randomize опираться на время запуска программы

// симулятор подбрасывания кубика пользователем и компьютером, возвращает истину, если игрок "выбросил" больше очков
bool users_choose_first()
{
    std::cout << "Подбрасываем кубик, определяем, кто ходит первым...\n";
    Sleep(3000);
    auto users_scores{ rand() % 6 + 1 };
    std::cout << "У Вас: " << users_scores << std::endl;
    auto computer_scores{ rand() % 6 + 1 };
    std::cout << "У компьютера: " << computer_scores << std::endl;
    while (users_scores == computer_scores)
    {
        std::cout << "Придётся бросить кубик ещё раз... " << std::endl;
        Sleep(3000);
        users_scores = rand() % 6 + 1;
        std::cout << "У Вас: " << users_scores << std::endl;
        computer_scores = rand() % 6 + 1;
        std::cout << "У компьютера: " << computer_scores << std::endl;
    }
    Sleep(1000);
    return (users_scores > computer_scores)? true: false;
}

// определяет минимальное из двух чисел
unsigned short get_min_from(const unsigned short a, const unsigned short b)
{
    return (a <= b) ? a : b;
}

// получаем от пользователя натуральное число
unsigned short get_number(const unsigned short min, const unsigned short max)
{
    int answer;
    std::cin >> answer;
    while (std::cin.fail() || (answer < min) || (answer > max))
    {
        std::cin.clear();
        std::cin.ignore(1000, '\n');
        std::cout << "Нужно ввести число от " << min << " до " << max << ", повторите ввод: ";
        std::cin >> answer;
    }
    return static_cast<unsigned short>(answer);
}

// компьютер рассчитывает, сколько он должен взять спичек, чтобы в итоге оставить игрока с одной
unsigned short computers_smart_choice(const unsigned short left_matches, const unsigned short min, const unsigned short max)
{
    /* чтобы на последнем ходу оставить игрока с одной спичкой, 
    на предыдущем нужно оставить его с 1 + (максимальное число за ход + минимальное число за ход), 
    а на предпредыдущем - с 1 + (максимальное число за ход + минимальное число за ход)*2 и т.д., то есть 
    нужно взять столько, чтобы пользователю осталось число, дающее 1 в остатке от деления на (максимальное число за ход + минимальное число за ход) */
    unsigned short optimal_choice{ min };
    while (((left_matches - optimal_choice) % (max + min) != 1) && (optimal_choice < max))
    {
        ++optimal_choice;
    }
    return optimal_choice;
}

int main()
{
    setlocale(LC_CTYPE, "rus");                  // для вывода сообщений пользователю на кириллице
    srand(static_cast<unsigned int>(time(0)));   // аналог randomize с привязкой ко времени запуска

    const unsigned short matches_number{ 100 };  // начальное количество спичек
    const unsigned short min_matches{ 1 };       // минимальное количество спичек, которое можно взять за ход
    const unsigned short max_matches{ 10 };      // максимальное количество спичек, которое можно взять за ход
    // Объясняем правила игры польхователю и даём несколько секунд, чтобы их прочитать:
    std::cout << "Игра «" << matches_number << " спичек».\nИз кучки, первоначально содержащей " << matches_number << " спичек,\n"
        << "двое играющих поочерёдно берут по несколько спичек: не менее " << min_matches << " и не более " << max_matches
        << "\nПроигрывает тот, кто взял последнюю спичку.\n";
    Sleep(6000);
    // Даём пользователю выбрать уровень сложности. 
    // При низком уровне компьютер будет брать случайное количество спичек, при высоком - делать умный выбор
    std::cout << "Выберите уровень сложности:\n0 - низкий\n1 - высокий\n";
    bool complexity_is_high{ static_cast<bool>(get_number(0, 1)) };
   
    while (true)                                        // играем, пока пользователю не надоест
    {
        // с помощью симулятора подбрасывания кубика определяем кто ходит первым:
        bool users_turn{ users_choose_first() };
        if (users_turn) std::cout << "Вы ходите первым!\n";
        else std::cout << "Компьютер ходит первым!\n";
        Sleep(1000);

        unsigned short left_matches{ matches_number };  // количество оставшихся спичек сначала равно начальному количеству
        while (left_matches > 1)                        // цикл одного хода, игрок (пользователь или компьютер) делает ход
        {
            // сначала показываем, сколько осталось спичек, числом и чёрточками |
            std::cout << "осталось спичек: " << left_matches << '\n';
            for (unsigned short i = 1; i <= left_matches; i++)
                std::cout << '|';
            std::cout << std::endl;

            unsigned short one_choice{ 0 };             // количество спичек, которые игрок берёт за ход
            if (users_turn)                             // если ходит игрок:
            {
                std::cout << "Сколько спичек Вы берёте? ";
                /* чтобы игрок не взял все спички или больше, чем есть,
                   за максимум спичек за ход берём не больше, чем осталось минус 1 */      
                one_choice = get_number(min_matches, get_min_from(left_matches - 1, max_matches));
            }
            else                                        // если ходит компьютер:
            {
                Sleep(1000);
                if (!complexity_is_high)                // при низком уровне компьютер будет брать случайное количество спичек
                    one_choice = rand() % get_min_from((left_matches - 1), max_matches) + min_matches;
                /* чтобы игрок не взял все спички или больше, чем есть,
                   за максимум спичек за ход берём не больше, чем осталось минус 1 */
                else
                    one_choice = computers_smart_choice(left_matches, min_matches, get_min_from(left_matches - 1, max_matches));
                std::cout << "Компьютер берёт " << one_choice << '\n';
            }

            left_matches -= one_choice;                // убираем взятое количество спичек
            users_turn = !users_turn;                  // передаём право хода другому игроку
        }

        // осталась одна спичка. Чей ход - тот и проиграл:
        if (users_turn)
            std::cout << "| - последняя спичка - Ваша! Вы проиграли!..\nХотите отыграться?..\n\n";
        else
            std::cout << "Поздравляем! Вы выиграли, оставив компьютеру последнюю спичку!..\nДайте шанс ему отыграться!\n\n";
        Sleep(5000);
    }
}

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

#include <iostream>

#include <Windows.h> // для Sleep()

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

// симулятор подбрасывания кубика пользователем и компьютером, возвращает истину, если игрок "выбросил" больше очков

bool users_choose_first()

{

std::cout << "Подбрасываем кубик, определяем, кто ходит первым...\n";

Sleep(3000);

auto users_scores{ rand() % 6 + 1 };

std::cout << "У Вас: " << users_scores << std::endl;

auto computer_scores{ rand() % 6 + 1 };

std::cout << "У компьютера: " << computer_scores << std::endl;

while (users_scores == computer_scores)

{

std::cout << "Придётся бросить кубик ещё раз... " << std::endl;

Sleep(3000);

users_scores = rand() % 6 + 1;

std::cout << "У Вас: " << users_scores << std::endl;

computer_scores = rand() % 6 + 1;

std::cout << "У компьютера: " << computer_scores << std::endl;

}

Sleep(1000);

return (users_scores > computer_scores)? true: false;

}

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

unsigned short get_min_from(const unsigned short a, const unsigned short b)

{

return (a <= b) ? a : b;

}

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

unsigned short get_number(const unsigned short min, const unsigned short max)

{

int answer;

std::cin >> answer;

while (std::cin.fail() || (answer < min) || (answer > max))

{

std::cin.clear();

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

std::cout << "Нужно ввести число от " << min << " до " << max << ", повторите ввод: ";

std::cin >> answer;

}

return static_cast<unsigned short>(answer);

}

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

unsigned short computers_smart_choice(const unsigned short left_matches, const unsigned short min, const unsigned short max)

{

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

на предыдущем нужно оставить его с 1 + (максимальное число за ход + минимальное число за ход),

а на предпредыдущем - с 1 + (максимальное число за ход + минимальное число за ход)*2 и т.д., то есть

нужно взять столько, чтобы пользователю осталось число, дающее 1 в остатке от деления на (максимальное число за ход + минимальное число за ход) */

unsigned short optimal_choice{ min };

while (((left_matches - optimal_choice) % (max + min) != 1) && (optimal_choice < max))

{

++optimal_choice;

}

return optimal_choice;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // для вывода сообщений пользователю на кириллице

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

const unsigned short matches_number{ 100 }; // начальное количество спичек

const unsigned short min_matches{ 1 }; // минимальное количество спичек, которое можно взять за ход

const unsigned short max_matches{ 10 }; // максимальное количество спичек, которое можно взять за ход

// Объясняем правила игры польхователю и даём несколько секунд, чтобы их прочитать:

std::cout << "Игра «" << matches_number << " спичек».\nИз кучки, первоначально содержащей " << matches_number << " спичек,\n"

<< "двое играющих поочерёдно берут по несколько спичек: не менее " << min_matches << " и не более " << max_matches

<< "\nПроигрывает тот, кто взял последнюю спичку.\n";

Sleep(6000);

// Даём пользователю выбрать уровень сложности.

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

std::cout << "Выберите уровень сложности:\n0 - низкий\n1 - высокий\n";

bool complexity_is_high{ static_cast<bool>(get_number(0, 1)) };

while (true) // играем, пока пользователю не надоест

{

// с помощью симулятора подбрасывания кубика определяем кто ходит первым:

bool users_turn{ users_choose_first() };

if (users_turn) std::cout << "Вы ходите первым!\n";

else std::cout << "Компьютер ходит первым!\n";

Sleep(1000);

unsigned short left_matches{ matches_number }; // количество оставшихся спичек сначала равно начальному количеству

while (left_matches > 1) // цикл одного хода, игрок (пользователь или компьютер) делает ход

{

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

std::cout << "осталось спичек: " << left_matches << '\n';

for (unsigned short i = 1; i <= left_matches; i++)

std::cout << '|';

std::cout << std::endl;

unsigned short one_choice{ 0 }; // количество спичек, которые игрок берёт за ход

if (users_turn) // если ходит игрок:

{

std::cout << "Сколько спичек Вы берёте? ";

/* чтобы игрок не взял все спички или больше, чем есть,

за максимум спичек за ход берём не больше, чем осталось минус 1 */

one_choice = get_number(min_matches, get_min_from(left_matches - 1, max_matches));

}

else // если ходит компьютер:

{

Sleep(1000);

if (!complexity_is_high) // при низком уровне компьютер будет брать случайное количество спичек

one_choice = rand() % get_min_from((left_matches - 1), max_matches) + min_matches;

/* чтобы игрок не взял все спички или больше, чем есть,

за максимум спичек за ход берём не больше, чем осталось минус 1 */

else

one_choice = computers_smart_choice(left_matches, min_matches, get_min_from(left_matches - 1, max_matches));

std::cout << "Компьютер берёт " << one_choice << '\n';

}

left_matches -= one_choice; // убираем взятое количество спичек

users_turn = !users_turn; // передаём право хода другому игроку

}

// осталась одна спичка. Чей ход - тот и проиграл:

if (users_turn)

std::cout << "| - последняя спичка - Ваша! Вы проиграли!..\nХотите отыграться?..\n\n";

else

std::cout << "Поздравляем! Вы выиграли, оставив компьютеру последнюю спичку!..\nДайте шанс ему отыграться!\n\n";

Sleep(5000);

}

Ответить

Анастасия:

3 мая 2020 в 11:20

Моё решение задания №2 (два способа):

#include <iostream>
#include <string>

// получает натуральное число от пользователя
unsigned get_number()
{
	std::cout << "Введите натуральное число: ";
	int answer;
	std::cin >> answer;
	while (std::cin.fail() || (answer < 0))
	{
		std::cin.clear();
		std::cin.ignore(1000, '\n');
		std::cout << "Нужно ввести натуральное число, повторите ввод: ";
		std::cin >> answer;
	}
	return static_cast<unsigned>(answer);
}

// переводит число в 16-ричную запись (возвращает строку)
std::string convert_to_hex(unsigned number)
{
	std::string hex_number{};                      // строковая переменная для 16-ричной записи
	while (number != 0)
	{
		unsigned short modulo{ number % 16 };      // остаток от деления на 16
		std::string char_to_add;                   // остаток от деления на 16 как один из симоволов 123456789ABCDEF
		if (modulo < 10)
			char_to_add = std::to_string(modulo);  // 1-9
		else 
			char_to_add = (modulo-10) + 65;        // 65 - код символа A, результат будет один из ABCDEF
		hex_number.insert(0, char_to_add);         // добавляем полученный символ в начало 16-ричной записи (индекс 0)
		number /= 16;
	}
	return hex_number;
}

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

    std::cout << "Программа переводит число в 16-ричную запись.\n";
	unsigned given_number{ get_number() };

	std::cout << "Это же число в 16-ричной записи:  ";
	std::cout.setf(std::ios::hex, std::ios::basefield);  // включаем 16-ричную СИ, отключаем все противоречащие флаги группы
	std::cout.setf(std::ios::uppercase);                 // включаем большие буквы
	std::cout << given_number << std::endl;
	
	std::cout << "То же, но с самописным переводом: ";
	std::cout << convert_to_hex(given_number) << std::endl;
	
	return 0;
}

#include <iostream>

#include <string>

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

unsigned get_number()

{

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

int answer;

std::cin >> answer;

while (std::cin.fail() || (answer < 0))

{

std::cin.clear();

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

std::cout << "Нужно ввести натуральное число, повторите ввод: ";

std::cin >> answer;

}

return static_cast<unsigned>(answer);

}

// переводит число в 16-ричную запись (возвращает строку)

std::string convert_to_hex(unsigned number)

{

std::string hex_number{}; // строковая переменная для 16-ричной записи

while (number != 0)

{

unsigned short modulo{ number % 16 }; // остаток от деления на 16

std::string char_to_add; // остаток от деления на 16 как один из симоволов 123456789ABCDEF

if (modulo < 10)

char_to_add = std::to_string(modulo); // 1-9

else

char_to_add = (modulo-10) + 65; // 65 - код символа A, результат будет один из ABCDEF

hex_number.insert(0, char_to_add); // добавляем полученный символ в начало 16-ричной записи (индекс 0)

number /= 16;

}

return hex_number;

}

int main()

{

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

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

unsigned given_number{ get_number() };

std::cout << "Это же число в 16-ричной записи: ";

std::cout.setf(std::ios::hex, std::ios::basefield); // включаем 16-ричную СИ, отключаем все противоречащие флаги группы

std::cout.setf(std::ios::uppercase); // включаем большие буквы

std::cout << given_number << std::endl;

std::cout << "То же, но с самописным переводом: ";

std::cout << convert_to_hex(given_number) << std::endl;

return 0;

}

Ответить

Анастасия:

3 мая 2020 в 11:19

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

#include <iostream>
#include <string>

unsigned short check_value_from_user_as_date(const std::string& what_we_check, const unsigned min, const unsigned max)
{
	int value_to_check;
	std::cin >> value_to_check;
	while (std::cin.fail()||(value_to_check < min)||(value_to_check > max))
	{
		std::cin.clear();
		std::cin.ignore(32767, '\n');
		std::string left_to_enter;
		if (what_we_check == "День")
			left_to_enter = "! Введите дату в формате ДД ММ ГГГГ ещё раз: ";
		else if (what_we_check == "Месяц")
			left_to_enter = "! Введите месяц и год в формате ММ ГГГГ ещё раз: ";
		else if (what_we_check == "Год")
			left_to_enter = "! Введите год в формате ГГГГ ещё раз: ";
		std::cout << what_we_check << " должен быть натуральным числом от " << min << " до " << max << left_to_enter;
		std::cin >> value_to_check;
	}
	return static_cast<unsigned short>(value_to_check);
}

// выводим дату в привычном формате ДД.ММ.ГГГГ, иначе может быть 9.7.1999
void print_date(const unsigned short day, const unsigned short month, const unsigned short year)
{
	if (day < 10)
		std::cout << "0" << day << ".";
	else std::cout << day << ".";
	if (month < 10)
		std::cout << "0" << month << ".";
	else std::cout << month << ".";
   std::cout << year << std::endl;
}

// возвращает истину, если год - високосный
bool is_leap_year(const unsigned short year)
{
	if (year % 400 == 0)
		return true;
	// если не делится на 400, но делится на 100
	if (year % 100 == 0)
		return false;
	// если просто делится на 4 без остатка (но не делится на 100 и 400)
	if (year % 4 == 0)
		return true;
	// иначе не делится на 4 без остатка
	return false;
}

// возвращает количество дней в месяце. Для определения с февралём нужен год (для других месяцев без разницы)
unsigned short days_in_month(const unsigned short month, const unsigned short year = 2020)
{
	switch (month)
	{
	case 2:
		if (is_leap_year(year)) return 29;
		else return 28;
	case 4:
	case 6:
	case 9:
	case 11:
		return 30;
	default:
		return 31;
	}
}

// возвращает истину, если дата существует и ложь, если нет (например 30.02 - не существует)
bool next_day_calculation(unsigned short& day, unsigned short& month, unsigned short& year)
{
	if (day < days_in_month(month, year))
	{
		++day;
		return true;
	}
	else if (day == days_in_month(month, year))
	{
		day = 1;
		if (month < 12)
			++month;
		else
		{
			month = 1;
			++year;
		}
		return true;
	}
	else // число в дате - больше возможного
		return false;
}

int main()
{
	setlocale(LC_CTYPE, "rus"); // для вывода сообщений на кириллице
	std::cout << "Программа вычисляет дату следующего дня.\n";

	while (true)
	{
		std::cout << "Введите дату в формате ДД ММ ГГГГ: ";
		unsigned short day = check_value_from_user_as_date("День", 1, 31);
		unsigned short month = check_value_from_user_as_date("Месяц", 1, 12);
		unsigned short year = check_value_from_user_as_date("Год", 1000, 3000);
		std::cout << "Заданная дата ";
		print_date(day, month, year);
		if (next_day_calculation(day, month, year))
		{
			std::cout << "Дата следующего дня: ";
			print_date(day, month, year);
		}
		else 
			std::cout << "Такой даты нет, попробуйте ввести другую!" << std::endl;
	}
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

#include <iostream>

#include <string>

unsigned short check_value_from_user_as_date(const std::string& what_we_check, const unsigned min, const unsigned max)

{

int value_to_check;

std::cin >> value_to_check;

while (std::cin.fail()||(value_to_check < min)||(value_to_check > max))

{

std::cin.clear();

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

std::string left_to_enter;

if (what_we_check == "День")

left_to_enter = "! Введите дату в формате ДД ММ ГГГГ ещё раз: ";

else if (what_we_check == "Месяц")

left_to_enter = "! Введите месяц и год в формате ММ ГГГГ ещё раз: ";

else if (what_we_check == "Год")

left_to_enter = "! Введите год в формате ГГГГ ещё раз: ";

std::cout << what_we_check << " должен быть натуральным числом от " << min << " до " << max << left_to_enter;

std::cin >> value_to_check;

}

return static_cast<unsigned short>(value_to_check);

}

// выводим дату в привычном формате ДД.ММ.ГГГГ, иначе может быть 9.7.1999

void print_date(const unsigned short day, const unsigned short month, const unsigned short year)

{

if (day < 10)

std::cout << "0" << day << ".";

else std::cout << day << ".";

if (month < 10)

std::cout << "0" << month << ".";

else std::cout << month << ".";

std::cout << year << std::endl;

}

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

bool is_leap_year(const unsigned short year)

{

if (year % 400 == 0)

return true;

// если не делится на 400, но делится на 100

if (year % 100 == 0)

return false;

// если просто делится на 4 без остатка (но не делится на 100 и 400)

if (year % 4 == 0)

return true;

// иначе не делится на 4 без остатка

return false;

}

// возвращает количество дней в месяце. Для определения с февралём нужен год (для других месяцев без разницы)

unsigned short days_in_month(const unsigned short month, const unsigned short year = 2020)

{

switch (month)

{

case 2:

if (is_leap_year(year)) return 29;

else return 28;

case 4:

case 6:

case 9:

case 11:

return 30;

default:

return 31;

}

// возвращает истину, если дата существует и ложь, если нет (например 30.02 - не существует)

bool next_day_calculation(unsigned short& day, unsigned short& month, unsigned short& year)

{

if (day < days_in_month(month, year))

{

++day;

return true;

}

else if (day == days_in_month(month, year))

{

day = 1;

if (month < 12)

++month;

else

{

month = 1;

++year;

}

return true;

}

else // число в дате - больше возможного

return false;

}

int main()

{

setlocale(LC_CTYPE, "rus"); // для вывода сообщений на кириллице

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

while (true)

{

std::cout << "Введите дату в формате ДД ММ ГГГГ: ";

unsigned short day = check_value_from_user_as_date("День", 1, 31);

unsigned short month = check_value_from_user_as_date("Месяц", 1, 12);

unsigned short year = check_value_from_user_as_date("Год", 1000, 3000);

std::cout << "Заданная дата ";

print_date(day, month, year);

if (next_day_calculation(day, month, year))

{

std::cout << "Дата следующего дня: ";

print_date(day, month, year);

}

else

std::cout << "Такой даты нет, попробуйте ввести другую!" << std::endl;

}

Ответить

Shom:

17 февраля 2020 в 16:39

Задание №3.

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

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

std::string grammar(const int number)             // Функция для правописания; 
{
    std::string str{std::to_string(number)};      
    if (number >= 5 && number <= 20 ) str += " спичек.";
    else 
    {    
         int temp{number%10};
         if (temp == 1 ) str += " спичку.";
         else if (temp >= 2 && temp <= 4) str += " спички.";
              else str += " спичек.";                         
    }
    return str;
} 


int main()
{  
    //SetConsoleCP(1251);                         // Пользователям Windows для подключения
    //SetConsoleOutputCP(1251);                   //   кириллицы раскоментировать эти две строки;
    
    std::cout << "    *** 100 спичек. ***\n\n"; 
    
    srand(time(0));                              // Начальное значение для генерации случайных
                                                 //                                      чисел;
    int match{100};                              // Начальное количество спичек в куче;
    const int minM{1};                           // Минимально возможный ход;
    const int maxM{10};                          // Максимально возможный ход;
    
    int user,                                    // Для хода пользователя;
        computer;                                // Для хода компьютера;
        
    while (match)
    {
        std::cout << "\nСпичек в куче: " << match << " шт.\n\n"
                    "Ваш ход, возьмите от 1 до 10 спичек: ";
        while (1)
        {
            user = validationInput(minM, maxM);          // Ход пользователя;   
            if (user > match)
                std::cout << "В куче меньше спичек, чем вы хотите взять.\n"
                            "Поробуте ещё раз: ";
            else break;                
        }
        match -= user;
        
        if (!match)                               // Если спичек в куче не осталось;  
        {
            std::cout << "\n\t\tИИ Вас одолел.\n\n"; 
            break;            
        }
        
        if (match == minM) computer = minM;       // Ход компьютера;
        else if (match <= maxM + minM) computer = match - minM;
        else computer = minM + rand()%maxM;         
        match -= computer;
        std::cout << "Компьютер взял " << grammar(computer) << "\n";
        if (!match)
            std::cout << "\n\t\tВЫ ВЫИГРАЛИ!.\n\n";                            
    }
    std::cout << "Игра завершена.\n";    
    
    return 0;
}

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

#include <iostream>

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

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

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

{

int val;

while (true)

{

std::cin >> val;

if (std::cin.fail() || val<a || val>z)

{

std::cin.clear();

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

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

continue;

}

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

return val;

}

std::string grammar(const int number) // Функция для правописания;

{

std::string str{std::to_string(number)};

if (number >= 5 && number <= 20 ) str += " спичек.";

else

{

int temp{number%10};

if (temp == 1 ) str += " спичку.";

else if (temp >= 2 && temp <= 4) str += " спички.";

else str += " спичек.";

}

return str;

}

int main()

{

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

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

std::cout << " *** 100 спичек. ***\n\n";

srand(time(0)); // Начальное значение для генерации случайных

// чисел;

int match{100}; // Начальное количество спичек в куче;

const int minM{1}; // Минимально возможный ход;

const int maxM{10}; // Максимально возможный ход;

int user, // Для хода пользователя;

computer; // Для хода компьютера;

while (match)

{

std::cout << "\nСпичек в куче: " << match << " шт.\n\n"

"Ваш ход, возьмите от 1 до 10 спичек: ";

while (1)

{

user = validationInput(minM, maxM); // Ход пользователя;

if (user > match)

std::cout << "В куче меньше спичек, чем вы хотите взять.\n"

"Поробуте ещё раз: ";

else break;

}

match -= user;

if (!match) // Если спичек в куче не осталось;

{

std::cout << "\n\t\tИИ Вас одолел.\n\n";

break;

}

if (match == minM) computer = minM; // Ход компьютера;

else if (match <= maxM + minM) computer = match - minM;

else computer = minM + rand()%maxM;

match -= computer;

std::cout << "Компьютер взял " << grammar(computer) << "\n";

if (!match)

std::cout << "\n\t\tВЫ ВЫИГРАЛИ!.\n\n";

}

std::cout << "Игра завершена.\n";

return 0;

}

Ответить

Анастасия:

6 мая 2020 в 11:45

Это хорошо, что у Вас хотя бы последний ход компьютер делает более менее "обдуманно". Плохо, что игрок всегда ходит первым, и неговорящие имена параметров функции validationInput(const int a, const int z), которые на самом деле минимальное и максимальное количество спичек за ход. За то "спички" поставили в правильную форму))

Ответить

Shom:

13 февраля 2020 в 17:09

Задание №2.

// Linux Mint 18.3, g++-7, c++17, IDE "CodeLite";    
#include <iostream>
//#include <windows.h>              // Раскоментировать для подключения 
                                    //  кириллицы в Windows; 
template <typename T>               // Шаблон;
T validationInput()                 // Функция валидации ввода данных;
{
    T val;
    while (true)
    {
        std::cin >> val;
        if (std::cin.fail())        
        {                                             
            std::cin.clear();
            std::cin.ignore(32767, '\n');
            std::cout << "Ошибка ввода! Попробуйте ещё раз: ";
            continue;
        }
        std::cin.ignore(32767, '\n');
        return val;
    }
}

char symbol(int val)                 // Функция преобразования числа в символ;
{
    if (val<0) val *= -1;
    if (val<10) return '0' + val;    // Это элегантное решение нашёл на Киберфоруме,
    else return 'A'+ val%10;         //   когда искал библиотечную функцию для 
}                                    //     преобразования числа в символ;


int main()
{  
    //SetConsoleCP(1251);                         // Пользователям Windows для подключения
    //SetConsoleOutputCP(1251);                   //   кириллицы раскоментировать эти две строки;
    
    std::cout << "    *** Программа переводит десятичное число в "
                      "шестнадцатиричную систему счисления. ***\n\n"; 
    
    while (1)
    {
        std::cout << "Введите число в десятичной системе: ";
        double num10{validationInput<double>()};               // Ввод числа пользователем;
        if (!num10) break;                                     // Выход из программы при введении нуля; 
           
        
        int integer{static_cast<int>(num10)};                  // Выделяем целую часть введённого числа; 
        double fractoin{num10-integer};                        // Выделяем дробную часть введённого числа;
        
        std::string num16{num10 < 0 ? "-" : ""};               // Строка для преобразованного числа;
        std::string temp{""};                                  // Временная строка; 
        do                                                     // Преобразуем целую часть в
        {                                                      //   шестнадцатиричную систему;
            temp.push_back(symbol(integer%16));                // Число записывается в строку задом на перёд; 
            integer /= 16;
        } 
        while (integer);       
             
        for (int iii{temp.length()-1}; iii>=0; --iii)          // Переписываем число в нормальный вид; 
        {
            num16.push_back(temp[iii]);
        }
        
        if (fractoin)                                          // Если есть дробная часть у введённого числа;
        {                                                      
            std::cout << "Введите точность конечного числа\n (количество знаков после запятой): ";
            int accuracy{validationInput<int>()};              // Точность конечного числа;
            if (accuracy<0) 
            {
                std::cout << "Точность не может быть отрицательной!\n"
                             "Давайте начнём с начала:\n";
                continue;  
            }
            num16.push_back('.');                             // Добавляем в строку десятичную точку;
            for (size_t iii{0}; iii<accuracy; ++iii)          // Преобразуем дробную часть в
            {                                                 //  16-тиричную систему;
                fractoin *= 16;
                integer = static_cast<int>(fractoin);
                num16.push_back(symbol(integer));
                fractoin -= integer;
            }        
        }
        
        std::cout << "\nРезультат преобразования: " << num16 << "\n"
                     "Для выхода введите 0\n\n";                      
    }
    std::cout << "\nПрограмма завершена\n\n";                 // Выводим сообщение о завершении 
                                                              //                      программы;
    return 0;
}

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

#include <iostream>

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

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

template <typename T> // Шаблон;

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

{

T val;

while (true)

{

std::cin >> val;

if (std::cin.fail())

{

std::cin.clear();

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

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

continue;

}

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

return val;

}

char symbol(int val) // Функция преобразования числа в символ;

{

if (val<0) val *= -1;

if (val<10) return '0' + val; // Это элегантное решение нашёл на Киберфоруме,

else return 'A'+ val%10; // когда искал библиотечную функцию для

} // преобразования числа в символ;

int main()

{

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

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

std::cout << " *** Программа переводит десятичное число в "

"шестнадцатиричную систему счисления. ***\n\n";

while (1)

{

std::cout << "Введите число в десятичной системе: ";

double num10{validationInput<double>()}; // Ввод числа пользователем;

if (!num10) break; // Выход из программы при введении нуля;

int integer{static_cast<int>(num10)}; // Выделяем целую часть введённого числа;

double fractoin{num10-integer}; // Выделяем дробную часть введённого числа;

std::string num16{num10 < 0 ? "-" : ""}; // Строка для преобразованного числа;

std::string temp{""}; // Временная строка;

do // Преобразуем целую часть в

{ // шестнадцатиричную систему;

temp.push_back(symbol(integer%16)); // Число записывается в строку задом на перёд;

integer /= 16;

}

while (integer);

for (int iii{temp.length()-1}; iii>=0; --iii) // Переписываем число в нормальный вид;

{

num16.push_back(temp[iii]);

}

if (fractoin) // Если есть дробная часть у введённого числа;

{

std::cout << "Введите точность конечного числа\n (количество знаков после запятой): ";

int accuracy{validationInput<int>()}; // Точность конечного числа;

if (accuracy<0)

{

std::cout << "Точность не может быть отрицательной!\n"

"Давайте начнём с начала:\n";

continue;

}

num16.push_back('.'); // Добавляем в строку десятичную точку;

for (size_t iii{0}; iii<accuracy; ++iii) // Преобразуем дробную часть в

{ // 16-тиричную систему;

fractoin *= 16;

integer = static_cast<int>(fractoin);

num16.push_back(symbol(integer));

fractoin -= integer;

}

std::cout << "\nРезультат преобразования: " << num16 << "\n"

"Для выхода введите 0\n\n";

}

std::cout << "\nПрограмма завершена\n\n"; // Выводим сообщение о завершении

// программы;

return 0;

}

Ответить

Анастасия:

4 мая 2020 в 14:05

Я как-то и не задумывалась, чтобы сделать программу для преобразования дробных чисел. А это точно именно так работает? Кажется, нет, ведь в оригинале шестнадцатеричной записи точка не встречается…
Но Ваша функция преобразования остатка в символ мне понравилась. Действительно элегантная.

Ответить
1. Shom:
  
  4 мая 2020 в 14:18
  
  https://math.semestr.ru/inf/16.php
  Да, красивая функция и очень простая)
  
  Ответить

Shom:

7 февраля 2020 в 12:22

Задание №1.

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

void lastDayMonth(int *arr)         // Обработка последнего дня месяца;
{
    std::cout << "Последний день месяца! ";
    arr[0] = 1;
    ++arr[1];
} 

int main()
{  
    //SetConsoleCP(1251);                         // Пользователям Windows для подключения
    //SetConsoleOutputCP(1251);                   //   кириллицы раскоментировать эти две строки;
    
    std::cout << "    *** Программа вычисляет дату следующего дня. ***\n\n"; 
    
    while (1)                                     // Основной цикл программы;
    {    
        std::cout << "Введите цифрами дату (число, месяц, год): ";
        std::string date;                         // Строка для ввода даты;
        int dateArr[3];                           // Массив для даты;
        
        char key{1};                              // Ключ для выхода из цикла;
        while (key)
        {
            std::getline(std::cin, date);         // Вводим дату;
            if (date[0] == 'Q' || date[0] == 'q') return 0;   // Условие завершения программы;
            size_t index{0};                      // Для stoi(), хранение индекса элемента; 
            for (size_t iii{0}; iii<3; ++iii)     // Заполняем массив датой;
            {
                try
                {
                    dateArr[iii] = stoi(date, &index);  // Пытаемся преобразовать число в строку      
                }                                       //  и, если получилось, записываем м масив;  
                catch (std::invalid_argument)           // Ловим ошибку преобразования строки 
                {                                       //     в число от stoi();
                     std::cout << "Ошибка ввода! Попробуйте ещё раз: ";
                     break;            
                } 
                date = date.erase(0, index+1);          // Удаляем преобразованную часть строки; 
                
                if (iii == 2) key = 0;                  // Если заполнение массива прошло удачно;
            }        
            
            if (!key)                                   // Если массив заполнен проверяем правильность
            {                                           //   даты;
                if (dateArr[0]<1 || dateArr[0]>31 || dateArr[1]<1 || dateArr[1]>12 )
                {                                       // Если количество дней/месяцев больше/меньше 
                    std::cout << "Ошибка! Некорректная дата! Попробуйте ещё раз: ";  // общепринятого; 
                    key = 1;
                    continue;
                }
                            
                if (dateArr[0] == 31)
                {
                    switch (dateArr[1])               // Если в 30-тидневных месяцах 
                    {                                 //     введено 31-ое число;              
                        case 4:
                        case 6:
                        case 9:
                        case 11: std::cout << "Ошибка! В этом месяце 30 дней. " 
                                              "Попробуйте ещё раз: ";
                                  key = 1;
                                  continue;
                        default:  break;
                    }                
                }
                
                if (dateArr[1] == 2)           // Количество дней в феврале;
                {
                    if (dateArr[2]%4)          // Не весокосный год;
                    {
                        if (dateArr[0]>28)
                        {
                            std::cout << "Ошибка! В феврале этого года 28 дней. " 
                                         "Попробуйте ещё раз: ";
                            key = 1;
                            continue;
                        }                                
                    } 
                    else if (dateArr[0]>29)    // Весокосный год;
                    {
                            std::cout << "Ошибка! В феврале этого года 29 дней. " 
                                         "Попробуйте ещё раз: ";
                            key = 1;
                            continue;
                    } 
                }
            }          
        }
        
        switch (dateArr[0])                   // Ищем завтра;
        {
            case 31: if (dateArr[1] == 12)    // Для 31 декабря;
                     {
                         std::cout << "Последний день года! ";
                         dateArr[0] = 1;
                         dateArr[1] = 1;
                         ++dateArr[2];
                     } else lastDayMonth(dateArr);   // Для 31-го числа остальных месяцев;               
                     break;
                    
            case 30: switch (dateArr[1])       // Для 30-го числа 30-тидневных месяцев;
                     {    
                         case 4:
                         case 6:
                         case 9:
                         case 11: lastDayMonth(dateArr);
                                  break;
                         default: ++dateArr[0]; // Для 30-го числа остальных месяцев; 
                                  break;                    
                     }
                     break;
                    
            case 29: if (dateArr[1] == 2) lastDayMonth(dateArr);  // 29-ое февраля;                              
                     else ++dateArr[0];         // 29-ое не февраля;
                     break;
                    
            case 28: if ((dateArr[1] == 2) && (dateArr[2]%4 != 0)) // 28-ое февраля
                         lastDayMonth(dateArr);            //   не весакосного года;
                     else ++dateArr[0];         // 28-ое не февраля;        
                     break; 

            default: ++dateArr[0];              // Все остальные дни;
                     break;
        }
        std::string day{"0"},                  // Для вывода числа;
                    month{"0"};                // Для вывода месяца;
        
        if (dateArr[0]/10) day = "";           // Если число больше 9;
        if (dateArr[1]/10) month = "";         // Если месяц больше 9;
        
        std::cout << "Завтра " << day << dateArr[0] << "." << month <<
                     dateArr[1] << "." << dateArr[2] << "\n"
                     "Для выхода введите 'Q'.\n\n";            
    }    

    return 0;
}

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

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

#include <iostream>

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

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

void lastDayMonth(int *arr) // Обработка последнего дня месяца;

{

std::cout << "Последний день месяца! ";

arr[0] = 1;

++arr[1];

}

int main()

{

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

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

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

while (1) // Основной цикл программы;

{

std::cout << "Введите цифрами дату (число, месяц, год): ";

std::string date; // Строка для ввода даты;

int dateArr[3]; // Массив для даты;

char key{1}; // Ключ для выхода из цикла;

while (key)

{

std::getline(std::cin, date); // Вводим дату;

if (date[0] == 'Q' || date[0] == 'q') return 0; // Условие завершения программы;

size_t index{0}; // Для stoi(), хранение индекса элемента;

for (size_t iii{0}; iii<3; ++iii) // Заполняем массив датой;

{

try

{

dateArr[iii] = stoi(date, &index); // Пытаемся преобразовать число в строку

} // и, если получилось, записываем м масив;

catch (std::invalid_argument) // Ловим ошибку преобразования строки

{ // в число от stoi();

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

break;

}

date = date.erase(0, index+1); // Удаляем преобразованную часть строки;

if (iii == 2) key = 0; // Если заполнение массива прошло удачно;

}

if (!key) // Если массив заполнен проверяем правильность

{ // даты;

if (dateArr[0]<1 || dateArr[0]>31 || dateArr[1]<1 || dateArr[1]>12 )

{ // Если количество дней/месяцев больше/меньше

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

key = 1;

continue;

}

if (dateArr[0] == 31)

{

switch (dateArr[1]) // Если в 30-тидневных месяцах

{ // введено 31-ое число;

case 4:

case 6:

case 9:

case 11: std::cout << "Ошибка! В этом месяце 30 дней. "

"Попробуйте ещё раз: ";

key = 1;

continue;

default: break;

}

if (dateArr[1] == 2) // Количество дней в феврале;

{

if (dateArr[2]%4) // Не весокосный год;

{

if (dateArr[0]>28)

{

std::cout << "Ошибка! В феврале этого года 28 дней. "

"Попробуйте ещё раз: ";

key = 1;

continue;

}

else if (dateArr[0]>29) // Весокосный год;

{

std::cout << "Ошибка! В феврале этого года 29 дней. "

"Попробуйте ещё раз: ";

key = 1;

continue;

}

switch (dateArr[0]) // Ищем завтра;

{

case 31: if (dateArr[1] == 12) // Для 31 декабря;

{

std::cout << "Последний день года! ";

dateArr[0] = 1;

dateArr[1] = 1;