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

Руслан:

19 мая 2022 в 01:05

Задание 3

#include <iomanip>
#include <iostream>
#include <cstdlib>
#include <string>
#include <vector>
#include <ctime>
#include <random>
#include <algorithm>
#include <functional>

class Random
{
public:
	static int fromRange(int begin, int end)
	{
		return rand() % (end - begin) + begin;
	}
};

template<typename T>
std::ostream& operator << (std::ostream& out, std::vector<T>& vec)
{
	std::for_each(vec.begin(), vec.end(), [&out](const auto e) {out << e; });
	return out;
}

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

	std::string word;
	std::getline(std::cin, word);

	std::vector<std::string> lastWords;
	std::string result(word.size(), ' ');

	size_t count{ 0 };

	while(result != word)
	{
		std::vector<int> lastIndex;
		
		for (int j = 0; j < word.size();)
		{
			int index = Random::fromRange(0, word.size());
			bool isIndexUnique{ true };

			std::for_each(lastIndex.begin(), lastIndex.end(), [&isIndexUnique, index](const auto e)
				{ 
					if (e == index) isUnique = false;
				}
			);

			if (isIndexUnique)
			{
				result[j] = word[index];
				lastWords.push_back(result);
				lastIndex.push_back(index);
				++j;
			}
		}

		bool isWordFound{ false };
		std::for_each(lastWords.begin(), lastWords.end() - 1, [&isWordFound, &result](const auto e)
			{
				if (e == result) isFound = true;
			}
		);

		if (!isWordFound)
		{
			std::cout << "[" << count << "] " << lastIndex << " " << result << std::endl;
			++count;
		}

	}

	return EXIT_SUCCESS;
}

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

#include <iomanip>

#include <iostream>

#include <cstdlib>

#include <string>

#include <vector>

#include <ctime>

#include <random>

#include <algorithm>

#include <functional>

class Random

{

public:

static int fromRange(int begin, int end)

{

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

}

};

template<typename T>

std::ostream& operator << (std::ostream& out, std::vector<T>& vec)

{

std::for_each(vec.begin(), vec.end(), [&out](const auto e) {out << e; });

return out;

}

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

{

srand(time(0));

setlocale(LC_ALL, "Russian");

std::string word;

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

std::vector<std::string> lastWords;

std::string result(word.size(), ' ');

size_t count{ 0 };

while(result != word)

{

std::vector<int> lastIndex;

for (int j = 0; j < word.size();)

{

int index = Random::fromRange(0, word.size());

bool isIndexUnique{ true };

std::for_each(lastIndex.begin(), lastIndex.end(), [&isIndexUnique, index](const auto e)

{

if (e == index) isUnique = false;

}

);

if (isIndexUnique)

{

result[j] = word[index];

lastWords.push_back(result);

lastIndex.push_back(index);

++j;

}

bool isWordFound{ false };

std::for_each(lastWords.begin(), lastWords.end() - 1, [&isWordFound, &result](const auto e)

{

if (e == result) isFound = true;

}

);

if (!isWordFound)

{

std::cout << "[" << count << "] " << lastIndex << " " << result << std::endl;

++count;

}

return EXIT_SUCCESS;

}

Ответить

Антон:

24 апреля 2022 в 13:18

Это решение задания 1. Судя по тестированию получилось

#include<iostream>
#include<locale>
#include<string>
using namespace std;
int main()
{
	setlocale(LC_ALL, "rus");
	std::cout << "Введите строку: ";
	std::string str;
	std::getline(std::cin, str);
	std::cout << endl;
	std::cout << "Длина строки равна: " << end(str) - begin(str) << endl;
	system("pause");
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

#include<iostream>

#include<locale>

#include<string>

using namespace std;

int main()

{

setlocale(LC_ALL, "rus");

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

std::string str;

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

std::cout << endl;

std::cout << "Длина строки равна: " << end(str) - begin(str) << endl;

system("pause");

return 0;

}

Ответить

WAR:

31 августа 2021 в 17:53

Задание №2:

#include <iostream>

int main() {
double money{24}, percent{1.06};
int year{2021};
while(--year >= 1826) money *= percent;
std::cout << "Now you have would: " << (int)money << " dollars";
return 0;
}

1

2

3

4

5

6

7

8

9

#include <iostream>

int main() {

double money{24}, percent{1.06};

int year{2021};

while(--year >= 1826) money *= percent;

std::cout << "Now you have would: " << (int)money << " dollars";

return 0;

}

Ответить

WAR:

31 августа 2021 в 17:36

Задание №1:

#include <iostream>
#include <string>

int main() {
std::string str;
while(str.length() < 1) {
      std::cout<<"Enter string: ";
      std::getline(std::cin, str);
}	
int len = str.end() - str.begin();
std::cout << "Length string is: " << len;
return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

#include <iostream>

#include <string>

int main() {

std::string str;

while(str.length() < 1) {

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

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

}

int len = str.end() - str.begin();

std::cout << "Length string is: " << len;

return 0;

}

Ответить

Rock:

5 февраля 2021 в 22:12

Задание 1:

#include<iostream>

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

	std::string str;
	str = "Я строка я строка";
	int x = 1, count = 0;

	for (int i = 0; i < x; i++)
	{
		if (str[i])
		{
			x++;
			count++;
		}
	}

	std::cout << count;

	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

#include<iostream>

int main()

{

setlocale(0, "");

std::string str;

str = "Я строка я строка";

int x = 1, count = 0;

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

{

if (str[i])

{

x++;

count++;

}

std::cout << count;

return 0;

}

Задание 2:

тут 2 варианта ибо многие пишут 1 вариант который берет процент от начального числа и прибавляет его к числу но после берет процент у прибавленного числа но депозит не так работает правильнее 2 вариант от начального вклада мы получаем каждый год процент не смотря на полученное от депозита (есть формулы увеличения депозита но тут в условии нету такого).

#include<iostream>


int main()
{

	double  money = 24;



	for (int i = 1826; i < 2021; i++)
	{
		money *= 1.06;
	}
	std::cout << static_cast<int>(money)<<std::endl ;


	money = 24;


	for (int i = 1826; i < 2021; i++)
	{
		money += 24 * 0.06;
	}
	std::cout <<money;




}

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

#include<iostream>

int main()

{

double money = 24;

for (int i = 1826; i < 2021; i++)

{

money *= 1.06;

}

std::cout << static_cast<int>(money)<<std::endl ;

money = 24;

for (int i = 1826; i < 2021; i++)

{

money += 24 * 0.06;

}

std::cout <<money;

}

разница расчетов колоссальна

Задача 3:

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

struct Struct
{
	std::string word;
	int *index;
};




int Random(int max) // вихрь марслена 
{
	std::random_device rd; // случайное число
	std::mt19937 random(rd()); // с вихрем марслена
	std::uniform_int_distribution<> distrib(0, max); // в определенном диапазоне что бы можно было передать вихрь

	return distrib(random);// возврат диапазона с параметром вихря
}

void Swaping(Struct& t)
{
	
		int random1 = Random(t.word.size() - 1);
		int random2 = Random(t.word.size() - 1);


		while (random1 == random2)
		{
			random2 = Random(t.word.size() - 1);
		}
		
			std::swap(t.word[random1], t.word[random2]);
			std::swap(t.index[random1], t.index[random2]);
		
}

bool index_comparison(Struct&t, Struct&sor)
{
	for (int i = 0; i < t.word.size(); i++)
	{
		if (t.index[i] == sor.index[i])
			continue;

			return false;
	}
	return true;
}




int main()
{

	setlocale(0, "");

	SetConsoleCP(1251);
	SetConsoleOutputCP(1251);

	Struct user_word;
	Struct control_word;

	std::cout << "Введите слово: ";
	std::cin >> user_word.word;

	user_word.index = new int[user_word.word.size()];
	control_word.index = new int[user_word.word.size()];
	int count = 1;

	

	for (int i = 0; i < user_word.word.size(); i++)
	{
		user_word.index[i] = i ;
		control_word.index[i] = i;
	}

	control_word.word = user_word.word;
	
	while (1)
	{

		
		Swaping(user_word);
		
		std::cout << "[" << count++ << "] ";
		for (int i = 0; i < user_word.word.size(); i++)
		{
			std::cout << user_word.index[i];
		}
			std::cout<< " " << user_word.word << std::endl;

			bool prov = index_comparison(user_word, control_word);

		if (control_word.word == user_word.word && prov)
			break;
		
	}

	delete[] user_word.index;
	delete[] control_word.index;

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

#include<iostream>

#include<random>

#include <windows.h>

struct Struct

{

std::string word;

int *index;

};

int Random(int max) // вихрь марслена

{

std::random_device rd; // случайное число

std::mt19937 random(rd()); // с вихрем марслена

std::uniform_int_distribution<> distrib(0, max); // в определенном диапазоне что бы можно было передать вихрь

return distrib(random);// возврат диапазона с параметром вихря

}

void Swaping(Struct& t)

{

int random1 = Random(t.word.size() - 1);

int random2 = Random(t.word.size() - 1);

while (random1 == random2)

{

random2 = Random(t.word.size() - 1);

}

std::swap(t.word[random1], t.word[random2]);

std::swap(t.index[random1], t.index[random2]);

}

bool index_comparison(Struct&t, Struct&sor)

{

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

{

if (t.index[i] == sor.index[i])

continue;

return false;

}

return true;

}

int main()

{

setlocale(0, "");

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

Struct user_word;

Struct control_word;

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

std::cin >> user_word.word;

user_word.index = new int[user_word.word.size()];

control_word.index = new int[user_word.word.size()];

int count = 1;

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

{

user_word.index[i] = i ;

control_word.index[i] = i;

}

control_word.word = user_word.word;

while (1)

{

Swaping(user_word);

std::cout << "[" << count++ << "] ";

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

{

std::cout << user_word.index[i];

}

std::cout<< " " << user_word.word << std::endl;

bool prov = index_comparison(user_word, control_word);

if (control_word.word == user_word.word && prov)

break;

}

delete[] user_word.index;

delete[] control_word.index;

return 0;

}

Ответить

Максим:

18 января 2021 в 16:11

Задание 1

#include <iostream>
#include <string>
#include <iterator> // for std::distance

int main()
{
    std::string str;
    std::cin >> str;

    int size{};
    for (std::string::iterator begin{ str.begin() }; begin != str.end(); ++begin, ++size) {}

    // second variant:
    // size = std::distance(str.begin(), str.end());

    std::cout << "String size: " << size << '\n';
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

#include <iostream>

#include <string>

#include <iterator> // for std::distance

int main()

{

std::string str;

std::cin >> str;

int size{};

for (std::string::iterator begin{ str.begin() }; begin != str.end(); ++begin, ++size) {}

// second variant:

// size = std::distance(str.begin(), str.end());

std::cout << "String size: " << size << '\n';

return 0;

}

Ответить

Аноним:

18 ноября 2020 в 01:47

Третье задание этой части зацепило, решил поделиться своим вариантом исполнения.

#include <iostream>
#include <string>
#include <vector>
#include <random>

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

struct Letter {
    unsigned int position;
    char symbol;
};

int main()
{
    cout << "Enter a word: ";
    string word;
    cin >> word; //записали слово
    unsigned int length = word.size(); //записали длину один раз в целях экономии
    vector<Letter> wordArr; //массив слова из структуры-пары (позиция/символ)
    for (unsigned int index = 0; index < length; ++index) //заполняем массив
        wordArr.push_back(Letter{ index, word[index] });
    std::random_device rd;
    std::mt19937 mersene(rd());
    vector<bool> usingLetter{}; //логический массив-маска для определения, какой символ мы уже подставили
    usingLetter.resize(length);
    unsigned int count = 1; //счетчик попыток
    while (1) { //бесконечный цикл подбора
        cout << "#" << count++ << " ";
        vector<Letter> randomWord; //массив рандомного варианта
        for (unsigned int index = 0; index < length; ++index) //инициализируем маску
            usingLetter[index] = false;
        for (unsigned int count = 0; count < length; ++count) { //заполняем рандомный вариант, пока не используем все символы
            unsigned int index{};
            do {
                index = mersene() % length; //подбираем индекс
            } while (usingLetter[index]); //если мы уже его использовали, подбираем другой
            randomWord.push_back(Letter{ wordArr[index].position, wordArr[index].symbol }); //наполняем рандомное слово подобранным символом
            usingLetter[index] = true; //обновляем маску
        }
        for (auto& item : randomWord) //выводим результат
            cout << item.position;
        cout << " ";
        for (auto& item : randomWord)
            cout << item.symbol;
        cout << "\n";
        unsigned int coincidence{ 0 }; //счетчик совпадений
        for (unsigned int index = 0; index < length; ++index) //проходим по каждому символу
            if (randomWord[index].symbol == wordArr[index].symbol) //если символ стоит на своём месте или мог бы там стоять
                ++coincidence; //увеличиваем счетчик
        if (coincidence == length) //если совпало всё
            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

#include <iostream>

#include <string>

#include <vector>

#include <random>

using std::cin;

using std::cout;

using std::string;

using std::vector;

struct Letter {

unsigned int position;

char symbol;

};

int main()

{

cout << "Enter a word: ";

string word;

cin >> word; //записали слово

unsigned int length = word.size(); //записали длину один раз в целях экономии

vector<Letter> wordArr; //массив слова из структуры-пары (позиция/символ)

for (unsigned int index = 0; index < length; ++index) //заполняем массив

wordArr.push_back(Letter{ index, word[index] });

std::random_device rd;

std::mt19937 mersene(rd());

vector<bool> usingLetter{}; //логический массив-маска для определения, какой символ мы уже подставили

usingLetter.resize(length);

unsigned int count = 1; //счетчик попыток

while (1) { //бесконечный цикл подбора

cout << "#" << count++ << " ";

vector<Letter> randomWord; //массив рандомного варианта

for (unsigned int index = 0; index < length; ++index) //инициализируем маску

usingLetter[index] = false;

for (unsigned int count = 0; count < length; ++count) { //заполняем рандомный вариант, пока не используем все символы

unsigned int index{};

do {

index = mersene() % length; //подбираем индекс

} while (usingLetter[index]); //если мы уже его использовали, подбираем другой

randomWord.push_back(Letter{ wordArr[index].position, wordArr[index].symbol }); //наполняем рандомное слово подобранным символом

usingLetter[index] = true; //обновляем маску

}

for (auto& item : randomWord) //выводим результат

cout << item.position;

cout << " ";

for (auto& item : randomWord)

cout << item.symbol;

cout << "\n";

unsigned int coincidence{ 0 }; //счетчик совпадений

for (unsigned int index = 0; index < length; ++index) //проходим по каждому символу

if (randomWord[index].symbol == wordArr[index].symbol) //если символ стоит на своём месте или мог бы там стоять

++coincidence; //увеличиваем счетчик

if (coincidence == length) //если совпало всё

break; //выходим из бесконечного цикла

}

return 0;

}

Ответить

Дмитрий:

30 августа 2020 в 16:30

Задание 3:

#include <iostream>
#include <windows.h>
#include <ctime>
using namespace std;

bool Compare(int Random_num,int *TempArr,int lenth)/*ф-ия проверяет наличие ранее сгенерированных и присвоенных рандомный чисел*/
{
     int count=0;
     for (int i=0;i<lenth;i++){
          if (TempArr[i]!=Random_num)
               count++;
     }
     if (count==lenth)
          return true;/*Возвращаем true если нету совпадений */
     else
          return false;/*Возвращам false если есть хоть одно совпадение*/
}
bool Compare(char *Arr,char *CopyArr,int lenth)/*ф-ия сравнивает первоначальный и итоговый массив*/
{
     int count=0;
     for (int i=0;i<lenth;i++){
          if (Arr[i]==CopyArr[i])
               count++;
     }
     if (count==lenth)
          return false;/*Завершаем цикл если массивы идентичны*/
     else
          return true;/*Продолжаем работу цикла*/
}

int main()
{
    srand(time(0));
    int Random_num,lenth,counter=0;  /*Random_nam-переменная для врем хр чисел(ранд) lenth-длинна введённой строки counter- счётчик для консоли*/
    char *Arr=new char[0];               /*Массив где хранится неизм введённая строка*/
    gets(Arr);                                 /*вводим строку*/
    lenth=strlen(Arr);                       /*вычисляем и сохраняем длинну*/
    int *TempArr=new int[lenth];        /*Массив для запоминания рандомизированных чисел*/
    char *CopyArr=new char[lenth];     /*массив где хранится изменяеммая строка*/
    for (int i=0;i<lenth;i++){                /*копирование Arr в CopyArr*/
          CopyArr[i]=Arr[i];
    }
    for (int i=0;i<lenth;i++){                /*иницикализация массива для запоминания*/
          TempArr[i]=1000;
    }
    do
    {
          cout <<"["<<counter<<"] ";
          for (int i=0;i<lenth;){                                     /*перетосовка элементов массива СopyArr*/
               Random_num=rand()%lenth+0;                   /*получение рандомного числа от 0 до 2(включительно) */
               if (Compare(Random_num,TempArr,lenth))    /*условие проверки рандомного числа, на возможность повторного записования*/
               {
                    cout <<Random_num;
                    TempArr[i]=Random_num;                   /*запоминаем число, чтобы больше оно не использовалось*/
                    CopyArr[i]=Arr[Random_num];              /*присваиваем элемент массива Arr(c рандомно-выбранным элементом) массиву CopyArr*/
                    i++;                                                /*Переходим ко следующему элементу амссива CopyArr*/
               }
          }
          cout <<"->";
          for (int i=0;i<lenth;i++){         /*выводим результат перестановки*/
               cout <<CopyArr[i];
          }
          cout <<"\t";
          counter++;
          for (int i=0;i<lenth;i++){         /*возращаем стандартные значения элементов массива TempArr(для дальнейшего использования)*/
               TempArr[i]=10;
          }
    }
    while (Compare(Arr,CopyArr,lenth)); /*проверяется условие совпадения первоначального массива Arr и итогового CopyArr*/
    delete[] TempArr;                        /*Освобождаем динамически-занятую память*/
    TempArr=nullptr;
    delete[] CopyArr;
    CopyArr=nullptr;
    delete[] Arr;
    Arr=nullptr;
    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

#include <iostream>

#include <windows.h>

#include <ctime>

using namespace std;

bool Compare(int Random_num,int *TempArr,int lenth)/*ф-ия проверяет наличие ранее сгенерированных и присвоенных рандомный чисел*/

{

int count=0;

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

if (TempArr[i]!=Random_num)

count++;

}

if (count==lenth)

return true;/*Возвращаем true если нету совпадений */

else

return false;/*Возвращам false если есть хоть одно совпадение*/

}

bool Compare(char *Arr,char *CopyArr,int lenth)/*ф-ия сравнивает первоначальный и итоговый массив*/

{

int count=0;

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

if (Arr[i]==CopyArr[i])

count++;

}

if (count==lenth)

return false;/*Завершаем цикл если массивы идентичны*/

else

return true;/*Продолжаем работу цикла*/

}

int main()

{

srand(time(0));

int Random_num,lenth,counter=0; /*Random_nam-переменная для врем хр чисел(ранд) lenth-длинна введённой строки counter- счётчик для консоли*/

char *Arr=new char[0]; /*Массив где хранится неизм введённая строка*/

gets(Arr); /*вводим строку*/

lenth=strlen(Arr); /*вычисляем и сохраняем длинну*/

int *TempArr=new int[lenth]; /*Массив для запоминания рандомизированных чисел*/

char *CopyArr=new char[lenth]; /*массив где хранится изменяеммая строка*/

for (int i=0;i<lenth;i++){ /*копирование Arr в CopyArr*/

CopyArr[i]=Arr[i];

}

for (int i=0;i<lenth;i++){ /*иницикализация массива для запоминания*/

TempArr[i]=1000;

}

do

{

cout <<"["<<counter<<"] ";

for (int i=0;i<lenth;){ /*перетосовка элементов массива СopyArr*/

Random_num=rand()%lenth+0; /*получение рандомного числа от 0 до 2(включительно) */

if (Compare(Random_num,TempArr,lenth)) /*условие проверки рандомного числа, на возможность повторного записования*/

{

cout <<Random_num;

TempArr[i]=Random_num; /*запоминаем число, чтобы больше оно не использовалось*/

CopyArr[i]=Arr[Random_num]; /*присваиваем элемент массива Arr(c рандомно-выбранным элементом) массиву CopyArr*/

i++; /*Переходим ко следующему элементу амссива CopyArr*/

}

cout <<"->";

for (int i=0;i<lenth;i++){ /*выводим результат перестановки*/

cout <<CopyArr[i];

}

cout <<"\t";

counter++;

for (int i=0;i<lenth;i++){ /*возращаем стандартные значения элементов массива TempArr(для дальнейшего использования)*/

TempArr[i]=10;

}

while (Compare(Arr,CopyArr,lenth)); /*проверяется условие совпадения первоначального массива Arr и итогового CopyArr*/

delete[] TempArr; /*Освобождаем динамически-занятую память*/

TempArr=nullptr;

delete[] CopyArr;

CopyArr=nullptr;

delete[] Arr;

Arr=nullptr;

return 0;

}

Ответить

Анастасия:

9 апреля 2020 в 15:58

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

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

/* везде в программе будем использовать тип uint16_t для индексов букв,
потому что:
1) в слове букв немного, это положительное число уж точно меньше 128
2) тип uint8_t не подходит, потому что через cout выводится какая-то ерунда вместо его символов */

// получаем слово от пользователя
std::string get_word()
{
    std::cout << "Программа случайным образом меняет буквы в слове, пока не получит начальное слово.\n";
    std::cout << "Введите слово (лучше не очень длинное): ";
    std::string word;
    std::getline(std::cin, word);
    return word;
}

// функция выбора случайного числа между двумя заданными значениями
static uint16_t getRandomNumber(uint16_t min, uint16_t max)
{
    static const double fraction = 1.0 / static_cast<double>(RAND_MAX + 1.0);
    return static_cast<uint16_t>(rand() * fraction * (max - min + 1) + min);
}

// функция создаёт новое слово по данному слову и индексам букв из него
std::string form_new_word_by_indexes(const std::string& initial_word, const std::vector<uint16_t>& indexes)
{
    std::string new_word{};
    for (uint16_t i = 0; i < initial_word.length(); ++i)
        new_word += initial_word[indexes[i]];
    return new_word;
}

void mix_cycle(const std::string& initial_word);

int main()
{
    // подключаем кириллицу:
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);

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

    return 0;
}

// основной цикл программы: случайно переставляем буквы в данном слове, пока не получим его же
void mix_cycle(const std::string& initial_word)
{
    // количество букв в слове:
    const uint16_t letters_number{ static_cast<uint16_t>(initial_word.length()) };

    // массив доступных для перестановки номеров букв, сначала это все номера по порядку 0, 1, 2, ...
    std::vector <uint16_t> available_indexes{};
    available_indexes.resize(letters_number);
    for (uint16_t i = 0; i < letters_number; ++i)
        available_indexes[i] = i;
    // количество доступных индексов, сначала это все:
    uint16_t available_indexes_number{ letters_number };

    // массив номеров букв для нового слова, сначала там пусто
    std::vector <uint16_t> new_indexes{};
    new_indexes.resize(letters_number);

    unsigned iteration{ 1 };  // счётчик итераций для печати на экране

    while (true)
    {
        std::cout << "[" << iteration++ << "] "; // печатаем номер итерации, после чего его увеличиваем

        // цикл по номерам букв нового слова:
        for (uint16_t i = 0; i < letters_number; ++i)
        {
            // случайно выбираем номер буквы из доступных индексов
            uint16_t new_index = getRandomNumber(0, available_indexes_number - 1);
            new_indexes[i] = available_indexes[new_index];
            std::cout << new_indexes[i];

            /* выбранный индекс меняем местами с последним доступным и уменьшаем количество доступных индексов на 1,
               чтобы сделать его недоступным: */
            std::swap(available_indexes[new_index], available_indexes[available_indexes_number - 1]);
            --available_indexes_number;
        }

        // теперь по начальному слову и индексам букв из него формируем новое слово, печатаем результат:
        std::string new_word = form_new_word_by_indexes(initial_word, new_indexes);
        std::cout << " " << new_word << std::endl;

        // если получилось начальное слово, выходим из цикла while, иначе будем составлять другое слово, перемешивая полученное:
        if (initial_word == new_word)
            break;
        else // готовимся к следующей итерации
        {
            available_indexes_number = letters_number;    // снова все индексы букв доступны
            for (uint16_t i = 0; i < letters_number; ++i)
                available_indexes[i] = new_indexes[i];    // теперь будем перемешивать на основе получившихся индексов
        }
    }
}

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

#include <iostream>

#include <Windows.h> // для кириллицы

#include <string> // для работы со строками

#include <vector> // использую вектор вместо массива, т.к. длина слова заранее не известна

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

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

#include <algorithm> // для std::swap

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

потому что:

1) в слове букв немного, это положительное число уж точно меньше 128

2) тип uint8_t не подходит, потому что через cout выводится какая-то ерунда вместо его символов */

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

std::string get_word()

{

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

std::cout << "Введите слово (лучше не очень длинное): ";

std::string word;

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

return word;

}

// функция выбора случайного числа между двумя заданными значениями

static uint16_t getRandomNumber(uint16_t min, uint16_t max)

{

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

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

}

// функция создаёт новое слово по данному слову и индексам букв из него

std::string form_new_word_by_indexes(const std::string& initial_word, const std::vector<uint16_t>& indexes)

{

std::string new_word{};

for (uint16_t i = 0; i < initial_word.length(); ++i)

new_word += initial_word[indexes[i]];

return new_word;

}

void mix_cycle(const std::string& initial_word);

int main()

{

// подключаем кириллицу:

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

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

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

rand();

mix_cycle(get_word());

return 0;

}

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

void mix_cycle(const std::string& initial_word)

{

// количество букв в слове:

const uint16_t letters_number{ static_cast<uint16_t>(initial_word.length()) };

// массив доступных для перестановки номеров букв, сначала это все номера по порядку 0, 1, 2, ...

std::vector <uint16_t> available_indexes{};

available_indexes.resize(letters_number);

for (uint16_t i = 0; i < letters_number; ++i)

available_indexes[i] = i;

// количество доступных индексов, сначала это все:

uint16_t available_indexes_number{ letters_number };

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

std::vector <uint16_t> new_indexes{};

new_indexes.resize(letters_number);

unsigned iteration{ 1 }; // счётчик итераций для печати на экране

while (true)

{

std::cout << "[" << iteration++ << "] "; // печатаем номер итерации, после чего его увеличиваем

// цикл по номерам букв нового слова:

for (uint16_t i = 0; i < letters_number; ++i)

{

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

uint16_t new_index = getRandomNumber(0, available_indexes_number - 1);

new_indexes[i] = available_indexes[new_index];

std::cout << new_indexes[i];

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

чтобы сделать его недоступным: */

std::swap(available_indexes[new_index], available_indexes[available_indexes_number - 1]);

--available_indexes_number;

}

// теперь по начальному слову и индексам букв из него формируем новое слово, печатаем результат:

std::string new_word = form_new_word_by_indexes(initial_word, new_indexes);

std::cout << " " << new_word << std::endl;

// если получилось начальное слово, выходим из цикла while, иначе будем составлять другое слово, перемешивая полученное:

if (initial_word == new_word)

break;

else // готовимся к следующей итерации

{

available_indexes_number = letters_number; // снова все индексы букв доступны

for (uint16_t i = 0; i < letters_number; ++i)

available_indexes[i] = new_indexes[i]; // теперь будем перемешивать на основе получившихся индексов

}

Ответить

Анастасия:

9 апреля 2020 в 15:57

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

#include <iostream>
#include <iomanip>  // чтобы задать точность для вывода длинных чисел

/* глобальные константы - зло, но тут программа небольшая, 
и они будут использоваться в двух функциях, иначе пришлось создавать бы их в main
и передавать в обе функции, где их прописывать как параметры, а это ужасно удлинняет всё */
const float initial_deposit       { 24.0f };
const float percent_of_deposit    { 6.0f };
const unsigned short first_year   { 1826 };
const unsigned short current_year { 2020 };

// вычисляет текущее состояние депозита, если проценты считаются только от начальной суммы вклада
float current_deposit()
{
    float deposit{ initial_deposit };
    // каждый год депозит увеличивается на 6% от начального вклада
    deposit += (initial_deposit * percent_of_deposit / 100) * (current_year - first_year);
    return deposit;
}

// вычисляет текущее состояние депозита, если проценты начисляются с индексацией
float current_deposit_with_indexation()
{
    float deposit{ initial_deposit };
    // каждый год депозит увеличивается на 6% от текущего остатка (вместе с накопленными процентами)
    for (unsigned short year = (first_year + 1); year <= current_year; year++)
        deposit += deposit * percent_of_deposit / 100;
    return deposit;
}

int main()
{
    setlocale(LC_CTYPE, "rus");
    std::cout << "Остров Манхэттен был приобретён поселенцами за 24$ в 1826 г.\n"
              << "Программа считает, каково было бы в настоящее время состояние счёта,\n"
              << "если бы эти 24$ были помещены тогда в банк под 6% годового дохода\n" << std::endl;
    std::cout << "Состояние счёта, если проценты начислялись без индексации: " << current_deposit() << std::endl;
    std::cout << "Состояние счёта, если проценты начислялись c индексацией: " << std::setprecision(9) << current_deposit_with_indexation() << 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

#include <iostream>

#include <iomanip> // чтобы задать точность для вывода длинных чисел

/* глобальные константы - зло, но тут программа небольшая,

и они будут использоваться в двух функциях, иначе пришлось создавать бы их в main

и передавать в обе функции, где их прописывать как параметры, а это ужасно удлинняет всё */

const float initial_deposit { 24.0f };

const float percent_of_deposit { 6.0f };

const unsigned short first_year { 1826 };

const unsigned short current_year { 2020 };

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

float current_deposit()

{

float deposit{ initial_deposit };

// каждый год депозит увеличивается на 6% от начального вклада

deposit += (initial_deposit * percent_of_deposit / 100) * (current_year - first_year);

return deposit;

}

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

float current_deposit_with_indexation()

{

float deposit{ initial_deposit };

// каждый год депозит увеличивается на 6% от текущего остатка (вместе с накопленными процентами)

for (unsigned short year = (first_year + 1); year <= current_year; year++)

deposit += deposit * percent_of_deposit / 100;

return deposit;

}

int main()

{

setlocale(LC_CTYPE, "rus");

std::cout << "Остров Манхэттен был приобретён поселенцами за 24$ в 1826 г.\n"

<< "Программа считает, каково было бы в настоящее время состояние счёта,\n"

<< "если бы эти 24$ были помещены тогда в банк под 6% годового дохода\n" << std::endl;

std::cout << "Состояние счёта, если проценты начислялись без индексации: " << current_deposit() << std::endl;

std::cout << "Состояние счёта, если проценты начислялись c индексацией: " << std::setprecision(9) << current_deposit_with_indexation() << std::endl;

return 0;

}

Ответить

Анастасия:

9 апреля 2020 в 15:56

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

#include <iostream>
#include <Windows.h>       // для кириллицы
#include <string>

int main()
{
    // подключаем кириллицу:
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);

    std::cout << "Программа считает количество символов в строке без стандартной функции для этого.\nВведите что-нибудь:\n";
    std::string users_text{};
    std::getline(std::cin, users_text);
    
    int string_size{ 0 };
    while (users_text[string_size] != '\0')
    {
        string_size++;
    }

    std::cout << "Вы ввели строку, длина которой " << string_size << 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

#include <iostream>

#include <Windows.h> // для кириллицы

#include <string>

int main()

{

// подключаем кириллицу:

SetConsoleCP(1251);

SetConsoleOutputCP(1251);

std::cout << "Программа считает количество символов в строке без стандартной функции для этого.\nВведите что-нибудь:\n";

std::string users_text{};

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

int string_size{ 0 };

while (users_text[string_size] != '\0')

{

string_size++;

}

std::cout << "Вы ввели строку, длина которой " << string_size << std::endl;

return 0;

}

Ответить

Марат:

3 февраля 2020 в 23:06

Задание №3

#include <iostream>
#include <string>
#include <cstdlib>
#include <ctime>
// Функция возвращает целое число, сгенерированное случайным образом.
int getRandNumber(int value){return rand() % value;}

// Функция конвертирует целое число в символ.
char ConvertToChar(int val) { return val + 48; }

int main()
{
	setlocale(0, "");
	srand(time(0));
	rand();
	std::string str;
	std::cout << "Введите слово: ";
	std::cin >> str;
	std::string generatedString; // строка будет хранить символы введенной пользователем строки в случ. порядке.
	std::string indexes;		 // строка будет хранить индексы символов, переставленых с введенной строки.
	int numberOfIterations(0);	 // счетчик итераций.
	int index(0);				 // индекс, под которым находится символ указанной строки.
	bool thereIsThisIndex;		 // будет хранить true, если такой символ под таким индексом уже был переставлен.

	// с каждой итерацией цикла, мы будем генерировать строку, состоящую из символов введенной пользователем строки,
	// переставленных случайным образом.
	do
	{
		generatedString = ""; // Очищаем наши строки.
		indexes = "";
		//Цикл будет повторяться до тех пор пока, размер нашей сгенерированной строчки не будет равен размеру введенной.
		while (generatedString.size() != str.size())
		{
			thereIsThisIndex = false;
			// генерируем индекс, указывающий на символ, который будем добавлять к нашей генерируемой строке.
			index = rand() % str.size(); 
			for (int i = 0; i < indexes.size(); ++i)
			{
				// если символ под сгенерированным индексом был уже переставлен, завершаем цикл.
				if (ConvertToChar(index) == indexes[i])  
				{
					thereIsThisIndex = true;
					break;
				}
			}
			// если символ под таким индексом не был переставлен, добавляем этот символ к нашей генерируемой строке,
			// а к строке, содержащей индексы символов, которые уже были переставлены, добавляем наш индекс.
			if (!thereIsThisIndex)
			{
				generatedString += str[index];
				indexes += std::to_string(index);
			}
		}
		// Вывод в консоль.
		if (numberOfIterations % 3 == 0)
			std::cout << std::endl;
		std::cout << '[' << numberOfIterations << "] " << indexes << ' ' << generatedString << ' ';
		numberOfIterations++;
	} while (generatedString != str);
	std::cout << std::endl;
	
	system("pause");
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

#include <iostream>

#include <string>

#include <cstdlib>

#include <ctime>

// Функция возвращает целое число, сгенерированное случайным образом.

int getRandNumber(int value){return rand() % value;}

// Функция конвертирует целое число в символ.

char ConvertToChar(int val) { return val + 48; }

int main()

{

setlocale(0, "");

srand(time(0));

rand();

std::string str;

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

std::cin >> str;

std::string generatedString; // строка будет хранить символы введенной пользователем строки в случ. порядке.

std::string indexes; // строка будет хранить индексы символов, переставленых с введенной строки.

int numberOfIterations(0); // счетчик итераций.

int index(0); // индекс, под которым находится символ указанной строки.

bool thereIsThisIndex; // будет хранить true, если такой символ под таким индексом уже был переставлен.

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

// переставленных случайным образом.

do

{

generatedString = ""; // Очищаем наши строки.

indexes = "";

//Цикл будет повторяться до тех пор пока, размер нашей сгенерированной строчки не будет равен размеру введенной.

while (generatedString.size() != str.size())

{

thereIsThisIndex = false;

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

index = rand() % str.size();

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

{

// если символ под сгенерированным индексом был уже переставлен, завершаем цикл.

if (ConvertToChar(index) == indexes[i])

{

thereIsThisIndex = true;

break;

}

// если символ под таким индексом не был переставлен, добавляем этот символ к нашей генерируемой строке,

// а к строке, содержащей индексы символов, которые уже были переставлены, добавляем наш индекс.

if (!thereIsThisIndex)

{

generatedString += str[index];

indexes += std::to_string(index);

}

// Вывод в консоль.

if (numberOfIterations % 3 == 0)

std::cout << std::endl;

std::cout << '[' << numberOfIterations << "] " << indexes << ' ' << generatedString << ' ';

numberOfIterations++;

} while (generatedString != str);

std::cout << std::endl;

system("pause");

return 0;

}

Ответить

Анастасия:

11 апреля 2020 в 11:19

Это решение мне более менее близко,по крайней мере, раскрыта суть идеи Shom, что проверяем, использовали ли уже сгенерированный случайный индекс.
И мне понравилась идея хранить индексы не в каком-нибудь массиве или векторе, а тоже в качестве строки.

Ответить

Shom:

26 декабря 2019 в 13:51

Задание №3

#include <iostream>
#include <iomanip>                     // Для форматирования вывода;
#include <wchar.h>                     // Для работы с кириллицей в Linux;
#include <vector>                      
#include <forward_list>                // Для односвязных списков ("быстрый" контейнер);                   

class MixingWord
{
private:
    std::wstring m_word,                                // Переменная для слова;     
                 m_mixWord;                             // Для "перемешанного" изначального слова;
    size_t m_size;                                      // Длина слова;
    std::vector<size_t> m_vec;                          // Вектор для индекса букв;
    std::forward_list<std::wstring>  m_listMixWord;     // Список для смешанных вариантов слова,       
                                                        //   нужен, чтобы исключать совпадения выриантов;
public:
  MixingWord()                                          // Конструктор;
  {
      setWord();                                        // Запрашиваем слово;
      m_size = m_word.length();                         // Сохраняем длину слова в переменной;
      m_mixWord.resize(m_size);                         // Устанавливаем количество символов в переменной;
      m_vec.resize(m_size);                             // Устанавливаем длину вектора;
      generationWord();                                 // Генерируем варианты;
  }
  
  void setWord()                                        //  Метод введения слова;
  {
      std::wcout << L"Введите слово: ";
      std::wcin  >> m_word;
  }
  
  void mixing()                                        // Метод для "перемешивания" букв
  {                                                    //          в слове;
      size_t temp{0};
      bool key;
      for (size_t iii{0}; iii<m_size; )
      {
          key = false;
          temp = rand()%m_size;
          for (size_t jjj{0}; jjj<iii; ++jjj)         // Проверка на повторения индекса 
          {                                           //    буквы при генерации;
              if(temp == m_vec[jjj])                  // Если совпадение найдено;
              {
                  key = true;                         // Изменяем значение ключа;
                  break;                              // Прерываем цикл;
              }
          }
          if (key) continue;                         // Если было найдено совпадение - прерываем итерацию;
          m_mixWord[iii] = m_word[temp];             // Составляем вариант слова;
          m_vec[iii] = temp;                         // Добавляем индекс буквы в вектор;
          ++iii;
      }
  }
  
  void generationWord()                              // Метод для генерации вариантов; 
  {
      size_t count{0};                               // Счётчик вариантов;
      bool key;
      std::wstring temp;
      while (m_mixWord != m_word)                    // Генерируем пока вариант не совпадёт с изначальным словом;
      {
          key = false;
          mixing();
          for (const auto& word : m_listMixWord)    // Проверяем вариант на повторяемовсть;
          {
              if (m_mixWord == word)                // Если найдено совпадение;
              {
                  key = true;                       // Изменяем значение ключа;
                  break;                            // Прерываем цикл;
              }
          }
          if (key) continue;                        // Если найдено совпадение, то завершаем итерацию;
          m_listMixWord.push_front(m_mixWord);      // Добавляем вариант в список;
          temp = L"[" + std::to_wstring(count) + L"] ";           // Создаём строку для вывода номера варианта;
          std::wcout << std::setw(8) << std::right << temp;       // Выводим на экран номер варианта,
          for (const auto& num : m_vec) std::wcout << num;        //    индексы букв,
          std::wcout << L" " << m_mixWord << L" ";
          if((count+1)%3 == 0) std::wcout << L'\n';               //      вариант слова; 
          ++count;
      }
      std::wcout << L"\n\n";
  }    
};                           
                 
int main()
{
    setlocale(LC_ALL, "");                     // Подключаем локаль;
    srand(time(0));                            // Задаём точку отсчёта для генерации случайных чисел;
    std::wcout << L"    *** Программа в случайном порядке переставляет\
 буквы в слове ***\n\n"; 
 
    MixingWord m;                              // Создаём объект класса; 
    
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

#include <iostream>

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

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

#include <vector>

#include <forward_list> // Для односвязных списков ("быстрый" контейнер);

class MixingWord

{

private:

std::wstring m_word, // Переменная для слова;

m_mixWord; // Для "перемешанного" изначального слова;

size_t m_size; // Длина слова;

std::vector<size_t> m_vec; // Вектор для индекса букв;

std::forward_list<std::wstring> m_listMixWord; // Список для смешанных вариантов слова,

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

public:

MixingWord() // Конструктор;

{

setWord(); // Запрашиваем слово;

m_size = m_word.length(); // Сохраняем длину слова в переменной;

m_mixWord.resize(m_size); // Устанавливаем количество символов в переменной;

m_vec.resize(m_size); // Устанавливаем длину вектора;

generationWord(); // Генерируем варианты;

}

void setWord() // Метод введения слова;

{

std::wcout << L"Введите слово: ";

std::wcin >> m_word;

}

void mixing() // Метод для "перемешивания" букв

{ // в слове;

size_t temp{0};

bool key;

for (size_t iii{0}; iii<m_size; )

{

key = false;

temp = rand()%m_size;

for (size_t jjj{0}; jjj<iii; ++jjj) // Проверка на повторения индекса

{ // буквы при генерации;

if(temp == m_vec[jjj]) // Если совпадение найдено;

{

key = true; // Изменяем значение ключа;

break; // Прерываем цикл;

}

if (key) continue; // Если было найдено совпадение - прерываем итерацию;

m_mixWord[iii] = m_word[temp]; // Составляем вариант слова;

m_vec[iii] = temp; // Добавляем индекс буквы в вектор;

++iii;

}

void generationWord() // Метод для генерации вариантов;

{

size_t count{0}; // Счётчик вариантов;

bool key;

std::wstring temp;

while (m_mixWord != m_word) // Генерируем пока вариант не совпадёт с изначальным словом;

{

key = false;

mixing();

for (const auto& word : m_listMixWord) // Проверяем вариант на повторяемовсть;

{

if (m_mixWord == word) // Если найдено совпадение;

{

key = true; // Изменяем значение ключа;

break; // Прерываем цикл;

}

if (key) continue; // Если найдено совпадение, то завершаем итерацию;

m_listMixWord.push_front(m_mixWord); // Добавляем вариант в список;

temp = L"[" + std::to_wstring(count) + L"] "; // Создаём строку для вывода номера варианта;

std::wcout << std::setw(8) << std::right << temp; // Выводим на экран номер варианта,

for (const auto& num : m_vec) std::wcout << num; // индексы букв,

std::wcout << L" " << m_mixWord << L" ";

if((count+1)%3 == 0) std::wcout << L'\n'; // вариант слова;

++count;

}

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

}

};

int main()

{

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

srand(time(0)); // Задаём точку отсчёта для генерации случайных чисел;

std::wcout << L" *** Программа в случайном порядке переставляет\

буквы в слове ***\n\n";

MixingWord m; // Создаём объект класса;

return 0;

}

Ответить

Марат:

3 февраля 2020 в 23:19

Ваш вариант мне понравился!

Ответить
1. Shom:
  
  4 февраля 2020 в 10:49
  
  Спасибо!
  
  Ответить

Анастасия:

11 апреля 2020 в 11:04

А мне это решение показалось сложным.
В частности, в функции mixing() не хватило комментария, что же всё-таки проверяет key. И следующий вложенный цикл тоже я не поняла:

          for (size_t jjj{0}; jjj<iii; ++jjj)         // Проверка на повторения индекса 
          {                                           //    буквы при генерации;
              if(temp == m_vec[jjj])                  // Если совпадение найдено;
              {
                  key = true;                         // Изменяем значение ключа;
                  break;                              // Прерываем цикл;
              }
          }

1

2

3

4

5

6

7

8

for (size_t jjj{0}; jjj<iii; ++jjj) // Проверка на повторения индекса

{ // буквы при генерации;

if(temp == m_vec[jjj]) // Если совпадение найдено;

{

key = true; // Изменяем значение ключа;

break; // Прерываем цикл;

}

почему jjj ограничен iii и зачем сравнивать индексы?

Ответить

Shom:

11 апреля 2020 в 15:18

key становится true если данную букву мы уже раньше переставили (буквы проверяются по индексу — местоположению в слове, так как в слове может встречаться несколько одинаковых букв), key == true прерывает текущую итерацию и не даёт счётчику букв (iii) увеличиться на единицу, то-есть, следующая итерация будет подбирать букву для того-же индекса (местоположения в слове).
jjj ограничен iii так как iii представляет собой длину уже набранной части "перемешанного слова", а цикл с jjj проверяет совпадение только-что сгенерированного числа (ограниченного длиной заданного слова) с использованными индексами букв заданного слова.

Ответить

Shom:

24 декабря 2019 в 16:47

Задание №2.

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

                 
int main()
{
    std::cout << "    *** Программа расчитывает сумму на депозите в конце срока вклада ***\n\n"; 
    const size_t money{24},                          // Начальный капитал;
                 interest{6},                        // Банковский процент;
                 startingYear{1826},                 // Год открыти вклада;
                 endYear{2019},                      // Год окончания вклада;
                 period(endYear-startingYear);       // Период вклада;
    double deposit{static_cast<double>(money)};      // Переменная для расчёта увеличивающейся
                                                     //   суммы вклада; 
    for (size_t iii{0}; iii<period; ++iii)           // Расчёт;
    {
        deposit += (deposit*(static_cast<double>(interest))/100);
    }
    std::cout << "Сумма составила бы $" << std::fixed << std::setprecision(2)
                                                           << deposit << "\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

#include <iostream>

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

int main()

{

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

const size_t money{24}, // Начальный капитал;

interest{6}, // Банковский процент;

startingYear{1826}, // Год открыти вклада;

endYear{2019}, // Год окончания вклада;

period(endYear-startingYear); // Период вклада;

double deposit{static_cast<double>(money)}; // Переменная для расчёта увеличивающейся

// суммы вклада;

for (size_t iii{0}; iii<period; ++iii) // Расчёт;

{

deposit += (deposit*(static_cast<double>(interest))/100);

}

std::cout << "Сумма составила бы $" << std::fixed << std::setprecision(2)

<< deposit << "\n";

return 0;

}

Ответить

Shom:

24 декабря 2019 в 14:57

#include <iostream>
#include <wchar.h>              // Для работы с кириллицей в Linux;
#include <locale>               // Для подключения кириллицы;
                    
                 
int main()
{
    setlocale(LC_ALL, "");                      // Подключаем кириллицу;
    std::wcout << L"    *** Программа определяет длину строки. ***\n\n";
    
    std::wcout << L"Введите строку: ";
    std::wstring str;                          // Переменная для строки;
    std::getline(std::wcin, str);              // Вводим строку;
    str += L'\n';                              // Добавляем символ в конец строки;
    
    wchar_t c{L' '};                           // Переменная для символа;
    size_t count{0};                           // Счётчик;
    while (c != '\n')                          // Пока не достигнем конца строки
    {                                          // ... перебираем символы в строке;
        c = str[count];                        
        ++count;
    }
    
    std::wcout << L"Строка имеет длину " << --count << L" символов.\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

#include <iostream>

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

#include <locale> // Для подключения кириллицы;

int main()

{

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

std::wcout << L" *** Программа определяет длину строки. ***\n\n";

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

std::wstring str; // Переменная для строки;

std::getline(std::wcin, str); // Вводим строку;

str += L'\n'; // Добавляем символ в конец строки;

wchar_t c{L' '}; // Переменная для символа;

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

while (c != '\n') // Пока не достигнем конца строки

{ // ... перебираем символы в строке;

c = str[count];

++count;

}

std::wcout << L"Строка имеет длину " << --count << L" символов.\n";

return 0;

}

Ответить

Владимир:

18 декабря 2019 в 21:35

//Задание №3
#include <iostream>
#include <string>
#include <Windows.h>
#include <random> 

int randNum(int length) // генерируем "случайное" число
{
	std::random_device rd;
	std::mt19937 mersenne(rd());
	return mersenne() % length;
}

int main()
{
	SetConsoleCP(1251); SetConsoleOutputCP(1251);
	std::cout << "Программа, используя генерацию случайных чисел, переставляет буквы слова в рандомном порядке,\n"
		"пока полученное слово не совпадёт с начальным словом.\nВведите слово : ";
	std::string str;
	std::cin >> str;
	int len = str.length(); // длина слова
	int count(0); // счетчик вариантов слова
	int score{ 0 }; // счетчик несовпадений индексов
	int* index_arr = new int[len]; // массив индексов
	int* index_contr = new int[len]; // начальное расположение индексов
	std::cout << std::endl;
	while (true) {
		std::cout << "[" << count++ << "] ";

		for (int i(0); i < len; ++i) { // индексами символов user-слова 
			index_arr[i] = i; // заполняется массив index_arr
			index_contr[i] = index_arr[i]; // и index_contr
		}
		for (int j(0); j < len; ++j) // рандомно мешает индексы в index_arr
			std::swap(index_arr[j], index_arr[randNum(len)]);

		for (int q(0); q < len; ++q) // и выводит результат
			std::cout << index_arr[q];
		std::cout << " ";

		for (int k(0); k < len; ++k) // выводит символы user-слова
			std::cout << str[index_arr[k]]; // в соответствии с ранд. индексами index_arr
		std::cout << "\t\t";

		score = 0;
		for (int t(0); t < len; ++t) // сравнивает индексы index_contr и index_arr
			if (index_contr[t] != index_arr[t]) // если есть несовпадение
				++score; // фиксируем в счетчике

		if ((count + 1) % 3 == 1) // реализация вывода в три col (колонки)
			std::cout << "\n";

		if (score == 0) // если все индексы массивов совпали
			break; // заканчиваем выполнение программы
	}
	std::cout << std::endl;
	delete[] index_arr;
	delete[] index_contr;
	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

//Задание №3

#include <iostream>

#include <string>

#include <Windows.h>

#include <random>

int randNum(int length) // генерируем "случайное" число

{

std::random_device rd;

std::mt19937 mersenne(rd());

return mersenne() % length;

}

int main()

{

SetConsoleCP(1251); SetConsoleOutputCP(1251);

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

"пока полученное слово не совпадёт с начальным словом.\nВведите слово : ";

std::string str;

std::cin >> str;

int len = str.length(); // длина слова

int count(0); // счетчик вариантов слова

int score{ 0 }; // счетчик несовпадений индексов

int* index_arr = new int[len]; // массив индексов

int* index_contr = new int[len]; // начальное расположение индексов

std::cout << std::endl;

while (true) {

std::cout << "[" << count++ << "] ";

for (int i(0); i < len; ++i) { // индексами символов user-слова

index_arr[i] = i; // заполняется массив index_arr

index_contr[i] = index_arr[i]; // и index_contr

}

for (int j(0); j < len; ++j) // рандомно мешает индексы в index_arr

std::swap(index_arr[j], index_arr[randNum(len)]);

for (int q(0); q < len; ++q) // и выводит результат

std::cout << index_arr[q];

std::cout << " ";

for (int k(0); k < len; ++k) // выводит символы user-слова

std::cout << str[index_arr[k]]; // в соответствии с ранд. индексами index_arr

std::cout << "\t\t";

score = 0;

for (int t(0); t < len; ++t) // сравнивает индексы index_contr и index_arr

if (index_contr[t] != index_arr[t]) // если есть несовпадение

++score; // фиксируем в счетчике

if ((count + 1) % 3 == 1) // реализация вывода в три col (колонки)

std::cout << "\n";

if (score == 0) // если все индексы массивов совпали

break; // заканчиваем выполнение программы

}

std::cout << std::endl;

delete[] index_arr;

delete[] index_contr;

return 0;

}

Ответить

Анастасия:

11 апреля 2020 в 10:47

Владимир, в Вашей программе есть один существенный недочёт:

score = 0;
for (int t(0); t < len; ++t) // сравнивает индексы index_contr и index_arr
      if (index_contr[t] != index_arr[t]) // если есть несовпадение
            ++score; // фиксируем в счетчике
if (score == 0) // если все индексы массивов совпали
      break; // заканчиваем выполнение программы

1

2

3

4

5

6

score = 0;

for (int t(0); t < len; ++t) // сравнивает индексы index_contr и index_arr

if (index_contr[t] != index_arr[t]) // если есть несовпадение

++score; // фиксируем в счетчике

if (score == 0) // если все индексы массивов совпали

break; // заканчиваем выполнение программы

Во-первых, индексы могут и не совпадать, главное чтобы совпадали буквы! В том же слове "корова" начальные индексы 012345 не совпадут с 032145, но слово совпадёт.
Во-вторых, зачем считать количество несовпадений индексов, когда важен сам факт, есть они или нет. То есть выходить из цикла можно при первом же несовпадении.

Ну, и ещё один момент. У вас целый ряд одинаковых циклов for, почему бы и не использовать для каждого одну и ту же переменную i, ведь она создаётся и живёт только в одном цикле, не влияя на другие, можно было не придумывать все эти j, k, q, t…

Ответить

Алена:

12 декабря 2019 в 17:50

Задача 2.

#include <iostream>
#include <iomanip> // для std::setprecision()

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

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

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

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

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

// Функция принимает в качестве параметра текущий год
// Вычисления начинаются с 1826 года, по 6% годовых
// Функция возвращает состояние счета
double moneyAccount(int year)
{
	double sumAayment = 24; //стартовая сумма вклада

	// начисление процентов начинается через год, поэтому начинаем с 1827 года
	for (int count = 1827; count <= year; ++count)
	{
		sumAayment *= 1.06; // 6% годовых
	}
	return sumAayment;
}

int main()
{
	setlocale(LC_ALL, "Rus");
	std::cout << "***Остров Манхэттен был приобретён поселенцами за $24 в 1826 г.***\n"
		<< "***Каково было бы в настоящее время состояние их счёта,***\n"
		<< "***если бы эти 24 доллара были помещены тогда в банк под 6% годового дохода?***\n\n"
		<< "Введите год: ";
	int presentYear = getUserValue();
	std::cout << "В " << presentYear << " году состояние счета было бы равно: "
		<< std::setprecision(20) << moneyAccount(presentYear) << "\n\n";
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

#include <iostream>

#include <iomanip> // для std::setprecision()

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

int getUserValue()

{

while (true)

{

int value;

std::cin >> value;

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

{

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

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

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

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

}

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

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

{

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

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

}

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

{

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

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

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

}

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

}

// Функция принимает в качестве параметра текущий год

// Вычисления начинаются с 1826 года, по 6% годовых

// Функция возвращает состояние счета

double moneyAccount(int year)

{

double sumAayment = 24; //стартовая сумма вклада

// начисление процентов начинается через год, поэтому начинаем с 1827 года

for (int count = 1827; count <= year; ++count)

{

sumAayment *= 1.06; // 6% годовых

}

return sumAayment;

}

int main()

{

setlocale(LC_ALL, "Rus");

std::cout << "***Остров Манхэттен был приобретён поселенцами за $24 в 1826 г.***\n"

<< "***Каково было бы в настоящее время состояние их счёта,***\n"

<< "***если бы эти 24 доллара были помещены тогда в банк под 6% годового дохода?***\n\n"

<< "Введите год: ";

int presentYear = getUserValue();

std::cout << "В " << presentYear << " году состояние счета было бы равно: "

<< std::setprecision(20) << moneyAccount(presentYear) << "\n\n";

}

Ответить

Анастасия:

11 апреля 2020 в 10:07

Тогда уж нужно просить ввести текущий год. Или в предыстории писать, что программа вычисляет состояние счёта на заданный год, а не на настоящий момент.
sumAayment — странноватое название переменной.

Ответить

Алена:

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

Задача 1.

#include <iostream>
#include <string>

//Функция вычисляет длину строки без использования стандартной функции.
int lengthString(const std::string& someString)
{
	int index = 0;
	while (someString[index] != '\0')
		index++;
	return index;
}

int main()
{
	setlocale(LC_ALL, "Rus");
	std::cout << "***Программа вычисляет длину строки без использования стандартной функции определения длины***\n\n";
	std::cout << "Введите строку : ";
	std::string userString;
	std::getline(std::cin, userString);
	std::cout << "В веденной строке " << lengthString(userString) << " символов\n\n";
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

#include <iostream>

#include <string>

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

int lengthString(const std::string& someString)

{

int index = 0;

while (someString[index] != '\0')

index++;

return index;

}

int main()

{

setlocale(LC_ALL, "Rus");

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

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

std::string userString;

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

std::cout << "В веденной строке " << lengthString(userString) << " символов\n\n";

}

Ответить

Владимир:

17 ноября 2019 в 00:54

Задание №2

#include <iostream>
#define PLUS_SIX_PERCENT 1.06
#define YEAR_1826 1826
#define YEAR_2019 2019
#define DOLLARS_24 24

int main()
{
	setlocale(LC_ALL, "rus");
	double dollars(DOLLARS_24); // начальный капитал 
	int years(YEAR_1826); // начало отсчета времени (лет)
	std::cout << "Остров Манхэттен был приобретён поселенцами за $24 в 1826 г.,\n";
	while (years++ <= YEAR_2019) dollars *= PLUS_SIX_PERCENT;
	std::cout << "в банке под 6 % годовых до 2019г. (включительно) эти деньги стоили бы : " << dollars << " $\n";
	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

#include <iostream>

#define PLUS_SIX_PERCENT 1.06

#define YEAR_1826 1826

#define YEAR_2019 2019

#define DOLLARS_24 24

int main()

{

setlocale(LC_ALL, "rus");

double dollars(DOLLARS_24); // начальный капитал

int years(YEAR_1826); // начало отсчета времени (лет)

std::cout << "Остров Манхэттен был приобретён поселенцами за $24 в 1826 г.,\n";

while (years++ <= YEAR_2019) dollars *= PLUS_SIX_PERCENT;

std::cout << "в банке под 6 % годовых до 2019г. (включительно) эти деньги стоили бы : " << dollars << " $\n";

return 0;

}

Ответить

Анастасия:

11 апреля 2020 в 10:03

По ряду причин не рекомендуется использовать #define для констант, в частности:
1) при этом не учитывается тип константы, что может привести к ошибкам сужения типов, например.
2) такие константы не отслеживаются при отладке.

Ответить

Владимир:

17 ноября 2019 в 00:52

Задание №1

#include <iostream>

bool makeChoice(char& choice) // предлагаем повторить 
{
	std::cout << "хотите ";
	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");
	char choice; // продолжение (да/нет) 
	int length; // длина строки

	std::cout << "Программа определяет длину строки";
	do {
		std::cout << "\nвведите строку : ";
		length = 0;
		while (getchar() != '\n') ++length;
		std::cout << "длина строки : " << length << "\n";
	} 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

#include <iostream>

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

{

std::cout << "хотите ";

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

char choice; // продолжение (да/нет)

int length; // длина строки

std::cout << "Программа определяет длину строки";

do {

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

length = 0;

while (getchar() != '\n') ++length;

std::cout << "длина строки : " << length << "\n";

} while (makeChoice(choice));

return 0;

}

Ответить

Юлия:

20 октября 2019 в 12:21

№3

#include <iostream>
#include <locale>
#include <Windows.h>
#include <fstream>
#include <string>
#include <time.h>
#include <conio.h>

#define MAX_NUMBER	9999999

using namespace std;

string get_s ();
unsigned int get_rand (unsigned int min, unsigned int max);
char YesNo ();
string swap_letters (string);

int main()
{
	setlocale (LC_ALL, "Russian");
	SetConsoleOutputCP (1251);
	SetConsoleCP (1251);

	time_t time_time = time (NULL);
	srand (static_cast <unsigned int> (time_time));

	while (true)
	{
		cout << "\nВведите слово (для ввода enter или пробел): ";
		string s = get_s ();
		string swap_string = s;
		unsigned int counter = 0;
		do
		{
			counter++;
			cout << "Итерация №" << counter << " ";
			cout << swap_string << " ";
			swap_string = swap_letters (swap_string);
			cout << swap_string << endl;
		} while (swap_string != s);

		cout << "\n\nХотите продолжить? (Yes/No)\n";
		if (!YesNo ())
			break;
	}

	return 0;
}

string swap_letters (string s)
{
	unsigned short length = s.length ();
	string new_s;
	while (length)
	{
		unsigned short n = get_rand (0, length - 1);
		new_s.push_back (s[n]);
		s.erase (n, 1);
		length--;
	}


	return new_s;
}

string get_s ()
{
	string s;
	char a;
	int i = 0;
	do
	{
		a = _getch ();
		_putch (a);

		if (a != 13 && a != '\b' && a != ' ')		// пробел не считается символом
			s.push_back (a);

		i++;
		if (a == '\b')
		{
			i -= 2;
			cout << "  " << "\b\b";
			s.pop_back ();
		}

	} while (a != 13 && a != ' ');		// Конец строки - Enter или пробел
	cout << endl;
	return s;
}

unsigned int get_rand (unsigned int min = 0, unsigned int max = MAX_NUMBER)
{
	unsigned int rand_number = min + rand () % (max - min + 1);
	return rand_number;
}

char YesNo () {
	char a;
	while (1) {
		a = _getch ();
		if (a == 'y' || a == 'Y' || a == 'н' || a == 'Н')
			return TRUE;
		else if (a == 'n' || a == 'N' || a == 'т' || a == 'Т')
			return FALSE;
	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

#include <iostream>

#include <locale>

#include <Windows.h>

#include <fstream>

#include <string>

#include <time.h>

#include <conio.h>

#define MAX_NUMBER 9999999

using namespace std;

string get_s ();

unsigned int get_rand (unsigned int min, unsigned int max);

char YesNo ();

string swap_letters (string);

int main()

{

setlocale (LC_ALL, "Russian");

SetConsoleOutputCP (1251);

SetConsoleCP (1251);

time_t time_time = time (NULL);

srand (static_cast <unsigned int> (time_time));

while (true)

{

cout << "\nВведите слово (для ввода enter или пробел): ";

string s = get_s ();

string swap_string = s;

unsigned int counter = 0;

do

{

counter++;

cout << "Итерация №" << counter << " ";

cout << swap_string << " ";

swap_string = swap_letters (swap_string);

cout << swap_string << endl;

} while (swap_string != s);

cout << "\n\nХотите продолжить? (Yes/No)\n";

if (!YesNo ())

break;

}

return 0;

}

string swap_letters (string s)

{

unsigned short length = s.length ();

string new_s;

while (length)

{

unsigned short n = get_rand (0, length - 1);

new_s.push_back (s[n]);

s.erase (n, 1);

length--;

}

return new_s;

}

string get_s ()

{

string s;

char a;

int i = 0;

do

{

a = _getch ();

_putch (a);

if (a != 13 && a != '\b' && a != ' ') // пробел не считается символом

s.push_back (a);

i++;

if (a == '\b')

{

i -= 2;

cout << " " << "\b\b";

s.pop_back ();

}

} while (a != 13 && a != ' '); // Конец строки - Enter или пробел

cout << endl;

return s;

}

unsigned int get_rand (unsigned int min = 0, unsigned int max = MAX_NUMBER)

{

unsigned int rand_number = min + rand () % (max - min + 1);

return rand_number;

}

char YesNo () {

char a;

while (1) {

a = _getch ();

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

return TRUE;

else if (a == 'n' || a == 'N' || a == 'т' || a == 'Т')

return FALSE;

}

Ответить

Юлия:

20 октября 2019 в 12:23

Извините, не дочитала 3-е задание до конца. Вместо индексов у меня выводит перемешанное слово.

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

11 апреля 2020 в 09:55

Зачем писать свою функцию get_s (), да ещё и такую вычурную, с непонятными переменными-символами, если есть прекрасная std::getline(std::cin, строковая переменная), которая для этого и существует?

Ответить

Юлия:

20 октября 2019 в 11:03

№2

#include <iostream>
#include <locale>
#include <Windows.h>
#include <time.h>

using namespace std;

int main()
{
	setlocale (LC_ALL, "Russian");
	SetConsoleOutputCP (1251);
	SetConsoleCP (1251);

	// Отсчет времени начинается с 01.01.1970
	// Вычислим годы с 01.01.1970:
	time_t year = time (NULL) / 60 / 60 / 24 / 364;
	cout << "На данный момент ";
	cout << "с 1970 года прошло " << year << " лет, ";
	// Прибавим к ним годы с 1826 по 1970:
	year = year + (1970 - 1826);
	cout << "с 1826 года прошло " << year << " лет.";

	long double dollars = 24, percent = 6;
	for (unsigned int i = 0; i < year; i++)
	{
		dollars *= 1 + percent / 100;
		if (dollars < 1000)
			cout << "\nВ " << 1826 + 1 + i << " году " << dollars << " долларов;";
		else if (dollars < 1000000)
			cout << "\nВ " << 1826 + 1 + i << " году " << dollars / 1000 << " тысяч долларов;";
		else 
			cout << "\nВ " << 1826 + 1 + i << " году " << dollars / 1000000 << " млн долларов;";
	}

	return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

#include <iostream>

#include <locale>

#include <Windows.h>

#include <time.h>

using namespace std;

int main()

{

setlocale (LC_ALL, "Russian");

SetConsoleOutputCP (1251);

SetConsoleCP (1251);

// Отсчет времени начинается с 01.01.1970

// Вычислим годы с 01.01.1970:

time_t year = time (NULL) / 60 / 60 / 24 / 364;

cout << "На данный момент ";

cout << "с 1970 года прошло " << year << " лет, ";

// Прибавим к ним годы с 1826 по 1970:

year = year + (1970 - 1826);

cout << "с 1826 года прошло " << year << " лет.";

long double dollars = 24, percent = 6;

for (unsigned int i = 0; i < year; i++)

{

dollars *= 1 + percent / 100;

if (dollars < 1000)

cout << "\nВ " << 1826 + 1 + i << " году " << dollars << " долларов;";

else if (dollars < 1000000)

cout << "\nВ " << 1826 + 1 + i << " году " << dollars / 1000 << " тысяч долларов;";

else

cout << "\nВ " << 1826 + 1 + i << " году " << dollars / 1000000 << " млн долларов;";

}

return 0;

}

Ответить

Анастасия:

11 апреля 2020 в 09:49

слишком много магических чисел. И почему у Вас 364 дня в году?

Ответить

Юлия:

20 октября 2019 в 10:35

№1

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

using namespace std;

string get_s ();
unsigned short lenght_s (string);
char YesNo ();

int main()
{
	setlocale (LC_ALL, "Russian");
	SetConsoleOutputCP (1251);
	SetConsoleCP (1251);

	while (true)
	{
		cout << "\nВведите строку: ";
		string s = get_s ();
		cout << "\nВаша строка состоит из " << lenght_s (s) << " символов";
		cout << "\n\nХотите продолжить? (Yes/No)\n";
		if (!YesNo ())
			break;
	}
	return 0;
}

unsigned short lenght_s (string s)
{
	unsigned short i = 0;
	while (s[i])
		i++;
	return i;
}

// ********** (Конец строки - Enter, пробел считается символом) *********
string get_s ()
{
	string s;
	char a;
	int i = 0;
	do
	{
		a = _getch ();
		_putch (a);

		if (a != 13 && a != '\b')
			s.push_back (a);

		i++;
		if (a == '\b')
		{
			i -= 2;
			s.pop_back ();
		}

	} while (a != 13);

	return s;
}

char YesNo () {
	char a;
	while (1) {
		a = _getch ();
		if (a == 'y' || a == 'Y' || a == 'н' || a == 'Н')
			return TRUE;
		else if (a == 'n' || a == 'N' || a == 'т' || a == 'Т')
			return FALSE;
	}
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

#include <iostream>

#include <locale>

#include <Windows.h>

#include <string>

#include <conio.h>

using namespace std;

string get_s ();

unsigned short lenght_s (string);

char YesNo ();

int main()

{

setlocale (LC_ALL, "Russian");

SetConsoleOutputCP (1251);

SetConsoleCP (1251);

while (true)

{

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

string s = get_s ();

cout << "\nВаша строка состоит из " << lenght_s (s) << " символов";

cout << "\n\nХотите продолжить? (Yes/No)\n";

if (!YesNo ())

break;

}

return 0;

}

unsigned short lenght_s (string s)

{

unsigned short i = 0;

while (s[i])

i++;

return i;

}

// ********** (Конец строки - Enter, пробел считается символом) *********

string get_s ()

{

string s;

char a;

int i = 0;

do

{

a = _getch ();

_putch (a);

if (a != 13 && a != '\b')

s.push_back (a);

i++;

if (a == '\b')

{

i -= 2;

s.pop_back ();

}

} while (a != 13);

return s;

}

char YesNo () {

char a;

while (1) {

a = _getch ();

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

return TRUE;

else if (a == 'n' || a == 'N' || a == 'т' || a == 'Т')

return FALSE;

}

Ответить

Анастасия:

9 апреля 2020 в 16:19

Сама функция подсчёта символов в строке — простая и понятная, ей бы и можно было ограничено, что это за действия в get_s — большой вопрос… Зачем так сложно?

Ответить

Илья:

21 августа 2019 в 16:38

Задание 2:

#include <iostream>
#include <cmath>

int main()
{
	std::cout << (24 * (pow(1.06,2019 - 1826) - 1) / 0.06) << std::endl;
    return 0;
}

1

2

3

4

5

6

7

8

#include <iostream>

#include <cmath>

int main()

{

std::cout << (24 * (pow(1.06,2019 - 1826) - 1) / 0.06) << std::endl;

return 0;

}

Ответить

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

Easy: Задание №1

Medium: Задание №2

Hard: Задание №3

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

Добавить комментарий Отменить ответ