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

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

1. Максим:

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117

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

   Ответить
2. 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; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133

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

   1 2 3 4 5 6 7

   #ifndef RANDNUMBER_H #define RANDNUMBER_H   int getRandomNumber(int min, int max); int getRandomNumber(int scale);   #endif /* RANDNUMBER_H */

   RandNumber.cpp

   #include "RandNumber.h" #include <random> // для std::random_device и std::mt19937 int getRandomNumber(int min, int max) { //инициализация часов static bool init = false; if (init == false) { srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения init = true; } static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды // Равномерно распределяем вычисление значения из нашего диапазона return static_cast<int> (rand() * fraction * (max - min + 1) + min); } int getRandomNumber(int scale) { return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1)); }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   #include "RandNumber.h" #include <random> // для std::random_device и std::mt19937   int getRandomNumber(int min, int max) { //инициализация часов static bool init = false; if (init == false) { srand(static_cast<unsigned int> (time(0))); // используем системные часы в качестве стартового значения init = true; }   static const double fraction = 1.0 / (static_cast<double> (RAND_MAX) + 1.0); // используем static, так как это значение нужно вычислить единожды // Равномерно распределяем вычисление значения из нашего диапазона return static_cast<int> (rand() * fraction * (max - min + 1) + min); }   int getRandomNumber(int scale) { return getRandomNumber((pow(10, scale - 1)), (pow(10, scale) - 1)); }

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122

   #ifndef USERINPUT_H #define USERINPUT_H   template<typename T> void 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 */

   Ответить
3. 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; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

   #include <iostream> #include "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 */

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

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

   Ответить
4. Анастасия:

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

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

   Ответить
5. Анастасия:

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

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

   Ответить
6. Анастасия:

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

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

   #include <iostream> #include <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; }

   Ответить
7. RockNRullz:

   28 апреля 2020 в 13:05

   Задание №3:

   #include <iostream> #include <ctime> #include <string> 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); } size_t genNum() // генерирует числа { return getRandomNumber(48, 57); } size_t genLow() // строчные буквы { return getRandomNumber(97, 122); } size_t genHigh() // прописные буквы { return getRandomNumber(65, 90); } size_t midPass(size_t x = getRandomNumber(1, 2)) //генерирует средний пароль { switch (x) { case 1: return genLow(); case 2: return genNum(); } } size_t highPass(size_t x = getRandomNumber(1, 3)) //генерирует сложный пароль { switch (x) { case 1: return genLow(); case 2: return genNum(); case 3: return genHigh(); } } std::string genPass(size_t &x) // определяет какой пароль сгенерировать { std::string str; str.resize(x); if (x < 7) { for (size_t iii(0); iii < str.length(); ++iii) str[iii] = genNum(); } else if (x < 10) { for (size_t iii(0); iii < str.length(); ++iii) str[iii] = midPass(); } else { for (size_t iii(0); iii < str.length(); ++iii) str[iii] = highPass(); } return str; } size_t enterVal() //ввод значения { while (true) { size_t x; std::cin >> x; if (std::cin.fail()) { std::cin.clear(); std::cin.ignore(32767, '\n'); std::cout << "Ошибка, попробуй еще раз!\n"; } else return x;; } } void choise() // сам генератор { while (true) { size_t x; while (true) { std::cout << "Какой хочешь пароль?(1 - простой, 2 - средний, 3 - сложный): "; x = enterVal(); if (x < 1 || x > 3) std::cout << "Ошибка, попробуй еще раз!\n"; else break; } switch (x) { case 1: x = getRandomNumber(4, 6); break; case 2: x = getRandomNumber(7, 9); break; case 3: x = getRandomNumber(10, 20); break; } std::cout << "Сгенерированный пароль: " << genPass(x); size_t n; while (true) { std::cout << "\nСгенерировать еще пароль?(1 - да, 2 - нет): "; n = enterVal(); if (n < 1 || n > 2) std::cout << "Ошибка, попробуй еще раз!\n"; else break; } if (n == 1) continue; else break; } } int main() { setlocale(LC_ALL, "Rus"); srand(time(0)); choise(); return 0; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

   #include <iostream> #include <ctime> #include <string>   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); }   size_t genNum() // генерирует числа { return getRandomNumber(48, 57); }   size_t genLow() // строчные буквы { return getRandomNumber(97, 122); }   size_t genHigh() // прописные буквы { return getRandomNumber(65, 90); }   size_t midPass(size_t x = getRandomNumber(1, 2)) //генерирует средний пароль { switch (x) { case 1: return genLow(); case 2: return genNum(); } }   size_t highPass(size_t x = getRandomNumber(1, 3)) //генерирует сложный пароль { switch (x) { case 1: return genLow(); case 2: return genNum(); case 3: return genHigh(); } }   std::string genPass(size_t &x) // определяет какой пароль сгенерировать { std::string str; str.resize(x); if (x < 7) { for (size_t iii(0); iii < str.length(); ++iii) str[iii] = genNum(); } else if (x < 10) { for (size_t iii(0); iii < str.length(); ++iii) str[iii] = midPass(); } else { for (size_t iii(0); iii < str.length(); ++iii) str[iii] = highPass(); }   return str; }   size_t enterVal() //ввод значения { while (true) { size_t x; std::cin >> x; if (std::cin.fail()) { std::cin.clear(); std::cin.ignore(32767, '\n'); std::cout << "Ошибка, попробуй еще раз!\n"; } else return x;; }   }   void choise() // сам генератор { while (true) { size_t x; while (true) { std::cout << "Какой хочешь пароль?(1 - простой, 2 - средний, 3 - сложный): "; x = enterVal(); if (x < 1 || x > 3) std::cout << "Ошибка, попробуй еще раз!\n"; else break; } switch (x) { case 1: x = getRandomNumber(4, 6); break; case 2: x = getRandomNumber(7, 9); break; case 3: x = getRandomNumber(10, 20); break; } std::cout << "Сгенерированный пароль: " << genPass(x); size_t n; while (true) { std::cout << "\nСгенерировать еще пароль?(1 - да, 2 - нет): "; n = enterVal(); if (n < 1 || n > 2) std::cout << "Ошибка, попробуй еще раз!\n"; else break; } if (n == 1) continue; else break; } }   int main() { setlocale(LC_ALL, "Rus"); srand(time(0)); choise();   return 0; }

   Ответить
   1. Анастасия:

      28 мая 2020 в 20:37

      Неплохое решение. Но было бы гораздо лучше, если бы Вы не использовали переменные с абстрактными названиями вроде x (для длины-то!) или n, а также разбили бы функцию choise (кстати, "выбор" пишется как choice, без буквы s), выделив из неё часть проверки пользовательского ввода, а то там этот код дублируется. Да, и ещё стоит добавлять const к параметрам функций, которые Вы не собираетесь менять.

      Ответить
8. Shom:

   21 февраля 2020 в 11:29

   Задание №3.

   // Linux Mint 18.3, g++-7, c++17, IDE "CodeLite"; #include <iostream> //#include <windows.h> // Раскоментировать для подключения // кириллицы в Windows; int main() { //SetConsoleCP(1251); // Пользователям Windows для подключения //SetConsoleOutputCP(1251); // кириллицы раскоментировать эти две строки; std::cout << " *** Генератор паролей. ***\n\n"; srand(time(0)); // Началльное число для генерации случайных чисел; const size_t simple{6}, // Длина простого пароля; complex{10}, // Длина сложного пароля; strong{15}; // Длина надёжного пароля; while(1) // Основной цикл программыЖ { char choice; // Переменная для выбора пользователя; while (1) // Валидация ввода; { std::cout << "Выберете сложность пароля (1 - простой, 2 - сложный, " "3 - надёжный),\n" "или введите 0 для завершения программы: "; std::cin >> choice; if (choice == '0') break; if (choice == '0' || choice == '1' || choice == '2' || choice == '3') break; else { std::cout << "Ошибка ввода! Попробуйте ещё раз.\n"; std::cin.ignore(32767, '\n'); } } if (choice == '0') break; // Завершение программы; size_t complexity; // Для записи выбранной сложности пароля; switch (choice) { case '1': complexity = simple; break; case '2': complexity = complex; break; case '3': complexity = strong; break; default: break; } std::string password{""}; // Переменная для пароля; for (size_t iii{0}; iii<complexity; ++iii) // Создаём пароль; { if (complexity == strong) // В надёжном пароле используем все символы с { // кодом от 32 до 126 включительно; password += static_cast<char>(32 + rand()%(127-32)); // Генерируем число, } // преобразуем его в символ и добавляем к строке; else { size_t start{40}; // Нижний предел для генерации сложного пароля; if (complexity == simple) start = 48; // Устанавливаем наименьшее число // генерации, если выбран простой пароль; size_t num{start + rand()%(110-start)}; // Генерируем число в заданных пределах; char temp; // Временная переменная для символа; if (num <= 47 ) // Блок с набором знаков для сложного пароля; { switch (num) { case 40: temp = '!'; break; case 41: temp = '@'; break; case 42: temp = '#'; break; case 43: temp = '$'; break; case 44: temp = '%'; break; case 45: temp = '&'; break; case 46: temp = '?'; break; case 47: temp = '_'; break; default: break; } } else if (num>=58 && num<=83) temp = num+7; // Смещаемся в область заглавных букв; else if (num>83) temp = num+13; // Смещаемся в область строчных букв; else temp = num; // Область цифр; password += temp; // Добавляем символ в строку; } } std::cout << "\nВаш пароль (внутри кавычек): \"" << password << "\"\n\n"; } std::cout << "\nПрограмма завершена.\n\n"; return 0; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90

   // Linux Mint 18.3, g++-7, c++17, IDE "CodeLite";     #include <iostream> //#include <windows.h>                          // Раскоментировать для подключения                                                 //  кириллицы в Windows;   int main() {       //SetConsoleCP(1251);                         // Пользователям Windows для подключения     //SetConsoleOutputCP(1251);                   //   кириллицы раскоментировать эти две строки;          std::cout << "    *** Генератор паролей. ***\n\n";          srand(time(0));                              // Началльное число для генерации случайных чисел;          const size_t simple{6},                      // Длина простого пароля;                  complex{10},                    // Длина сложного пароля;                  strong{15};                     // Длина надёжного пароля;       while(1)                                     // Основной цикл программыЖ     {         char choice;                             // Переменная для выбора пользователя;         while (1)                                // Валидация ввода;         {            std::cout << "Выберете сложность пароля (1 - простой, 2 - сложный, "                         "3 - надёжный),\n"                         "или введите 0 для завершения программы: ";            std::cin  >> choice;            if (choice == '0') break;                       if (choice == '0' || choice == '1' || choice == '2' || choice == '3')                break;            else            {                std::cout << "Ошибка ввода! Попробуйте ещё раз.\n";                std::cin.ignore(32767, '\n');            }                   }         if (choice == '0') break;                 // Завершение программы;                  size_t complexity;                        // Для записи выбранной сложности пароля;         switch (choice)         {             case '1': complexity = simple;  break;             case '2': complexity = complex; break;             case '3': complexity = strong;  break;             default: break;         }           std::string password{""};                 // Переменная для пароля;         for (size_t iii{0}; iii<complexity; ++iii)    // Создаём пароль;         {             if (complexity == strong)             // В надёжном пароле используем все символы с             {                                     //  кодом от 32 до 126 включительно;                 password += static_cast<char>(32 + rand()%(127-32));  // Генерируем число,             }                                     //  преобразуем его в символ и добавляем к строке;             else             {                 size_t start{40};                 // Нижний предел для генерации сложного пароля;                 if (complexity == simple) start = 48;   // Устанавливаем наименьшее число                                                         //   генерации, если выбран простой пароль;                 size_t num{start + rand()%(110-start)}; // Генерируем число в заданных пределах;                 char temp;                              // Временная переменная для символа;                 if (num <= 47 )                  // Блок с набором знаков для сложного пароля;                   {                     switch (num)                     {                         case 40: temp = '!'; break;                         case 41: temp = '@'; break;                         case 42: temp = '#'; break;                         case 43: temp = '$'; break;                         case 44: temp = '%'; break;                         case 45: temp = '&'; break;                         case 46: temp = '?'; break;                         case 47: temp = '_'; break;                         default: break;                     }                                 }                 else if (num>=58 && num<=83) temp = num+7;   // Смещаемся в область заглавных букв;                 else if (num>83) temp = num+13;              // Смещаемся в область строчных букв;                 else temp = num;                             // Область цифр;                                  password += temp;                            // Добавляем символ в строку;             }                     }           std::cout << "\nВаш пароль (внутри кавычек): \"" << password << "\"\n\n";                 }     std::cout << "\nПрограмма завершена.\n\n";            return 0; }

   Ответить
   1. Анастасия:

      28 мая 2020 в 20:22

      И всё-таки Вы позволяете себе слишком много запихивать в main, надо поработать над этим, определяя большую часть кода в функции или классы.

      Ответить
      1. Shom:

         1 июня 2020 в 17:49

         Решение получилось линейным, код не дублируется — по-моему, функции и классы только бы усложнили программу.

         Ответить
9. Shom:

   19 февраля 2020 в 16:47

   Задание №2.

   // Linux Mint 18.3, g++-7, c++17, IDE "CodeLite"; #include <iostream> //#include <windows.h> // Раскоментировать для подключения // кириллицы в Windows; inline int validationInput() // Функция валидации ввода данных; { int val; while (true) { std::cin >> val; if (std::cin.fail() || val<1 || val>3) { std::cin.clear(); std::cin.ignore(32767, '\n'); std::cout << "Ошибка ввода! Попробуйте ещё раз: "; continue; } std::cin.ignore(32767, '\n'); return val; } } int main() { //SetConsoleCP(1251); // Пользователям Windows для подключения //SetConsoleOutputCP(1251); // кириллицы раскоментировать эти две строки; std::cout << " *** Кмень = ножницы - бумага. ***\n\n"; srand(time(0)); // Началльное число для генерации случайных чисел; int user, // Выбор игрока; computer; // Выбор компьютера; std::string key; // Переменная для выхода из цикла; while (1) { std::cout << "Ваш ход. Камень - 1, Ножницы - 2, Бумага - 3: "; user = validationInput(); std::cout << "Компьютер выбрал "; computer = 1+rand()%3; switch (computer) // Обработка выбора компьютера; { case 1: std::cout << "камень.\n"; break; case 2: std::cout << "ножницы.\n"; break; case 3: std::cout << "бумагу.\n"; break; default: break; } switch (user-computer) // Вычисляем результат игры; { case 0: std::cout << "Ничья.\n"; break; case -1: case 2: std::cout << "Вы победили!\n"; break; case 1: case -2: std::cout << "Победил компьютер.\n"; break; default: std::cout << "Эффект квантовой запутанности.\n"; break; } std::cout << '\n'; std::cout << "Желаете ещё раз сыграть?(Д/Н): "; std::cin >> key; if (key != "Д" && key != "д") break; else std::cout << '\n'; } std::cout << "\nИгра завершена.\n\n"; return 0; }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

   // Linux Mint 18.3, g++-7, c++17, IDE "CodeLite";     #include <iostream> //#include <windows.h>                          // Раскоментировать для подключения                                                 //  кириллицы в Windows; inline int validationInput()                    // Функция валидации ввода данных; {     int val;     while (true)     {         std::cin >> val;         if (std::cin.fail() || val<1 || val>3)                 {                                                         std::cin.clear();             std::cin.ignore(32767, '\n');             std::cout << "Ошибка ввода! Попробуйте ещё раз: ";             continue;         }         std::cin.ignore(32767, '\n');         return val;     } }       int main() {       //SetConsoleCP(1251);                         // Пользователям Windows для подключения     //SetConsoleOutputCP(1251);                   //   кириллицы раскоментировать эти две строки;          std::cout << "    *** Кмень = ножницы - бумага. ***\n\n";          srand(time(0));                              // Началльное число для генерации случайных чисел;          int user,                                    // Выбор игрока;         computer;                                // Выбор компьютера;              std::string key;                             // Переменная для выхода из цикла;         while (1)     {               std::cout << "Ваш ход. Камень - 1, Ножницы - 2, Бумага - 3: ";         user = validationInput();                              std::cout << "Компьютер выбрал ";         computer = 1+rand()%3;         switch (computer)                        // Обработка выбора компьютера;         {             case 1: std::cout << "камень.\n"; break;             case 2: std::cout << "ножницы.\n"; break;             case 3: std::cout << "бумагу.\n"; break;             default: break;         }                  switch (user-computer)                   // Вычисляем результат игры;         {             case  0: std::cout << "Ничья.\n"; break;             case -1:             case  2: std::cout << "Вы победили!\n"; break;             case  1:             case -2: std::cout << "Победил компьютер.\n"; break;             default: std::cout << "Эффект квантовой запутанности.\n"; break;         }         std::cout << '\n';                  std::cout << "Желаете ещё раз сыграть?(Д/Н): ";         std::cin  >> key;         if (key != "Д" && key != "д") break;         else std::cout << '\n';           }     std::cout << "\nИгра завершена.\n\n";            return 0; }

   Ответить
10. Shom:

    18 февраля 2020 в 16:56

    Задание №1.

    // Linux Mint 18.3, g++-7, c++17, IDE "CodeLite"; #include <iostream> //#include <windows.h> // Раскоментировать для подключения // кириллицы в Windows; inline double validationInput() // Функция валидации ввода данных; { double 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; } } int main() { //SetConsoleCP(1251); // Пользователям Windows для подключения //SetConsoleOutputCP(1251); // кириллицы раскоментировать эти две строки; std::cout << " *** Работа с массивом. ***\n\n"; const int a[]{1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345}; std::cout << "Массив чисел:\n"; for (auto num : a) std::cout << num << ' '; std::cout << "\n\n"; std::cout << "Числа в массиве больше 5:\n"; for (auto num : a) if (num>5) std::cout << num << ' '; std::cout << "\n\n"; std::cout << "Введите число: "; double val{validationInput()}; std::cout << "Числа в массиве меньше " << val << ":\n"; bool key{true}; for (auto num : a) if (num<val) { std::cout << num << ' '; key = false; } else break; if (key) std::cout << " отсутствуют."; std::cout << "\n\n"; return 0; }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

    // Linux Mint 18.3, g++-7, c++17, IDE "CodeLite";     #include <iostream> //#include <windows.h>                          // Раскоментировать для подключения                                                 //  кириллицы в Windows;   inline double validationInput()                 // Функция валидации ввода данных; {     double 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;     } }     int main() {       //SetConsoleCP(1251);                         // Пользователям Windows для подключения     //SetConsoleOutputCP(1251);                   //   кириллицы раскоментировать эти две строки;          std::cout << "    *** Работа с массивом. ***\n\n";          const int a[]{1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345};          std::cout << "Массив чисел:\n";     for (auto num : a)             std::cout << num << ' ';     std::cout << "\n\n";              std::cout << "Числа в массиве больше 5:\n";     for (auto num : a)             if (num>5) std::cout << num << ' ';     std::cout << "\n\n";              std::cout << "Введите число: ";     double val{validationInput()};     std::cout << "Числа в массиве меньше " << val << ":\n";     bool key{true};     for (auto num : a)             if (num<val)         {             std::cout << num << ' ';             key = false;         }         else break;       if (key)         std::cout << " отсутствуют.";             std::cout << "\n\n";        return 0; }

    Ответить
11. Владимир:

    9 января 2020 в 22:01

    Задание №1:

    #include <iostream> #include <Windows.h> void inputСheck(int& num) // ввод числа с проверкой { while (!(std::cin >> num) || (std::cin.peek() != '\n')) { std::cin.clear(); std::cin.ignore(SHRT_MAX, '\n'); std::cout << "Error! Повторите ввод : "; } std::cin.ignore(SHRT_MAX, '\n'); } int main() { SetConsoleCP(1251); SetConsoleOutputCP(1251); std::cout << "Имеется массив :\n"; const int a[]{ 1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345 }; const int length = sizeof(a) / sizeof(a[0]); for (int i{}; i < length; ++i) std::cout << a[i] << " "; std::cout << "\n\nВсе элементы массива больше, значения которых 5 :\n"; for (int j{}; j < length; ++j) if (a[j] > 5) std::cout << a[j] << " "; std::cout << "\n\nВведите число и программа выведет значения массива, которые меньше Вашего числа : "; int number{}; inputСheck(number); for (int k{}; k < length; ++k) if (a[k] < number) std::cout << a[k] << " "; std::cout << "\n"; return 0; }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

    #include <iostream> #include <Windows.h>   void inputСheck(int& num) // ввод числа с проверкой { while (!(std::cin >> num) || (std::cin.peek() != '\n')) { std::cin.clear(); std::cin.ignore(SHRT_MAX, '\n'); std::cout << "Error! Повторите ввод : "; } std::cin.ignore(SHRT_MAX, '\n'); }   int main() { SetConsoleCP(1251); SetConsoleOutputCP(1251); std::cout << "Имеется массив :\n"; const int a[]{ 1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345 }; const int length = sizeof(a) / sizeof(a[0]); for (int i{}; i < length; ++i) std::cout << a[i] << " ";   std::cout << "\n\nВсе элементы массива больше, значения которых 5 :\n"; for (int j{}; j < length; ++j) if (a[j] > 5) std::cout << a[j] << " ";   std::cout << "\n\nВведите число и программа выведет значения массива, которые меньше Вашего числа : "; int number{}; inputСheck(number); for (int k{}; k < length; ++k) if (a[k] < number) std::cout << a[k] << " "; std::cout << "\n"; return 0; }

    Ответить
    1. Анастасия:

       26 мая 2020 в 14:04

       "Все элементы массива больше, значения которых 5 :"
       просто отмечу очень оригинальное построение фразы))

       Ответить
12. Алена:

    16 декабря 2019 в 22:53

    Задача 2.

    #include <iostream> #include <windows.h> #include <random> //Получаем ход игрока (камень, ножницы или бумага) char getPlayerMove() { char playerMove; while (true) { std::cout << "\n\nСделайте свой ход (К - камень, Н - ножницы, Б - бумага): "; std::cin >> playerMove; switch (playerMove) //проверяем ввод игрока (кириллица и латиница) { case 'К': case 'к': case 'K': case 'k': return 'К'; case 'Н': case 'н': case 'H': case 'h': return 'Н'; case 'Б': case 'б': case 'B': case 'b': return 'Б'; default: std::cout << "Ваш ход не распознан.\n"; } } } //Получаем ход компьютера (ГПСЧ c диапазоном) char randomNumber(int min, int max) { std::random_device rd; std::mt19937 mersenne(rd()); //иниц. вихрь Мерсенна случайным стартовым числом int number = mersenne() % (max - min + 1) + min; switch (number) //проверяем ввод игрока (кириллица и латиница) { case 1: return 'К'; case 2: return 'Н'; case 3: return 'Б'; default: std::cerr << "Ошибка генерации хода программы!"; exit(1); } } // Функция возвращает "Победа", если победил первый игрок std::string isWinner(char player1, char player2) { if (player1 == 'К') { if (player2 == 'К') return "Ничья"; if (player2 == 'Н') return "Победа"; if (player2 == 'Б') return "Поражение"; } if (player1 == 'Н') { if (player2 == 'К') return "Поражение"; if (player2 == 'Н') return "Ничья"; if (player2 == 'Б') return "Победа"; } if (player1 == 'Б') { if (player2 == 'К') return "Победа"; if (player2 == 'Н') return "Поражение"; if (player2 == 'Б') return "Ничья"; } } //Запрос на повтор игры bool getАskExit() { char askExit; while (true) { std::cout << "Хотите сыграть еще раз? (Д - да, Н - нет)?"; std::cin >> askExit; switch (askExit) //проверяем ввод игрока (кириллица и латиница) { case 'Д': case 'д': case 'Y': case 'y': return true; case 'Н': case 'н': case 'N': case 'n': return false; default: std::cout << "Ответ не распознан.\n"; } } } int main() { SetConsoleCP(1251); // настраиваем кодировку консоли (ввод) SetConsoleOutputCP(1251); // (вывод) std::cout << "***Игра «Камень, ножницы, бумага».***"; while (true) { char playerMove = getPlayerMove(); char programMove = randomNumber(1, 3); std::string winner = isWinner(playerMove, programMove); std::cout << "Ход компьютера: " << programMove << "\nИтог игры: " << isWinner(playerMove, programMove) << "\n\n"; if (!getАskExit()) break; } }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133

    #include <iostream> #include <windows.h> #include <random>   //Получаем ход игрока (камень, ножницы или бумага) char getPlayerMove() { char playerMove; while (true) { std::cout << "\n\nСделайте свой ход (К - камень, Н - ножницы, Б - бумага): "; std::cin >> playerMove; switch (playerMove) //проверяем ввод игрока (кириллица и латиница) { case 'К': case 'к': case 'K': case 'k': return 'К'; case 'Н': case 'н': case 'H': case 'h': return 'Н'; case 'Б': case 'б': case 'B': case 'b': return 'Б'; default: std::cout << "Ваш ход не распознан.\n"; } } }     //Получаем ход компьютера (ГПСЧ c диапазоном) char randomNumber(int min, int max) { std::random_device rd; std::mt19937 mersenne(rd()); //иниц. вихрь Мерсенна случайным стартовым числом int number = mersenne() % (max - min + 1) + min; switch (number) //проверяем ввод игрока (кириллица и латиница) { case 1: return 'К'; case 2: return 'Н'; case 3: return 'Б'; default: std::cerr << "Ошибка генерации хода программы!"; exit(1); } }   // Функция возвращает "Победа", если победил первый игрок std::string isWinner(char player1, char player2) { if (player1 == 'К') { if (player2 == 'К') return "Ничья"; if (player2 == 'Н') return "Победа"; if (player2 == 'Б') return "Поражение"; }   if (player1 == 'Н') { if (player2 == 'К') return "Поражение"; if (player2 == 'Н') return "Ничья"; if (player2 == 'Б') return "Победа"; }   if (player1 == 'Б') { if (player2 == 'К') return "Победа"; if (player2 == 'Н') return "Поражение"; if (player2 == 'Б') return "Ничья"; } }   //Запрос на повтор игры bool getАskExit() { char askExit; while (true) { std::cout << "Хотите сыграть еще раз? (Д - да, Н - нет)?"; std::cin >> askExit; switch (askExit) //проверяем ввод игрока (кириллица и латиница) { case 'Д': case 'д': case 'Y': case 'y': return true; case 'Н': case 'н': case 'N': case 'n': return false; default: std::cout << "Ответ не распознан.\n"; } } }   int main() { SetConsoleCP(1251); // настраиваем кодировку консоли (ввод) SetConsoleOutputCP(1251); // (вывод) std::cout << "***Игра «Камень, ножницы, бумага».***"; while (true) { char playerMove = getPlayerMove(); char programMove = randomNumber(1, 3); std::string winner = isWinner(playerMove, programMove);   std::cout << "Ход компьютера: " << programMove << "\nИтог игры: " << isWinner(playerMove, programMove) << "\n\n"; if (!getАskExit()) break; } }

    Ответить
13. Алена:

    6 декабря 2019 в 13:07

    Задача 1.

    #include <iostream> int getUserValue() //числовая валидация пользовательского ввода { while (true) { int value; std::cin >> value; if (std::cin.fail()) //если извлечения не произошло { std::cin.clear(); //сбрасываем все флаги std::cin.ignore(32767, '\n'); //очищаем мусор из потока std::cout << "Ошибка! Некорректный ввод. Попробуйте ЗАНОВО.\n"; continue; //начинаем сначала } if (value < 0) //индивидуальное требование к значению { std::cout << "Ошибка! Отрицательное число. Попробуйте ЗАНОВО.\n"; continue; //начинаем сначала } return value; //успешный ввод } } int main() { setlocale(LC_ALL, "Rus"); std::cout << "***Программа выводит все элементы больше 5 из заданного массива***\n" << "\t***и затем меньше числа от пользователя***\n\n"; int array[] = {1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345}; int lenghtArray = sizeof(array) / sizeof(array[0]); std::cout << "Элементы больше 5: "; for (int index = 0; index < lenghtArray; index++) { if (array[index] > 5) std::cout << array[index] << " "; } std::cout << "\n\nВведите свое значение: "; int userNumber = getUserValue(); std::cout << "Элементы меньше " << userNumber << ": "; for (int index = 0; index < lenghtArray; index++) { if (array[index] < userNumber) std::cout << array[index] << " "; } std::cout << "\n\nМассив был:\n"; for (int index = 0; index < lenghtArray; index++) { std::cout << array[index] << " "; } std::cout << "\n\n"; }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59

    #include <iostream>   int getUserValue() //числовая валидация пользовательского ввода { while (true) { int value; std::cin >> value;   if (std::cin.fail()) //если извлечения не произошло { std::cin.clear(); //сбрасываем все флаги std::cin.ignore(32767, '\n'); //очищаем мусор из потока std::cout << "Ошибка! Некорректный ввод. Попробуйте ЗАНОВО.\n"; continue; //начинаем сначала }   if (value < 0) //индивидуальное требование к значению { std::cout << "Ошибка! Отрицательное число. Попробуйте ЗАНОВО.\n"; continue; //начинаем сначала }   return value; //успешный ввод } }     int main() { setlocale(LC_ALL, "Rus"); std::cout << "***Программа выводит все элементы больше 5 из заданного массива***\n" << "\t***и затем меньше числа от пользователя***\n\n"; int array[] = {1, 1, 2, 4, 5, 9, 14, 22, 37, 54, 87, 90, 111, 243, 345}; int lenghtArray = sizeof(array) / sizeof(array[0]);   std::cout << "Элементы больше 5: "; for (int index = 0; index < lenghtArray; index++) { if (array[index] > 5) std::cout << array[index] << " "; }   std::cout << "\n\nВведите свое значение: "; int userNumber = getUserValue(); std::cout << "Элементы меньше " << userNumber << ": "; for (int index = 0; index < lenghtArray; index++) { if (array[index] < userNumber) std::cout << array[index] << " "; }   std::cout << "\n\nМассив был:\n"; for (int index = 0; index < lenghtArray; index++) { std::cout << array[index] << " "; } std::cout << "\n\n"; }

    Ответить
14. Владимир:

    17 ноября 2019 в 01:06

    Задание №3

    //Символы — (33 — 47) + (58 — 64) + (91 — 96) + (123 — 126)
    //Цифры — (48 — 57)
    //Буквы н.р. — (97 — 122)
    //Буквы в.р. — (65 — 90)

    #include <iostream> #include <random> int number(const int& min, const int& max) // генерируем "случайное" число { std::random_device rd; std::mt19937 mersenne(rd()); return mersenne() % (max - min + 1) + min; } bool check(int& num, const int x = INT_MAX) // проверяем ошибочность ввода { std::cin >> num; if (std::cin.fail() || num < 1 || num > x) { std::cin.clear(); std::cin.ignore(SHRT_MAX, '\n'); std::cout << "ERROR, повторите ввод :\t\t"; } else { std::cin.ignore(SHRT_MAX, '\n'); return false; } } bool makeChoice(char& choice) // предлагаем повторить { std::cout << "\nхотите "; while (true) { std::cout << "продолжить? да/нет - y/n : "; std::cin >> choice; std::cin.ignore(SHRT_MAX, '\n'); if (choice == 'y') return true; if (choice == 'n') return false; std::cout << "ERROR, "; } } int main() { setlocale(LC_ALL, "rus"); std::random_device rd; std::mt19937 mersenne(rd()); int categ; // выбираем категорию символов int level, length; // уровень сложности и длина пароля char choice; // выбор (да/нет) продолжения игры std::cout << "Генератор паролей трех уровней сложности,"; do { std::cout << "\nукажите количество символов пароля :\t\t"; while (check(length)); // проверка ввода std::cout << "выберите категорию сложности (от 1 до 3) :\t"; while (check(level, 3)); // проверка ввода std::cout << "ваш пароль :\t\t"; if (level == 1) // первый уровень сложности while (length-- > 0) { categ = number(1, 2); // рандомно выбираем категорию цифры или буквы ниж.рег. if (categ == 1) std::cout << static_cast<char>(number(48, 57)); // добавляем рандомную цифру else std::cout << static_cast<char>(number(97, 122)); // добавляем рандомную букву ниж. регистра } else if (level == 2) // второй уровень сложности while (length-- > 0) { categ = number(1, 3); // рандомно выбираем категорию цифры, буквы ниж.рег. или буквы верх.рег. if (categ == 1) std::cout << static_cast<char>(number(48, 57)); // добавляем рандомную цифру else if (categ == 2) std::cout << static_cast<char>(number(97, 122)); // добавляем рандомную букву нижнего регистра else std::cout << static_cast<char>(number(65, 90)); // добавляем рандомную букву верхнего регистра } else if (level == 3) // третий уровень сложности while (length-- > 0) std::cout << static_cast<char>(number(33, 126)); // добавляем рандомный символ } while (makeChoice(choice)); // предлагаем продолжить (да/нет) return 0; }

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

    #include <iostream> #include <random>   int number(const int& min, const int& max) // генерируем "случайное" число { std::random_device rd; std::mt19937 mersenne(rd()); return mersenne() % (max - min + 1) + min; }   bool check(int& num, const int x = INT_MAX) // проверяем ошибочность ввода { std::cin >> num; if (std::cin.fail() || num < 1 || num > x) { std::cin.clear(); std::cin.ignore(SHRT_MAX, '\n'); std::cout << "ERROR, повторите ввод :\t\t"; } else { std::cin.ignore(SHRT_MAX, '\n'); return false; } }   bool makeChoice(char& choice) // предлагаем повторить { std::cout << "\nхотите "; while (true) { std::cout << "продолжить? да/нет - y/n : "; std::cin >> choice; std::cin.ignore(SHRT_MAX, '\n'); if (choice == 'y') return true; if (choice == 'n') return false; std::cout << "ERROR, "; } }   int main() { setlocale(LC_ALL, "rus"); std::random_device rd; std::mt19937 mersenne(rd()); int categ; // выбираем категорию символов int level, length; // уровень сложности и длина пароля char choice; // выбор (да/нет) продолжения игры   std::cout << "Генератор паролей трех уровней сложности,"; do { std::cout << "\nукажите количество символов пароля :\t\t"; while (check(length)); // проверка ввода std::cout << "выберите категорию сложности (от 1 до 3) :\t"; while (check(level, 3)); // проверка ввода std::cout << "ваш пароль :\t\t";   if (level == 1) // первый уровень сложности while (length-- > 0) { categ = number(1, 2); // рандомно выбираем категорию цифры или буквы ниж.рег. if (categ == 1) std::cout << static_cast<char>(number(48, 57)); // добавляем рандомную цифру else std::cout << static_cast<char>(number(97, 122)); // добавляем рандомную букву ниж. регистра } else if (level == 2) // второй уровень сложности while (length-- > 0) { categ = number(1, 3); // рандомно выбираем категорию цифры, буквы ниж.рег. или буквы верх.рег. if (categ == 1) std::cout << static_cast<char>(number(48, 57)); // добавляем рандомную цифру else if (categ == 2) std::cout << static_cast<char>(number(97, 122)); // добавляем рандомную букву нижнего регистра else std::cout << static_cast<char>(number(65, 90)); // добавляем рандомную букву верхнего регистра } else if (level == 3) // третий уровень сложности while (length-- > 0) std::cout << static_cast<char>(number(33, 126)); // добавляем рандомный символ   } while (makeChoice(choice)); // предлагаем продолжить (да/нет)   return 0; }

    Ответить
    1. Анастасия:

       28 мая 2020 в 20:05

       Мне понравилась Ваша идея с рандомной категорией и удачное решение для высшего уровня сложности. В целом всё красиво вышло, смущает только, что функция check выдаёт false на успешную проверку, хотя по коду в main должно быть наоборот.

       Ответить