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

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

17691

ǀ 26

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

Оглавление:

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

Easy: Задание №1

Напишите программу, которая выведет все элементы больше 5 из следующего массива:

а = [1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345]

Затем спросите у пользователя число. Выведите числа из вышеприведенного массива, которые меньше числа, введенного пользователем.

Medium: Задание №2

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

камень, который ломает ножницы;

ножницы, которые режут бумагу;

бумага, которая обволакивает камень.

В конце игры пользователю должно выводиться сообщение о результате игры и предложение сыграть еще раз.

Hard: Задание №3

Напишите генератор паролей. Составьте три уровня сложности генерации паролей (включая их длину) и спрашивайте у пользователя, какой уровень сложности ему нужен. Проявите свою изобретательность: надежные пароли должны состоять из сочетания строчных букв, прописных букв, цифр и символов. Пароли должны генерироваться случайным образом каждый раз, когда пользователь запрашивает новый пароль.

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

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

Загрузка...

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

Finchi:

3 сентября 2022 в 10:44

Задание №2

#include <iostream>
#include <random>
#include <array>
int main()
{
	setlocale(LC_ALL, "russian");
	std::array <char, 3> rps{ 'r', 'p', 's' };
	std::cout << "Игра камень, ножницы, бумага.\n";
	char your_choise;
	do
	{
		std::cout << "Сделайте выбор (r, p, s): ";
		std::cin >> your_choise;
		std::cin.ignore(32767, '\n');
		std::cin.clear();
	} while (your_choise != 'r' && your_choise != 'p' && your_choise != 's');
	std::mt19937 mercene_vortex(std::random_device{}());
	char computer_choise = rps.at(mercene_vortex() % 3);
	std::cout << "Компьютер выбрал: " << computer_choise << '\n';
	if ((computer_choise == 'r' && your_choise == 's') || (computer_choise == 'p' && your_choise == 'r') ||
		(computer_choise == 's' && your_choise == 'p'))
		std::cout << "Вы проиграли!\n";
	else if (computer_choise == your_choise)
		std::cout << "Ничья!\n";
	else
		std::cout << "Вы выиграли!\n";
	do
	{
		std::cout << "Хотите сыграть еще раз? (y/n): ";
		std::cin >> your_choise;
		std::cin.clear();
		std::cin.ignore(32767, '\n');
	} while (your_choise!='y' && your_choise!='n');
	if (your_choise == 'y')
		main();
	else
		exit(0);
	return 0;
}

#include <iostream>

#include <random>

#include <array>

int main()

{

setlocale(LC_ALL, "russian");

std::array <char, 3> rps{ 'r', 'p', 's' };

std::cout << "Игра камень, ножницы, бумага.\n";

char your_choise;

{

std::cout << "Сделайте выбор (r, p, s): ";

std::cin >> your_choise;

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

std::cin.clear();

} while (your_choise != 'r' && your_choise != 'p' && your_choise != 's');

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

char computer_choise = rps.at(mercene_vortex() % 3);

std::cout << "Компьютер выбрал: " << computer_choise << '\n';

if ((computer_choise == 'r' && your_choise == 's') || (computer_choise == 'p' && your_choise == 'r') ||

(computer_choise == 's' && your_choise == 'p'))

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

else if (computer_choise == your_choise)

std::cout << "Ничья!\n";

else

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

{

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

std::cin >> your_choise;

std::cin.clear();

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

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

if (your_choise == 'y')

main();

else

exit(0);

return 0;

}

Задание №3

#include <iostream>
#include <random>
#include <string>
#include <array>
struct Symbols_range
{
	int begin;
	int end;
};
class Password_generator
{
public:
	Password_generator()
	{
		std::string lvl, temp;
		int ilvl;
		do
		{
			std::cout << "Выберите уровень сложности пароля (1, 2, 3, 4): ";
			std::getline(std::cin, lvl);
			ilvl = std::stoi(lvl);
			temp = std::to_string(ilvl);
		} while (lvl != temp && (ilvl > 0 && ilvl < 5));
		password_generate(ilvl);
	}
	std::string get_password()
	{
		return m_password;
	}
private:
	std::string m_password;
	void password_generate(int lvl)
	{
		std::array<Symbols_range, 4> range{ 48, 58, 97, 123, 65, 91, 33, 48};
		std::mt19937 mercene_vortex(std::random_device{}());
		int length = 0;
		switch (lvl)
		{
		case 1:
			length = 6 + mercene_vortex() % 2;
			for (int i = 0; i < length; i++)
			{
				m_password += range.at(0).begin + mercene_vortex() % (range.at(0).end - range.at(0).begin);
			}
			break;
		case 2:
			length = 6 + mercene_vortex() % 4;
			for (int i = 0; i < length; i++)
			{
				int kit = mercene_vortex()%lvl;
				m_password += range.at(kit).begin + mercene_vortex() % (range.at(kit).end - range.at(kit).begin);
			}
			break;
		case 3:
			length = 6 + mercene_vortex() % 8;
			for (int i = 0; i < length; i++)
			{
				int kit = mercene_vortex() % lvl;
				m_password += range.at(kit).begin + mercene_vortex() % (range.at(kit).end - range.at(kit).begin);
			}
			break;
		case 4:
			length = 6 + mercene_vortex() % 10;
			for (int i = 0; i < length; i++)
			{
				int kit = mercene_vortex() % lvl;
				m_password += range.at(kit).begin + mercene_vortex() % (range.at(kit).end - range.at(kit).begin);
			}
			break;
		default:
			std::cout << "class Password_generator: Ошибка при выборе уровня сложности пароля!\n";
			break;
		}
	}
};
int main()
{
	setlocale(LC_ALL, "russian");
	Password_generator first;
	std::cout << first.get_password();
	return 0;
}

#include <iostream>

#include <random>

#include <string>

#include <array>

struct Symbols_range

{

int begin;

int end;

};

class Password_generator

{

public:

Password_generator()

{

std::string lvl, temp;

int ilvl;

{

std::cout << "Выберите уровень сложности пароля (1, 2, 3, 4): ";

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

ilvl = std::stoi(lvl);

temp = std::to_string(ilvl);

} while (lvl != temp && (ilvl > 0 && ilvl < 5));

password_generate(ilvl);

}

std::string get_password()

{

return m_password;

}

private:

std::string m_password;

void password_generate(int lvl)

{

std::array<Symbols_range, 4> range{ 48, 58, 97, 123, 65, 91, 33, 48};

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

int length = 0;

switch (lvl)

{

case 1:

length = 6 + mercene_vortex() % 2;

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

{

m_password += range.at(0).begin + mercene_vortex() % (range.at(0).end - range.at(0).begin);

}

break;

case 2:

length = 6 + mercene_vortex() % 4;

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

{

int kit = mercene_vortex()%lvl;

m_password += range.at(kit).begin + mercene_vortex() % (range.at(kit).end - range.at(kit).begin);

}

break;

case 3:

length = 6 + mercene_vortex() % 8;

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

{

int kit = mercene_vortex() % lvl;

m_password += range.at(kit).begin + mercene_vortex() % (range.at(kit).end - range.at(kit).begin);

}

break;

case 4:

length = 6 + mercene_vortex() % 10;

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

{

int kit = mercene_vortex() % lvl;

m_password += range.at(kit).begin + mercene_vortex() % (range.at(kit).end - range.at(kit).begin);

}

break;

default:

std::cout << "class Password_generator: Ошибка при выборе уровня сложности пароля!\n";

break;

}

};

int main()

{

setlocale(LC_ALL, "russian");

Password_generator first;

std::cout << first.get_password();

return 0;

}

Ответить

Руслан:

18 мая 2022 в 21:04

Задание 3:

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

#define EMPTY -1

class Random
{
public:
	/// <summary>
	/// Returns a random number from the range. (END not included in the range)
	/// </summary>
	/// <param name="begin"></param>
	/// <param name="end"></param>
	static int fromRange(int begin, int end)
	{
		return (rand() % (end - begin)) + begin;
	}
private:

};

class Password
{
private:
	std::string m_value;
public:

	using Mask = char;

	const int ASCII_deaposones[4][2]{ { 48, 57 },	 // range of numeric characters in ASCII table
									  { 65, 90 },	 // range of uppercase letters in ASCII table
									  { 97, 122 },   // range of lowercase letters in ASCII table
									  { 33, 47 } };  // range of symbols in ASCII table

	enum class Masks
	{
		NUMBER_ENABLE = 0b0000001,
		LOWER_ENABLE = 0b00000010,
		UPPER_ENABLE = 0b00000100,
		SYMBOLS_ENABLE = 0b00001000,
		ENABLE_ALL = 0b00001111
	};

	void Generate(size_t length, Masks flag = Masks::ENABLE_ALL)
	{
		std::string value;
		Masks flags[4]{ Masks::NUMBER_ENABLE, Masks::UPPER_ENABLE, Masks::LOWER_ENABLE, Masks::SYMBOLS_ENABLE };

		for (size_t i{ 0 }; i < length;)
		{
			int type_key = Random::fromRange(0, 4); // We have 3 types of characters - numerics[0], letters in lower[1] and upper[2] case and symbols[3].
			int pos_key = Random::fromRange(ASCII_deaposones[type_key][0], ASCII_deaposones[type_key][1]);

			for (int flagPos{ 0 }; flagPos < 4; ++flagPos)
			{
				if ((static_cast<int>(flag) & static_cast<int>(flags[flagPos])) && (type_key == flagPos))
				{
					value += static_cast<char>(pos_key);
					++i;
				}
			}
		}

		m_value = value;
	}

	const std::string& getPassword()
	{
		return m_value;
	}

	friend std::ostream& operator<<(std::ostream& out, Password password);
};

std::ostream& operator<<(std::ostream& out, Password password)
{
	out << password.m_value;
	return out;
}

class Console
{
public:

	template<typename T>
	static bool input(T& value)
	{
		std::cin >> value;

		if (std::cin.fail()) {
			std::cin.clear();
			std::cin.ignore(32767, '\n');

			return false;
		}

		return true;
	}
};

int main()
{
	srand(time(0));

	using PassMasks = Password::Masks;

	Password pass;

	size_t length;
	std::cout << "Enter the length of your password: ";

	while (!Console::input<size_t>(length))
	{
		std::cout << "Retry: ";
	};

	std::cout << "============================================== " << std::endl;
	std::cout << "Choose a types of characters in your password: " << std::endl;
	std::cout << "1 - numeric " << std::endl;
	std::cout << "2 - uppercase letters " << std::endl;
	std::cout << "3 - lowercase letters " << std::endl;
	std::cout << "4 - symbols " << std::endl;
	std::cout << "5 - ALL " << std::endl;
	std::cout << "============================================== " << std::endl;

	std::string chosenTypes;
	while (!Console::input<std::string>(chosenTypes))
		std::cout << "Retry: ";

	Password::Mask mask{ 0b00000000 };
	PassMasks allMasks[5]{ PassMasks::NUMBER_ENABLE, PassMasks::UPPER_ENABLE, PassMasks::LOWER_ENABLE, PassMasks::SYMBOLS_ENABLE, PassMasks::ENABLE_ALL };

	for (size_t i{ 1 }; i < 6; ++i)
	{
		if (chosenTypes.find(std::to_string(i)) != EMPTY)
		{
			mask |= static_cast<int>(allMasks[i - 1]);
		}

	}

	pass.Generate(length, static_cast<PassMasks>(mask));

	std::cout << "Your password: " << pass << std::endl;
	
	return EXIT_SUCCESS;
}

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

#include <iostream>

#include <cstdlib>

#include <utility>

#include <string>

#include <ctime>

#define EMPTY -1

class Random

{

public:

/// <summary>

/// Returns a random number from the range. (END not included in the range)

/// </summary>

/// <param name="begin"></param>

/// <param name="end"></param>

static int fromRange(int begin, int end)

{

return (rand() % (end - begin)) + begin;

}

private:

};

class Password

{

private:

std::string m_value;

public:

using Mask = char;

const int ASCII_deaposones[4][2]{ { 48, 57 }, // range of numeric characters in ASCII table

{ 65, 90 }, // range of uppercase letters in ASCII table

{ 97, 122 }, // range of lowercase letters in ASCII table

{ 33, 47 } }; // range of symbols in ASCII table

enum class Masks

{

NUMBER_ENABLE = 0b0000001,

LOWER_ENABLE = 0b00000010,

UPPER_ENABLE = 0b00000100,

SYMBOLS_ENABLE = 0b00001000,

ENABLE_ALL = 0b00001111

};

void Generate(size_t length, Masks flag = Masks::ENABLE_ALL)

{

std::string value;

Masks flags[4]{ Masks::NUMBER_ENABLE, Masks::UPPER_ENABLE, Masks::LOWER_ENABLE, Masks::SYMBOLS_ENABLE };

for (size_t i{ 0 }; i < length;)

{

int type_key = Random::fromRange(0, 4); // We have 3 types of characters - numerics[0], letters in lower[1] and upper[2] case and symbols[3].

int pos_key = Random::fromRange(ASCII_deaposones[type_key][0], ASCII_deaposones[type_key][1]);

for (int flagPos{ 0 }; flagPos < 4; ++flagPos)

{

if ((static_cast<int>(flag) & static_cast<int>(flags[flagPos])) && (type_key == flagPos))

{

value += static_cast<char>(pos_key);

++i;

}

m_value = value;

}

const std::string& getPassword()

{

return m_value;

}

friend std::ostream& operator<<(std::ostream& out, Password password);

};

std::ostream& operator<<(std::ostream& out, Password password)

{

out << password.m_value;

return out;

}

class Console

{

public:

template<typename T>

static bool input(T& value)

{

std::cin >> value;

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

std::cin.clear();

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

return false;

}

return true;

}

};

int main()

{

srand(time(0));

using PassMasks = Password::Masks;

Password pass;

size_t length;

std::cout << "Enter the length of your password: ";

while (!Console::input<size_t>(length))

{

std::cout << "Retry: ";

};

std::cout << "============================================== " << std::endl;

std::cout << "Choose a types of characters in your password: " << std::endl;

std::cout << "1 - numeric " << std::endl;

std::cout << "2 - uppercase letters " << std::endl;

std::cout << "3 - lowercase letters " << std::endl;

std::cout << "4 - symbols " << std::endl;

std::cout << "5 - ALL " << std::endl;

std::cout << "============================================== " << std::endl;

std::string chosenTypes;

while (!Console::input<std::string>(chosenTypes))

std::cout << "Retry: ";

Password::Mask mask{ 0b00000000 };

PassMasks allMasks[5]{ PassMasks::NUMBER_ENABLE, PassMasks::UPPER_ENABLE, PassMasks::LOWER_ENABLE, PassMasks::SYMBOLS_ENABLE, PassMasks::ENABLE_ALL };

for (size_t i{ 1 }; i < 6; ++i)

{

if (chosenTypes.find(std::to_string(i)) != EMPTY)

{

mask |= static_cast<int>(allMasks[i - 1]);

}

pass.Generate(length, static_cast<PassMasks>(mask));

std::cout << "Your password: " << pass << std::endl;

return EXIT_SUCCESS;

}

Ответить

Руслан:

18 мая 2022 в 19:04

Задание 2:

#include <iostream>
#include <vector>
#include <algorithm>
#include <ctime>
 
// I did not distribute each individual class into header files, because this game is simple and I'm too lazy)

class GameItem
{
public:

	enum class Types
	{
		DEFAULT,
		STONE,
		SCISSORS,
		PAPER,
		DIFFICULT
	};

	GameItem(Types type = Types::DEFAULT) : m_type{ type }
	{
	}

	/// <summary>
	/// Returns current type of object.
	/// </summary>
	/// <returns></returns>
	Types getType()
	{
		return m_type;
	}

	/// <summary>
	/// Returns true, if current object wins another.
	/// </summary>
	/// <param name="gameItem"></param>
	/// <returns></returns>
	virtual bool fight(const GameItem& gameItem) const
	{
		for (size_t i = 0; i < gameItem.getBeatableObjects().size(); ++i)
		{
			if (gameItem.getBeatableObjects()[i] == m_type) return false;
		}

		return true;
	}

	/// <summary>
	/// Returns types of objects, which current object can win.
	/// </summary>
	/// <returns></returns>
	const std::vector<Types>& getBeatableObjects() const
	{
		return m_beatable;
	}

protected:

	std::vector<Types> m_beatable;

	Types m_type;
};

/// <summary>
/// It implies a game object that can influence the outcome of the game.
/// </summary>
class GameEntity : public GameItem
{
public:
	GameEntity(Types type, const std::string& name) : GameItem(type), m_name{ name }
	{
	}

	const std::string& getName() const
	{
		return m_name;
	}

protected:
	std::string m_name;
};

class Stone : public GameEntity
{
public:
	Stone(const std::string& name) : GameEntity(Types::STONE, name)
	{
		m_beatable.push_back(Types::SCISSORS);
	}

};

class Scissors : public GameEntity
{
public:
	Scissors(const std::string& name) : GameEntity(Types::SCISSORS, name)
	{
		m_beatable.push_back(Types::PAPER);
	}

};

class Random
{
public:

	template <typename T>
	static T getRandomItemFromVector(const std::vector<T>& items)
	{
		return items[abs(static_cast<int>(rand() % items.size()))];
	}
};

class Paper : public GameEntity
{
public:
	Paper(const std::string& name) : GameEntity(Types::PAPER, name)
	{
		m_beatable.push_back(Types::STONE);
	}

};

class LanguageLocale
{
public:
	static void SetRussian()
	{
		setlocale(LC_ALL, "Russian");
	}
};

int main(int argc, char* argv[])
{
	srand(time(0));

	Stone* stone = new Stone("Stone");
	Paper* paper = new Paper("Paper");
	Scissors* scissors = new Scissors("Scissors");

	// Èíòåðôåéñ äëÿ ïîëüçîâàòåëÿ
	std::cout << "What do you want to select?" << std::endl;
	std::cout << "1 - Stone" << std::endl;
	std::cout << "2 - Scissors" << std::endl;
	std::cout << "3 - Paper" << std::endl;

	size_t selectedItemType{ 0 };

	GameEntity* player = nullptr;
	std::vector<GameEntity*> gameEntites{ stone, scissors, paper };

	bool isSelected{ false };
	while (!isSelected)
	{
		std::cout << "Enter: ";
		std::cin >> selectedItemType;

		// Checking if the selected value of the element type is in the entire range of types.
		if ((selectedItemType > static_cast<size_t>(GameItem::Types::DEFAULT)) 
			&& (selectedItemType < static_cast<size_t>(GameItem::Types::DIFFICULT)))
		{
			isSelected = true;
			player = gameEntites[selectedItemType - 1];

			std::cout << "You selected: " << player->getName() << std::endl;
		}
		else std::cout << "Entered incorrect value!" << std::endl;
	}

	auto secondEntity = Random::getRandomItemFromVector<GameEntity*>(gameEntites);

	std::cout << "------------------------------ " << player->getName() << " <-> " << secondEntity->getName() << " ------------------------------" << std::endl;
	std::cout << "Result of the game: ";
	std::cout << ((player->getType() == secondEntity->getType()) ? "Draw" : player->fight(*secondEntity) ? "The player who chose the " + player->getName() + " wins!" : "The bot who chose the " + secondEntity->getName() + " wins!") << std::endl;

	std::for_each(gameEntites.begin(), gameEntites.end(), [](auto e) {delete e; });
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

#include <iostream>

#include <vector>

#include <algorithm>

#include <ctime>

// I did not distribute each individual class into header files, because this game is simple and I'm too lazy)

class GameItem

{

public:

enum class Types

{

DEFAULT,

STONE,

SCISSORS,

PAPER,

DIFFICULT

};

GameItem(Types type = Types::DEFAULT) : m_type{ type }

{

}

/// <summary>

/// Returns current type of object.

/// </summary>

/// <returns></returns>

Types getType()

{

return m_type;

}

/// <summary>

/// Returns true, if current object wins another.

/// </summary>

/// <param name="gameItem"></param>

/// <returns></returns>

virtual bool fight(const GameItem& gameItem) const

{

for (size_t i = 0; i < gameItem.getBeatableObjects().size(); ++i)

{

if (gameItem.getBeatableObjects()[i] == m_type) return false;

}

return true;

}

/// <summary>

/// Returns types of objects, which current object can win.

/// </summary>

/// <returns></returns>

const std::vector<Types>& getBeatableObjects() const

{

return m_beatable;

}

protected:

std::vector<Types> m_beatable;

Types m_type;

};

/// <summary>

/// It implies a game object that can influence the outcome of the game.

/// </summary>

class GameEntity : public GameItem

{

public:

GameEntity(Types type, const std::string& name) : GameItem(type), m_name{ name }

{

}

const std::string& getName() const

{

return m_name;

}

protected:

std::string m_name;

};

class Stone : public GameEntity

{

public:

Stone(const std::string& name) : GameEntity(Types::STONE, name)

{

m_beatable.push_back(Types::SCISSORS);

}

};

class Scissors : public GameEntity

{

public:

Scissors(const std::string& name) : GameEntity(Types::SCISSORS, name)

{

m_beatable.push_back(Types::PAPER);

}

};

class Random

{

public:

template <typename T>

static T getRandomItemFromVector(const std::vector<T>& items)

{

return items[abs(static_cast<int>(rand() % items.size()))];

}

};

class Paper : public GameEntity

{

public:

Paper(const std::string& name) : GameEntity(Types::PAPER, name)

{

m_beatable.push_back(Types::STONE);

}

};

class LanguageLocale

{

public:

static void SetRussian()

{

setlocale(LC_ALL, "Russian");

}

};

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

{

srand(time(0));

Stone* stone = new Stone("Stone");

Paper* paper = new Paper("Paper");

Scissors* scissors = new Scissors("Scissors");

// Èíòåðôåéñ äëÿ ïîëüçîâàòåëÿ

std::cout << "What do you want to select?" << std::endl;

std::cout << "1 - Stone" << std::endl;

std::cout << "2 - Scissors" << std::endl;

std::cout << "3 - Paper" << std::endl;

size_t selectedItemType{ 0 };

GameEntity* player = nullptr;

std::vector<GameEntity*> gameEntites{ stone, scissors, paper };

bool isSelected{ false };

while (!isSelected)

{

std::cout << "Enter: ";

std::cin >> selectedItemType;

// Checking if the selected value of the element type is in the entire range of types.

if ((selectedItemType > static_cast<size_t>(GameItem::Types::DEFAULT))

&& (selectedItemType < static_cast<size_t>(GameItem::Types::DIFFICULT)))

{

isSelected = true;

player = gameEntites[selectedItemType - 1];

std::cout << "You selected: " << player->getName() << std::endl;

}

else std::cout << "Entered incorrect value!" << std::endl;

}

auto secondEntity = Random::getRandomItemFromVector<GameEntity*>(gameEntites);

std::cout << "------------------------------ " << player->getName() << " <-> " << secondEntity->getName() << " ------------------------------" << std::endl;

std::cout << "Result of the game: ";

std::cout << ((player->getType() == secondEntity->getType()) ? "Draw" : player->fight(*secondEntity) ? "The player who chose the " + player->getName() + " wins!" : "The bot who chose the " + secondEntity->getName() + " wins!") << std::endl;

std::for_each(gameEntites.begin(), gameEntites.end(), [](auto e) {delete e; });

}

Ответить

WAR:

8 сентября 2021 в 22:14

Задание №3:

#include <iostream>
#include <ctime>
#include <string>

int main() {
std::srand(std::time(nullptr));
int diff{0};
while(diff < 1 || diff > 3) {
	std::cout << "Enter 1-3 level difficulty: ";
	std::cin >> diff;
	if(std::cin.fail()) {
		std::cin.clear();
		std::cin.ignore(32767, '\n');
		std::cout << "Error! Invalid input! Repeat input!\n";
	}
}
int len = diff == 1 ? 8 : diff == 2 ? 16 : 24;
std::string res;
char ch = '!';
int num{0};
for(int i{0}; i < len; ++i) {
	num = std::rand() % 93;
	res += (ch + num);
}
std::cout << "\nPassword: " << res;
return 0;
}

#include <iostream>

#include <ctime>

#include <string>

int main() {

std::srand(std::time(nullptr));

int diff{0};

while(diff < 1 || diff > 3) {

std::cout << "Enter 1-3 level difficulty: ";

std::cin >> diff;

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

std::cin.clear();

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

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

}

int len = diff == 1 ? 8 : diff == 2 ? 16 : 24;

std::string res;

char ch = '!';

int num{0};

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

num = std::rand() % 93;

res += (ch + num);

}

std::cout << "\nPassword: " << res;

return 0;

}

Ответить

WAR:

7 сентября 2021 в 11:53

Задание №1:

#include <iostream>

int main() {
int arr[]{1,1,2,4,5,9,14,22,37,54,
	87,90,111,243,345};
std::cout << "Array is: ";
for(int &i : arr) std::cout << i <<' ';
std::cout<<"\nElements in array more 5 is:\n";
for(int &i : arr) if(i > 5) std::cout << i << ' ';
int num;
std::cout<<"\nEnter number: "; std::cin >> num;
std::cout << "Less " << num << " in this array is: \n";
for(int &i : arr) if(i < num) std::cout << i <<' ';
return 0;
}

#include <iostream>

int main() {

int arr[]{1,1,2,4,5,9,14,22,37,54,

87,90,111,243,345};

std::cout << "Array is: ";

for(int &i : arr) std::cout << i <<' ';

std::cout<<"\nElements in array more 5 is:\n";

for(int &i : arr) if(i > 5) std::cout << i << ' ';

int num;

std::cout<<"\nEnter number: "; std::cin >> num;

std::cout << "Less " << num << " in this array is: \n";

for(int &i : arr) if(i < num) std::cout << i <<' ';

return 0;

}

Ответить

Petr:

30 июня 2021 в 15:21

Задание 3

#include<iostream>
#include<string>
#include<utility>

int getRandomNumber(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) + min);
}

int coolGetRandomNumber()
{
	while (true)
	{
		int a = getRandomNumber(65, 122);

		if (a != 91 && a != 92 && a != 93 && a != 94 && a != 95 && a != 96) return a;
	}
}

std::string shuffle(std::string password)
{
	std::string pass = password;
	for (int i = 0; i < 6; ++i)
	{
		std::swap(pass[getRandomNumber(0, 5)], pass[getRandomNumber(0, 5)]);
	}
	return pass;
}

const char* retStr(int a)
{
	switch (a)
	{
	case 0: return "0"; break;
	case 1: return "1"; break;
	case 2: return "2"; break;
	case 3: return "3"; break;
	case 4: return "4"; break;
	case 5: return "5"; break;
	case 6: return "6"; break;
	case 7: return "7"; break;
	case 8: return "8"; break;
	case 9: return "9"; break;
	}
}

std::string getPassword(int df)
{
	std::string password;

	if (df == 1)
	{
		int nums[6];
		for (int i = 0; i < 6; ++i)
		{
			nums[i] = getRandomNumber(0, 9);
			password += retStr(nums[i]);
		}
		password = shuffle(password);
		return password;
	}
	else if (df == 2)
	{
		int nums[6];
		for (int i = 0; i < 3; ++i)
		{
			nums[i] = getRandomNumber(0, 9);
			password += retStr(nums[i]);
		}

		for (int i = 3; i < 6; ++i)
		{
			nums[i] = coolGetRandomNumber();
			password += static_cast<char>(nums[i]);
		}

		password = shuffle(password);
		return password;
	}
	else if (df == 3)
	{
		int nums[6];
		for (int i = 0; i < 2; ++i)
		{
			nums[i] = getRandomNumber(0, 9);
			password += retStr(nums[i]);
		}
		for (int i = 2; i < 4; ++i)
		{
			nums[i] = coolGetRandomNumber();
			password += static_cast<char>(nums[i]);
		}
		for (int i = 4; i < 6; ++i)
		{
			nums[i] = getRandomNumber(35, 38);
			password += static_cast<char>(nums[i]);
		}

		password = shuffle(password);
		return password;
	}
}

int main()
{
	setlocale(LC_ALL, "rus");
	srand(static_cast<unsigned int>(time(0)));
	rand();
	
	while (true)
	{
		int df;
		while (true)
		{
			std::cout << "Выберите сложность(1, 2 или 3): ";
			std::cin >> df;
			std::cin.ignore(32767, '\n');

			if (std::cin.fail())
			{
				std::cin.clear();
				std::cin.ignore(32767, '\n');
			}
			else if (df > 0 && df < 4) break;
		}

		std::cout << "Пароль: " << getPassword(df) << "\n\n\n";
	}
}

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

#include<iostream>

#include<string>

#include<utility>

int getRandomNumber(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) + min);

}

int coolGetRandomNumber()

{

while (true)

{

int a = getRandomNumber(65, 122);

if (a != 91 && a != 92 && a != 93 && a != 94 && a != 95 && a != 96) return a;

}

std::string shuffle(std::string password)

{

std::string pass = password;

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

{

std::swap(pass[getRandomNumber(0, 5)], pass[getRandomNumber(0, 5)]);

}

return pass;

}

const char* retStr(int a)

{

switch (a)

{

case 0: return "0"; break;

case 1: return "1"; break;

case 2: return "2"; break;

case 3: return "3"; break;

case 4: return "4"; break;

case 5: return "5"; break;

case 6: return "6"; break;

case 7: return "7"; break;

case 8: return "8"; break;

case 9: return "9"; break;

}

std::string getPassword(int df)

{

std::string password;

if (df == 1)

{

int nums[6];

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

{

nums[i] = getRandomNumber(0, 9);

password += retStr(nums[i]);

}

password = shuffle(password);

return password;

}

else if (df == 2)

{

int nums[6];

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

{

nums[i] = getRandomNumber(0, 9);

password += retStr(nums[i]);

}

for (int i = 3; i < 6; ++i)

{

nums[i] = coolGetRandomNumber();

password += static_cast<char>(nums[i]);

}

password = shuffle(password);

return password;

}

else if (df == 3)

{

int nums[6];

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

{

nums[i] = getRandomNumber(0, 9);

password += retStr(nums[i]);

}

for (int i = 2; i < 4; ++i)

{

nums[i] = coolGetRandomNumber();

password += static_cast<char>(nums[i]);

}

for (int i = 4; i < 6; ++i)

{

nums[i] = getRandomNumber(35, 38);

password += static_cast<char>(nums[i]);

}

password = shuffle(password);

return password;

}

int main()

{

setlocale(LC_ALL, "rus");

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

rand();

while (true)

{

int df;

while (true)

{

std::cout << "Выберите сложность(1, 2 или 3): ";

std::cin >> df;

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

if (std::cin.fail())

{

std::cin.clear();

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

}

else if (df > 0 && df < 4) break;

}

std::cout << "Пароль: " << getPassword(df) << "\n\n\n";

}

Ответить

Rock:

29 апреля 2021 в 15:00

Задание 1:

#include<iostream>

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

	int x[] { 1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345 };
	int x_size = sizeof(x)/4;

	for (int i = 0; i < x_size; i++)
	{
		if(x[i]>5)
		std::cout << x[i]<<" ";

		if (i + 1 == x_size)
			std::cout << std::endl;
	}

	int y;
	std::cout << "Введите число которое станет верхним порогом дял вывода" << std::endl;
	std::cin >> y;

	for (int i = 0; i < x_size; i++)
	{
		if (x[i] > 5 && x[i]<y)
			std::cout << x[i] << " ";

		if (i + 1 == x_size)
			std::cout << std::endl;
	}

	return 0;
}

#include<iostream>

int main()

{

setlocale(0, "");

int x[] { 1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345 };

int x_size = sizeof(x)/4;

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

{

if(x[i]>5)

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

if (i + 1 == x_size)

std::cout << std::endl;

}

int y;

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

std::cin >> y;

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

{

if (x[i] > 5 && x[i]<y)

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

if (i + 1 == x_size)

std::cout << std::endl;

}

return 0;

}

Задание 2:

#include<iostream>

class Game
{
	enum objects
	{
		STONE,
		PAPER,
		SCISSORS,
	};


private:

	int player_score = 0, bot_score = 0;
	bool game_start = 0;
	objects player_obj, bot_obj;


	void Info()
	{
		system("cls");
		std::cout << "Вас приветствует игра \"Камень,Ножницы,Бумага\". \n" <<
			"Ваша задача набрать 3 очка против компьютера выбирая один из предложенных предметов." << std::endl;

		game_start = 1;
		system("pause");
	}

	void Player_turn()
	{
		system("cls");
		int x;
		std::cout << "Выберите один из трех предметов. \n" <<
			"1)Камень\n" <<
			"2)Бумага\n" <<
			"3)Ножницы" << std::endl;
		std::cin >> x;
		
		switch (x)
		{
		case 1:
			player_obj = STONE;
			break;
		case 2:
			player_obj = PAPER;
			break;
		case 3:
			player_obj = SCISSORS;
			break;
		default:
			std::cout << "Введите 1-3!\n";
			system("pause");
			Player_turn();
			break;
		}
	}

	void Bot_turn()
	{
		system("cls");
		int x = 1 + rand() % (3);
		switch (x)
		{
		case 1:
			bot_obj = STONE;
			break;
		case 2:
			bot_obj = PAPER;
			break;
		case 3:
			bot_obj = SCISSORS;
			break;
		}
	}


	bool Game_Logick()
	{
		system("cls");

		if (player_obj == STONE && bot_obj == STONE) 
		{
			std::cout << "У вас камень и у противника то же.Ничья.\n";
			system("pause");
			return 0; 
		}
		if (player_obj == STONE && bot_obj == PAPER) 
		{
			std::cout << "У вас камень а у противника бумага.Очко в пользу противника.\n";
			system("pause");
			bot_score++; return 1; 
		}
		
		if (player_obj == STONE && bot_obj == SCISSORS) 
		{
			std::cout << "У вас камень а у противника ножницы.Очко в вашу пользу.\n";
			system("pause");
			player_score++; return 1;
		}

		if (player_obj == PAPER && bot_obj == STONE) 
		{
			std::cout << "У вас бумага а у противника камень.Очко в вашу пользу.\n";
			system("pause");
			player_score++; return 1;
		}
		if (player_obj == PAPER && bot_obj == PAPER) 
		{
			std::cout << "У вас бумага и у противника бумага.Ничья.\n";
			system("pause");
			return 0;
		}
		if (player_obj == PAPER && bot_obj == SCISSORS) 
		{
			std::cout << "У вас бумага а у противника ножницы.Очко в пользу противника.\n";
			system("pause");
			bot_score++; return 1; 
		}

		if (player_obj == SCISSORS && bot_obj == STONE) 
		{
			std::cout << "У вас ножницы а у противника камень.Очко в пользу противника.\n";
			system("pause");
			bot_score++; return 1;
		}
		if (player_obj == SCISSORS && bot_obj == PAPER) 
		{
			std::cout << "У вас ножницы а у противника бумага.Очко в вашу пользу.\n";
			system("pause");
			player_score++; return 1; 
		}
		if (player_obj == SCISSORS && bot_obj == SCISSORS) 
		{
			std::cout << "У вас ножницы и у противника ножницы.Ничья.\n";
			system("pause");
			return 0; 
		}
	}

	bool Game_end()
	{
		if (player_score == 3 || bot_score == 3)
		{
			system("cls");
			if (player_score == 3)
			{
				std::cout << "У вас 3 очка, вы победили!\n";
			}
			else
			{
				std::cout << "У компьютера 3 очка, вы проиграли!\n";
				
			}
			system("pause");
			return 1;
		}
		else
			return 0;

	}


public:

	void Game_start()
	{
		while (true)
		{
			if (!game_start)
				Info();

			Player_turn();
			Bot_turn();
			Game_Logick();
			if (Game_end())
				break;
			
		}
	}

};


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

	Game game;
	game.Game_start();

	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

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

#include<iostream>

class Game

{

enum objects

{

STONE,

PAPER,

SCISSORS,

};

private:

int player_score = 0, bot_score = 0;

bool game_start = 0;

objects player_obj, bot_obj;

void Info()

{

system("cls");

std::cout << "Вас приветствует игра \"Камень,Ножницы,Бумага\". \n" <<

"Ваша задача набрать 3 очка против компьютера выбирая один из предложенных предметов." << std::endl;

game_start = 1;

system("pause");

}

void Player_turn()

{

system("cls");

int x;

std::cout << "Выберите один из трех предметов. \n" <<

"1)Камень\n" <<

"2)Бумага\n" <<

"3)Ножницы" << std::endl;

std::cin >> x;

switch (x)

{

case 1:

player_obj = STONE;

break;

case 2:

player_obj = PAPER;

break;

case 3:

player_obj = SCISSORS;

break;

default:

std::cout << "Введите 1-3!\n";

system("pause");

Player_turn();

break;

}

void Bot_turn()

{

system("cls");

int x = 1 + rand() % (3);

switch (x)

{

case 1:

bot_obj = STONE;

break;

case 2:

bot_obj = PAPER;

break;

case 3:

bot_obj = SCISSORS;

break;

}

bool Game_Logick()

{

system("cls");

if (player_obj == STONE && bot_obj == STONE)

{

std::cout << "У вас камень и у противника то же.Ничья.\n";

system("pause");

return 0;

}

if (player_obj == STONE && bot_obj == PAPER)

{

std::cout << "У вас камень а у противника бумага.Очко в пользу противника.\n";

system("pause");

bot_score++; return 1;

}

if (player_obj == STONE && bot_obj == SCISSORS)

{

std::cout << "У вас камень а у противника ножницы.Очко в вашу пользу.\n";

system("pause");

player_score++; return 1;

}

if (player_obj == PAPER && bot_obj == STONE)

{

std::cout << "У вас бумага а у противника камень.Очко в вашу пользу.\n";

system("pause");

player_score++; return 1;

}

if (player_obj == PAPER && bot_obj == PAPER)

{

std::cout << "У вас бумага и у противника бумага.Ничья.\n";

system("pause");

return 0;

}

if (player_obj == PAPER && bot_obj == SCISSORS)

{

std::cout << "У вас бумага а у противника ножницы.Очко в пользу противника.\n";

system("pause");

bot_score++; return 1;

}

if (player_obj == SCISSORS && bot_obj == STONE)

{

std::cout << "У вас ножницы а у противника камень.Очко в пользу противника.\n";

system("pause");

bot_score++; return 1;

}

if (player_obj == SCISSORS && bot_obj == PAPER)

{

std::cout << "У вас ножницы а у противника бумага.Очко в вашу пользу.\n";

system("pause");

player_score++; return 1;

}

if (player_obj == SCISSORS && bot_obj == SCISSORS)

{

std::cout << "У вас ножницы и у противника ножницы.Ничья.\n";

system("pause");

return 0;

}

bool Game_end()

{

if (player_score == 3 || bot_score == 3)

{

system("cls");

if (player_score == 3)

{

std::cout << "У вас 3 очка, вы победили!\n";

}

else

{

std::cout << "У компьютера 3 очка, вы проиграли!\n";

}

system("pause");

return 1;

}

else

return 0;

}

public:

void Game_start()

{

while (true)

{

if (!game_start)

Info();

Player_turn();

Bot_turn();

Game_Logick();

if (Game_end())

break;

}

};

int main()

{

setlocale(0, "");

Game game;

game.Game_start();

return 0;

}

Задание 3:

#include <iostream>


std::string LowerСase{ "abcdefjhigklmnopqrstuvwxyz" };
std::string UpperCase{ "ABCDEFJHIGKLMNOPQRSTUVWXYZ" };
std::string Numbers  { "1234567890" };
std::string Symbols  { "!@#$%^&*()-=_+/\\?.,{}`~:;\"'" };
 


void Generation_pass(bool LC,bool UC,bool N,bool S,int lenght)
{
	std::string password;

	while (true)
	{

		switch (1 + rand() % 4)
		{
		case 1:
			if (LC)
			{
				password += LowerСase[rand() % 26];
			}
			break;
		case 2:
			if (UC)
			{
				password += UpperCase[rand() % 26];
			}
			break;
		case 3:
			if (N)
			{
				password += Numbers[rand() % 10];
			}
			break;
		case 4:
			if (S)
			{
				int x = rand() % 26;
				password += Symbols[x];
			}
			break;
		default:
			break;
		}

		if (password.size() == lenght)
		{
			std::cout << password << std::endl;
			system("pause");
			system("cls");
			return;
		}
	}
}

std::string bool_interprit(bool x)
{
	if (x)
		return "ВКЛ";
	else
		return "ВЫКЛ";
}

void set_Lenght(int& lenght)
{
	system("cls");
	std::cout << "Введите желаемую длину ";
	std::cin >> lenght;
	system("cls");
}


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

	bool l_char=0, up_char=0, number=0,symbol=0;
	int lenght=0;

	while (true)
	{
		int menu;

		std::cout << "\t\t\t\tГенератор паролей\n\n"
			<< "1)Алфавит в нижнем регистре     \t" << bool_interprit(l_char) << std::endl
			<< "2)Алфавит в верхнем регистре    \t" << bool_interprit(up_char) << std::endl
			<< "3)Цифры                         \t" << bool_interprit(number) << std::endl
			<< "4)Различные клавиатурные знаки  \t" << bool_interprit(symbol) << std::endl
			<< "5)Указать длину пароля    (сейчас длина = "<<lenght<<" )" << std::endl
			<< "6)Генерация" << std::endl;

		std::cin >> menu;

		switch (menu)
		{
		case 1:
			if (!l_char)
				l_char = 1;
			else
				l_char = 0;
			system("cls");
			break;
		case 2:
			if (!up_char)
				up_char = 1;
			else
				up_char = 0;
			system("cls");
			break;
		case 3:
			if (!number)
				number = 1;
			else
				number = 0;
			system("cls");
			break;
		case 4:
			if (!symbol)
				symbol = 1;
			else
				symbol = 0;
			system("cls");
			break;
		case 5:
			set_Lenght(lenght);
			break;
		case 6:
			system("cls");
			Generation_pass(l_char, up_char, number, symbol, lenght);
			break;
		default:
			std::cout << "Некорректный ввод\n";
			system("pause");
			system("cls");
			break;
		}

		
	}

	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

143

144

145

#include <iostream>

std::string LowerСase{ "abcdefjhigklmnopqrstuvwxyz" };

std::string UpperCase{ "ABCDEFJHIGKLMNOPQRSTUVWXYZ" };

std::string Numbers { "1234567890" };

std::string Symbols { "!@#$%^&*()-=_+/\\?.,{}`~:;\"'" };

void Generation_pass(bool LC,bool UC,bool N,bool S,int lenght)

{

std::string password;

while (true)

{

switch (1 + rand() % 4)

{

case 1:

if (LC)

{

password += LowerСase[rand() % 26];

}

break;

case 2:

if (UC)

{

password += UpperCase[rand() % 26];

}

break;

case 3:

if (N)

{

password += Numbers[rand() % 10];

}

break;

case 4:

if (S)

{

int x = rand() % 26;

password += Symbols[x];

}

break;

default:

break;

}

if (password.size() == lenght)

{

std::cout << password << std::endl;

system("pause");

system("cls");

return;

}

std::string bool_interprit(bool x)

{

if (x)

return "ВКЛ";

else

return "ВЫКЛ";

}

void set_Lenght(int& lenght)

{

system("cls");

std::cout << "Введите желаемую длину ";

std::cin >> lenght;

system("cls");

}

int main()

{

setlocale(0, "");

bool l_char=0, up_char=0, number=0,symbol=0;

int lenght=0;

while (true)

{

int menu;

std::cout << "\t\t\t\tГенератор паролей\n\n"

<< "1)Алфавит в нижнем регистре \t" << bool_interprit(l_char) << std::endl

<< "2)Алфавит в верхнем регистре \t" << bool_interprit(up_char) << std::endl

<< "3)Цифры \t" << bool_interprit(number) << std::endl

<< "4)Различные клавиатурные знаки \t" << bool_interprit(symbol) << std::endl

<< "5)Указать длину пароля (сейчас длина = "<<lenght<<" )" << std::endl

<< "6)Генерация" << std::endl;

std::cin >> menu;

switch (menu)

{

case 1:

if (!l_char)

l_char = 1;

else

l_char = 0;

system("cls");

break;

case 2:

if (!up_char)

up_char = 1;

else

up_char = 0;

system("cls");

break;

case 3:

if (!number)

number = 1;

else

number = 0;

system("cls");

break;

case 4:

if (!symbol)

symbol = 1;

else

symbol = 0;

system("cls");

break;

case 5:

set_Lenght(lenght);

break;

case 6:

system("cls");

Generation_pass(l_char, up_char, number, symbol, lenght);

break;

default:

std::cout << "Некорректный ввод\n";

system("pause");

system("cls");

break;

}

return 0;

}

Ответить

Максим:

30 января 2021 в 17:54

Задание 3

#include <iostream>
#include <cstdlib>	// rand()
#include <ctime>	// time()
#include <limits>	// numeric_limits
#include <string>

enum Complexity {
	EASY = 1,
	NORMAL,
	HARD
};

enum Symbol_Type {
	LOWERCASE = 1,
	UPPERCASE,
	NUMBER,
	SYMBOL
};

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

void get_random_password(std::string& password, const int length, Symbol_Type type_max) {
	password.resize(length);
	for (char& symbol : password) {
		int dice_roll{ get_random_number(LOWERCASE, type_max) };
		switch (dice_roll) {
		case LOWERCASE:
			symbol = get_random_number('a', 'z');
			break;
		case UPPERCASE:
			symbol = get_random_number('A', 'Z');
			break;
		case NUMBER:
			symbol = get_random_number('0', '9');
			break;
		case SYMBOL:
			dice_roll = get_random_number(1, 4); // roll symbol group
			switch (dice_roll) {
			case 1:
				symbol = get_random_number('!', '/');
				break;
			case 2:
				symbol = get_random_number(':', '@');
				break;
			case 3:
				symbol = get_random_number('[', '`');
				break;
			case 4:
				symbol = get_random_number('{', '~');
				break;
			}
			break;
		}
	}
}

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

	const int length_easy{ 8 },
		length_normal{ 12 },
		length_hard{ 16 };

	std::cout << "Password complexity list:\n"
		"1 - easy:"
			"\n\tlength = " << length_easy <<
			"\n\tusing lowercase and uppercase letters\n"
		"2 - normal:"
			"\n\tlength = " << length_normal <<
			"\n\tusing lowercase and uppercase letters with numbers\n"
		"3 - hard:"
			"\n\tlength = " << length_hard <<
			"\n\tusing lowercase and uppercase letters with numbers and symbols\n\n";

	while (true) {
		std::cout << "Select password complexity from list: ";
		int complexity{};
		while (!(std::cin >> complexity) || (complexity < EASY || complexity > HARD)) {
			std::cout << "Not handled decision, try again: ";
			std::cin.clear();
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		}

		std::string password;
		switch (complexity) {
		case EASY:
			get_random_password(password, length_easy, UPPERCASE);
			std::cout << "Genereted easy";
			break;
		case NORMAL:
			get_random_password(password, length_normal, NUMBER);
			std::cout << "Genereted normal";
			break;
		case HARD:
			get_random_password(password, length_hard, SYMBOL);
			std::cout << "Genereted hard";
			break;
		}
		std::cout << " password:\t" << password << '\n';

		std::cout << "\nGenerate another password, y/n? ";
		char select{};
		while (!(std::cin >> select) || (select != 'y' && select != 'n')) {
			std::cout << "Not handled decision, try again: ";
			std::cin.clear();
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		}
		if (select == 'n') {
			break;
		}
	}
	return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

#include <iostream>

#include <cstdlib> // rand()

#include <ctime> // time()

#include <limits> // numeric_limits

#include <string>

enum Complexity {

EASY = 1,

NORMAL,

HARD

};

enum Symbol_Type {

LOWERCASE = 1,

UPPERCASE,

NUMBER,

SYMBOL

};

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

}

void get_random_password(std::string& password, const int length, Symbol_Type type_max) {

password.resize(length);

for (char& symbol : password) {

int dice_roll{ get_random_number(LOWERCASE, type_max) };

switch (dice_roll) {

case LOWERCASE:

symbol = get_random_number('a', 'z');

break;

case UPPERCASE:

symbol = get_random_number('A', 'Z');

break;

case NUMBER:

symbol = get_random_number('0', '9');

break;

case SYMBOL:

dice_roll = get_random_number(1, 4); // roll symbol group

switch (dice_roll) {

case 1:

symbol = get_random_number('!', '/');

break;

case 2:

symbol = get_random_number(':', '@');

break;

case 3:

symbol = get_random_number('[', '`');

break;

case 4:

symbol = get_random_number('{', '~');

break;

}

break;

}

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

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

rand();

const int length_easy{ 8 },

length_normal{ 12 },

length_hard{ 16 };

std::cout << "Password complexity list:\n"

"1 - easy:"

"\n\tlength = " << length_easy <<

"\n\tusing lowercase and uppercase letters\n"

"2 - normal:"

"\n\tlength = " << length_normal <<

"\n\tusing lowercase and uppercase letters with numbers\n"

"3 - hard:"

"\n\tlength = " << length_hard <<

"\n\tusing lowercase and uppercase letters with numbers and symbols\n\n";

while (true) {

std::cout << "Select password complexity from list: ";

int complexity{};

while (!(std::cin >> complexity) || (complexity < EASY || complexity > HARD)) {

std::cout << "Not handled decision, try again: ";

std::cin.clear();

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

}

std::string password;

switch (complexity) {

case EASY:

get_random_password(password, length_easy, UPPERCASE);

std::cout << "Genereted easy";

break;

case NORMAL:

get_random_password(password, length_normal, NUMBER);

std::cout << "Genereted normal";

break;

case HARD:

get_random_password(password, length_hard, SYMBOL);

std::cout << "Genereted hard";

break;

}

std::cout << " password:\t" << password << '\n';

std::cout << "\nGenerate another password, y/n? ";

char select{};

while (!(std::cin >> select) || (select != 'y' && select != 'n')) {

std::cout << "Not handled decision, try again: ";

std::cin.clear();

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

}

if (select == 'n') {

break;

}

return 0;

}

Ответить

Kir:

6 января 2021 в 17:01

Задание 3

main.cpp

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

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


enum PassDifficulty// сложность пароля
{
	LIGHT,
	MEDIEM,
	STRONG
};

enum CharGroups //группы char
{
	DIGITS,
	UPPER_CASE,
	LOWER_CASE,
	SYMBOLS,
	GROUPS_COUNT
};

CharGroups getGroupId(std::vector<CharGroups>& usedCharGroups, int currentCharIndex, int passSize)//генерация id char
{
	CharGroups charGroupId;
	while (true)
	{
		charGroupId = static_cast<CharGroups> (getRandomNumber(CharGroups::DIGITS, CharGroups::SYMBOLS));
		auto result = std::find(usedCharGroups.begin(), usedCharGroups.end(), charGroupId); // проверяем что эта группа char есть в пароле

		if (passSize - currentCharIndex <= CharGroups::GROUPS_COUNT) //если заполнение пароля подходит к концу,но не все группы char использованы
		{
			if (usedCharGroups.size() > 0) //если не все группы char использованы
			{
				if (result == usedCharGroups.end()) continue; //заново генерируем, если эта группа char уже есть в пароле
			}
		}

		if (result != usedCharGroups.end()) //если такой группы в пароле нет в
		{
			usedCharGroups.erase(result); //отмечаем, что группа char есть в пароле
		}
		break;
	}
	return charGroupId;
}

void setChar(std::string& pass, int index, std::vector<CharGroups>& usedCharGroups) //заполнение char пароля
{
	CharGroups charGroupId = getGroupId(usedCharGroups, index, pass.size()); //выбираем из какой группы char будет следующий char
	switch (charGroupId)
	{
	case CharGroups::DIGITS:
		pass[index] = static_cast<char> (getRandomNumber(48, 57));
		break;
	case CharGroups::UPPER_CASE:
		pass[index] = static_cast<char> (getRandomNumber(65, 90));
		break;
	case CharGroups::LOWER_CASE:
		pass[index] = static_cast<char> (getRandomNumber(97, 122));
		break;
	case CharGroups::SYMBOLS:
		switch (getRandomNumber(0, 3))
		{
		case 0:
			pass[index] = static_cast<char> (getRandomNumber(33, 47));
			break;
		case 1:
			pass[index] = static_cast<char> (getRandomNumber(58, 64));
			break;
		case 2:
			pass[index] = static_cast<char> (getRandomNumber(91, 96));
			break;
		case 3:
			pass[index] = static_cast<char> (getRandomNumber(123, 126));
			break;
		}
		break;
	}
}

int getPassSize(PassDifficulty passDifficulty) //генерация размера пароля
{
	switch (passDifficulty)
	{
	case LIGHT:
		return getRandomNumber(5, 7);
	case MEDIEM:
		return getRandomNumber(8, 15);
	case STRONG:
		return getRandomNumber(16, 20);
	}
	return getRandomNumber(4, 4); //чтобы хоть какой то минимальный размер задался, если вдруг чтото с PassDifficulty
}

void passGenerator(std::string& pass, PassDifficulty passDifficulty)
{
	pass.clear();
	int passSize{getPassSize(passDifficulty)};
	pass.resize(passSize);
	std::vector<CharGroups> usedCharGroups; //массив служащий для проверки наличия всех групп char в пароле
	usedCharGroups.push_back(CharGroups::DIGITS);
	usedCharGroups.push_back(CharGroups::UPPER_CASE);
	usedCharGroups.push_back(CharGroups::LOWER_CASE);
	usedCharGroups.push_back(CharGroups::SYMBOLS);
	for (int i = 0; i < passSize; ++i)
	{
		setChar(pass, i, usedCharGroups);
	}
}

int main()
{
	std::string pass;
	passGenerator(pass, PassDifficulty::STRONG);
	std::cout << pass;
	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

#include <iostream>

#include <algorithm>

#include <vector>

#include "UserInput.h"

#include "RandNumber.h"

/**

Напишите генератор паролей.

* Составьте три уровня сложности генерации паролей (включая их длину)

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

* какой уровень сложности ему нужен.

* Проявите свою изобретательность:

* надежные пароли должны состоять из сочетания

* строчных букв,

* прописных букв,

* цифр и символов.

* Пароли должны генерироваться случайным образом

* каждый раз, когда пользователь запрашивает новый пароль.

enum PassDifficulty// сложность пароля

{

LIGHT,

MEDIEM,

STRONG

};

enum CharGroups //группы char

{

DIGITS,

UPPER_CASE,

LOWER_CASE,

SYMBOLS,

GROUPS_COUNT

};

CharGroups getGroupId(std::vector<CharGroups>& usedCharGroups, int currentCharIndex, int passSize)//генерация id char

{

CharGroups charGroupId;

while (true)

{

charGroupId = static_cast<CharGroups> (getRandomNumber(CharGroups::DIGITS, CharGroups::SYMBOLS));

auto result = std::find(usedCharGroups.begin(), usedCharGroups.end(), charGroupId); // проверяем что эта группа char есть в пароле

if (passSize - currentCharIndex <= CharGroups::GROUPS_COUNT) //если заполнение пароля подходит к концу,но не все группы char использованы

{

if (usedCharGroups.size() > 0) //если не все группы char использованы

{

if (result == usedCharGroups.end()) continue; //заново генерируем, если эта группа char уже есть в пароле

}

if (result != usedCharGroups.end()) //если такой группы в пароле нет в

{

usedCharGroups.erase(result); //отмечаем, что группа char есть в пароле

}

break;

}

return charGroupId;

}

void setChar(std::string& pass, int index, std::vector<CharGroups>& usedCharGroups) //заполнение char пароля

{

CharGroups charGroupId = getGroupId(usedCharGroups, index, pass.size()); //выбираем из какой группы char будет следующий char

switch (charGroupId)

{

case CharGroups::DIGITS:

pass[index] = static_cast<char> (getRandomNumber(48, 57));

break;

case CharGroups::UPPER_CASE:

pass[index] = static_cast<char> (getRandomNumber(65, 90));

break;

case CharGroups::LOWER_CASE:

pass[index] = static_cast<char> (getRandomNumber(97, 122));

break;

case CharGroups::SYMBOLS:

switch (getRandomNumber(0, 3))

{

case 0:

pass[index] = static_cast<char> (getRandomNumber(33, 47));

break;

case 1:

pass[index] = static_cast<char> (getRandomNumber(58, 64));

break;

case 2:

pass[index] = static_cast<char> (getRandomNumber(91, 96));

break;

case 3:

pass[index] = static_cast<char> (getRandomNumber(123, 126));

break;

}

break;

}

int getPassSize(PassDifficulty passDifficulty) //генерация размера пароля

{

switch (passDifficulty)

{

case LIGHT:

return getRandomNumber(5, 7);

case MEDIEM:

return getRandomNumber(8, 15);

case STRONG:

return getRandomNumber(16, 20);

}

return getRandomNumber(4, 4); //чтобы хоть какой то минимальный размер задался, если вдруг чтото с PassDifficulty

}

void passGenerator(std::string& pass, PassDifficulty passDifficulty)

{

pass.clear();

int passSize{getPassSize(passDifficulty)};

pass.resize(passSize);

std::vector<CharGroups> usedCharGroups; //массив служащий для проверки наличия всех групп char в пароле

usedCharGroups.push_back(CharGroups::DIGITS);

usedCharGroups.push_back(CharGroups::UPPER_CASE);

usedCharGroups.push_back(CharGroups::LOWER_CASE);

usedCharGroups.push_back(CharGroups::SYMBOLS);

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

{

setChar(pass, i, usedCharGroups);

}

int main()

{

std::string pass;

passGenerator(pass, PassDifficulty::STRONG);

std::cout << pass;

return 0;

}

RandNumber.h

#ifndef RANDNUMBER_H
#define RANDNUMBER_H

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

#endif /* 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));
}

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

}

UserInput.h

#ifndef USERINPUT_H
#define USERINPUT_H

template<typename T>
void checkUserNumber(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 checkUserNumber(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 checkUserIntNumberByString(std::string& number)
{
	while (true)
	{
		//считывание чисел
		getline(std::cin, number);
		//проверяем введенные значения
		if (!isCorrectInput(number))
		{
			continue;
		}
		break;
	}
}

bool checkYesNo()
{
	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 */

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 checkUserNumber(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 checkUserNumber(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 checkUserIntNumberByString(std::string& number)

{

while (true)

{

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

getline(std::cin, number);

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

if (!isCorrectInput(number))

{

continue;

}

break;

}

bool checkYesNo()

{

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 */

Ответить

Kir:

6 января 2021 в 10:32

Задание №1

main.cpp

#include <iostream>
#include "UserInput.h"

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

а = [1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345]

Затем спросите у пользователя
 * число.
 * Выведите числа из вышеприведенного массива,
 * которые меньше числа, введенного пользователем.

 */

void print(int* arr, size_t size, bool (*comparisonFcn)(int, int), int value)
{
	for (int i = 0; i < size; ++i)
	{
		if (comparisonFcn(arr[i], value))
		{
			std::cout << arr[i] << ' ';
		}
	}
	std::cout << "\n";
}

bool isGreater(int value1, int value2)
{
	return value1 > value2;
}

bool isLower(int value1, int value2)
{
	return value1 < value2;
};

int main()
{
	int arr[15] = {1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345};
	std::cout << "Оригинальный массив\n";
	print(arr, 15, isGreater, 0);
	std::cout << "Значения массива, которые больше 5\n";
	print(arr, 15, isGreater, 5);
	int userValue = 0;
	std::cout << "Введите значение для сравения\n";
	checkUserNumber(userValue);
	std::cout << "Значения массива, которые меньше " << userValue << '\n';
	print(arr, 15, isLower, userValue);
	return 0;
}

#include <iostream>

#include "UserInput.h"

/**

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

* которая выведет

* все элементы больше 5 из следующего массива:

а = [1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345]

Затем спросите у пользователя

* число.

* Выведите числа из вышеприведенного массива,

* которые меньше числа, введенного пользователем.

void print(int* arr, size_t size, bool (*comparisonFcn)(int, int), int value)

{

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

{

if (comparisonFcn(arr[i], value))

{

std::cout << arr[i] << ' ';

}

std::cout << "\n";

}

bool isGreater(int value1, int value2)

{

return value1 > value2;

}

bool isLower(int value1, int value2)

{

return value1 < value2;

};

int main()

{

int arr[15] = {1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345};

std::cout << "Оригинальный массив\n";

print(arr, 15, isGreater, 0);

std::cout << "Значения массива, которые больше 5\n";

print(arr, 15, isGreater, 5);

int userValue = 0;

std::cout << "Введите значение для сравения\n";

checkUserNumber(userValue);

std::cout << "Значения массива, которые меньше " << userValue << '\n';

print(arr, 15, isLower, userValue);

return 0;

}

UserInput.h

#ifndef USERINPUT_H
#define USERINPUT_H

template<typename T>
void checkUserNumber(T& userNumber, int min, int 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 checkUserNumber(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 checkUserIntNumberByString(std::string& number)
{
	while (true)
	{
		//считывание чисел
		getline(std::cin, number);
		//проверяем введенные значения
		if (!isCorrectInput(number))
		{
			continue;
		}
		break;
	}
}


#endif /* USERINPUT_H */

#ifndef USERINPUT_H

#define USERINPUT_H

template<typename T>

void checkUserNumber(T& userNumber, int min, int 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 checkUserNumber(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 checkUserIntNumberByString(std::string& number)

{

while (true)

{

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

getline(std::cin, number);

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

if (!isCorrectInput(number))

{

continue;

}

break;

}

#endif /* USERINPUT_H */

Ответить

Анастасия:

26 мая 2020 в 13:57

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

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

enum class Levels{low = 1, medium, complex};

Levels get_level()
{
	std::cout << "What kind of password do you need?\n" 
		<< static_cast<unsigned short>(Levels::low) << " - simple\n" 
		<< static_cast<unsigned short>(Levels::medium) << " - ordinary\n" 
		<< static_cast<unsigned short>(Levels::complex) << " - complex\n";
	int answer;
	std::cin >> answer;
	while (std::cin.fail() || (answer < static_cast<unsigned short>(Levels::low)) || (answer > static_cast<unsigned short>(Levels::complex)))
	{
		std::cin.clear();
		std::cin.ignore(32767, '\n');
		std::cout << "you should input a number from " << static_cast<unsigned short>(Levels::low) 
			      << " to " << static_cast<unsigned short>(Levels::complex) << ": ";
		std::cin >> answer;
	}
	return static_cast<Levels>(answer);
}

std::string create_password(Levels level)
{
	// наборы символов для генерации паролей разного уровня:
	const static std::string small_letters { "abcdefghijklmnopqrstuvwxyz" };
	const static std::string big_letters   { "ABCDEFGHIJKLMOPQRSTUVWXYZ" };
	const static std::string figures       { "1234567890" };
	const static std::string symbols       { "~!#$%^&*-_+,.;:()" };

	std::string password;
	unsigned short length = 0;
	switch (level)
	{
	case Levels::low:
		length = rand() % 3 + 6; // длина простого пароля - от 6 до 8
		// весь пароль - маленькие буквы
		for (unsigned short i = 0; i < length; i++)
			password += small_letters[rand() % small_letters.size()];
		break;
	case Levels::medium:
		length = rand() % 3 + 8; // длина среднего пароля - от 8 до 10
		// половина букв - маленькие, половина - большие, если нечётная длина, добавляем одну цифру
		for (unsigned short i = 0; i < length / 2; i++)
			password += small_letters[rand() % small_letters.size()];
		for (unsigned short i = 0; i < length / 2; i++)
			password += big_letters[rand() % big_letters.size()];
		if (password.size() < length)
			password += figures[rand() % figures.size()];
		break;
	case Levels::complex:
		length = rand() %11 + 10; // длина сложного пароля - от 10 до 20
		// по четверти длины на разные группы символов, если ещё осталась длина - добавляем маленьких букв
		for (unsigned short i = 0; i < length / 4; i++)
			password += small_letters[rand() % small_letters.size()];
		for (unsigned short i = 0; i < length / 4; i++)
			password += big_letters[rand() % big_letters.size()];
		for (unsigned short i = 0; i < length / 4; i++)
			password += figures[rand() % figures.size()];
		for (unsigned short i = 0; i < length / 4; i++)
			password += symbols[rand() % symbols.size()];
		while (password.size() < (length-1))
			password += small_letters[rand() % small_letters.size()];
		break;
	default:
		break;
	}

	// теперь перемешиваем символы в пароле, чтобы символы одного вида не шли подряд:
	std::random_device rd;
	std::mt19937 g(rd());
	std::shuffle(password.begin(), password.end(), g);

	return password;
}

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

	Levels level = get_level();
	std::cout << "Your new password is: " << create_password(level) << std::endl << std::endl;

	return 0;
}

#include <iostream>

#include <string>

#include <random>

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

enum class Levels{low = 1, medium, complex};

Levels get_level()

{

std::cout << "What kind of password do you need?\n"

<< static_cast<unsigned short>(Levels::low) << " - simple\n"

<< static_cast<unsigned short>(Levels::medium) << " - ordinary\n"

<< static_cast<unsigned short>(Levels::complex) << " - complex\n";

int answer;

std::cin >> answer;

while (std::cin.fail() || (answer < static_cast<unsigned short>(Levels::low)) || (answer > static_cast<unsigned short>(Levels::complex)))

{

std::cin.clear();

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

std::cout << "you should input a number from " << static_cast<unsigned short>(Levels::low)

<< " to " << static_cast<unsigned short>(Levels::complex) << ": ";

std::cin >> answer;

}

return static_cast<Levels>(answer);

}

std::string create_password(Levels level)

{

// наборы символов для генерации паролей разного уровня:

const static std::string small_letters { "abcdefghijklmnopqrstuvwxyz" };

const static std::string big_letters { "ABCDEFGHIJKLMOPQRSTUVWXYZ" };

const static std::string figures { "1234567890" };

const static std::string symbols { "~!#$%^&*-_+,.;:()" };

std::string password;

unsigned short length = 0;

switch (level)

{

case Levels::low:

length = rand() % 3 + 6; // длина простого пароля - от 6 до 8

// весь пароль - маленькие буквы

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

password += small_letters[rand() % small_letters.size()];

break;

case Levels::medium:

length = rand() % 3 + 8; // длина среднего пароля - от 8 до 10

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

for (unsigned short i = 0; i < length / 2; i++)

password += small_letters[rand() % small_letters.size()];

for (unsigned short i = 0; i < length / 2; i++)

password += big_letters[rand() % big_letters.size()];

if (password.size() < length)

password += figures[rand() % figures.size()];

break;

case Levels::complex:

length = rand() %11 + 10; // длина сложного пароля - от 10 до 20

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

for (unsigned short i = 0; i < length / 4; i++)

password += small_letters[rand() % small_letters.size()];

for (unsigned short i = 0; i < length / 4; i++)

password += big_letters[rand() % big_letters.size()];

for (unsigned short i = 0; i < length / 4; i++)

password += figures[rand() % figures.size()];

for (unsigned short i = 0; i < length / 4; i++)

password += symbols[rand() % symbols.size()];

while (password.size() < (length-1))

password += small_letters[rand() % small_letters.size()];

break;

default:

break;

}

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

std::random_device rd;

std::mt19937 g(rd());

std::shuffle(password.begin(), password.end(), g);

return password;

}

int main()

{

//аналог randomize с привязкой ко времени запуска:

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

Levels level = get_level();

std::cout << "Your new password is: " << create_password(level) << std::endl << std::endl;

return 0;

}

Ответить

Анастасия:

26 мая 2020 в 13:55

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

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

enum class Choices {rock, paper, scissors};

unsigned short get_users_choice(const unsigned short min, const unsigned short max)
{
	unsigned short answer;
	std::cin >> answer;
	while (std::cin.fail() || (answer < min) || (answer > max))
	{
		std::cin.clear();
		std::cin.ignore(32767, '\n');
		std::cout << "you should input a number from " << min << " to " << max << ": ";
		std::cin >> answer;
	}
	return answer;
}

void who_wins(const Choices users_choice, const Choices comp_choice)
{
    auto difference = static_cast<short>(users_choice) - static_cast<short>(comp_choice);
	switch (difference)
	{
	case 0:
		std::cout << "\nThe draw!\n"; 
		break;
	case 1:
	case -2:
		std::cout << "\nCongratulations! You win!\n"; 
		break;
	default:
		std::cout << "\nComputer wins\n";
	}
}

void one_game_round()
{
	std::cout << "Your choice:\n1 - rock\n2 - paper\n3 - scissors\n";
	Choices users_choice = static_cast<Choices>(get_users_choice(1, 3) - 1);

	Choices computer_choice = static_cast<Choices>(rand() % 3);
	std::cout << "Computer has chosen ";
	switch (computer_choice)
	{
	case Choices::rock:
		std::cout << "rock"; 
		break;
	case Choices::paper:
		std::cout << "paper"; 
		break;
	case Choices::scissors:
		std::cout << "scissors"; 
		break;
	default:
		std::cout << "some unknown thing";
	}

	who_wins(users_choice, computer_choice);
}

bool play_one_more_time()
{
	std::cout << "\nDo you want to play one more time?\n1 - yes\n2 - no\n";
	return ((get_users_choice(1, 2) == 1) ? true : false);
}

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

    std::cout << "GAME rock-paper-scissors:\n\n";
	while (true)
	{
		one_game_round();
		if (!play_one_more_time()) break;
	}

	return 0;
}

#include <iostream>

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

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

enum class Choices {rock, paper, scissors};

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

{

unsigned short answer;

std::cin >> answer;

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

{

std::cin.clear();

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

std::cout << "you should input a number from " << min << " to " << max << ": ";

std::cin >> answer;

}

return answer;

}

void who_wins(const Choices users_choice, const Choices comp_choice)

{

auto difference = static_cast<short>(users_choice) - static_cast<short>(comp_choice);

switch (difference)

{

case 0:

std::cout << "\nThe draw!\n";

break;

case 1:

case -2:

std::cout << "\nCongratulations! You win!\n";

break;

default:

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

}

void one_game_round()

{

std::cout << "Your choice:\n1 - rock\n2 - paper\n3 - scissors\n";

Choices users_choice = static_cast<Choices>(get_users_choice(1, 3) - 1);

Choices computer_choice = static_cast<Choices>(rand() % 3);

std::cout << "Computer has chosen ";

switch (computer_choice)

{

case Choices::rock:

std::cout << "rock";

break;

case Choices::paper:

std::cout << "paper";

break;

case Choices::scissors:

std::cout << "scissors";

break;

default:

std::cout << "some unknown thing";

}

who_wins(users_choice, computer_choice);

}

bool play_one_more_time()

{

std::cout << "\nDo you want to play one more time?\n1 - yes\n2 - no\n";

return ((get_users_choice(1, 2) == 1) ? true : false);

}

int main()

{

//аналог randomize с привязкой ко времени запуска:

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

std::cout << "GAME rock-paper-scissors:\n\n";

while (true)

{

one_game_round();

if (!play_one_more_time()) break;

}

return 0;

}

Ответить

Анастасия:

26 мая 2020 в 13:54

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

#include <iostream>
#include <array>

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

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

    const unsigned length(15);
    int value_to_compare(5);
	std::array <int, length> array{ 1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345 };

	std::cout << "Элементы массива больше " << value_to_compare << ": ";
    for (const auto& element : array)
        if (element > value_to_compare)
            std::cout << element << " ";
    std::cout << std::endl;

	value_to_compare = get_number();
	std::cout << "Элементы массива меньше " << value_to_compare << ": ";
	for (const auto& element : array)
		if (element < value_to_compare)
			std::cout << element << " ";
	std::cout << std::endl;

    return 0;
}

#include <iostream>

#include <array>

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

int get_number()

{

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

int answer;

std::cin >> answer;

while (std::cin.fail())

{

std::cin.clear();

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

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

std::cin >> answer;

}

return answer;

}

int main()

{

setlocale(LC_CTYPE, "rus");

const unsigned length(