МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ

НАЦІОНАЛЬНИЙ ТЕХНІЧНИЙ УНІВЕРСИТЕТ УКРАЇНИ

“КИЇВСЬКИЙ ПОЛІТЕХНІЧНИЙ ІНСТИТУТ ІМЕНІ ІГОРЯ
СІКОРСЬКОГО”
ІНСТИТУТ ТЕЛЕКОМУНІКАЦІЙНИХ СИСТЕМ

Дисципліна:
«Інформатика»
Лабораторна робота №3
Робота з символьними строками. Робота з динамічно розподіляємою
памяттю

Виконав
студент групи ТІ-82
Буткевич Г.Ю.
Варіант №4

Київ 2019
Мета: розробка, налагодження та виконання программ на мові прграмування С++ для виконання
операцій над символьними строками та динамічними масивами.

ІІ.3 Завдання на лабораторну роботу ІІ.3.1 Реалізувати програмно рішення наступного завдання.

Дано: 1. Рядок символів Stroka, яка за вибором користувача:  задається випадковим чином
(кількість символів у рядку вводиться користувачем), також користувач в даному випадку визначає, з
яких символів формується рядок:  тільки з цифр;  тільки з літер (можлива кирилиця та латиниця); 
з будь-яких символів;  вводиться користувачем (к-ть символів визначається після закінчення вводу).
2. Рядок символів Stroka2, яка вводиться користувачем (к-ть символів визначається після закінчення
вводу). Реалізувати: 14. Відсортувати символи в рядку Stroka методом швидкого сортування. 17

15. Визначити:  Чи містить початковий рядок Stroka всі символи з Stroka2;  замінити всі символи в
початковому рядку Stroka рівні символам з Stroka2 на символ #;  визначити скільки разів Stroka2
зустрічається в початковому рядку Stroka. ІІ.3.2 Реалізувати програмно рішення наступного завдання.
Дано: Двовимірний динамічний масив n×n, елементами котрого будуть псевдовипадкові цілі числа
від -50 до 50. Реалізувати: Знаходження мінімального та максимального значень елементів,
розташованих в зафарбованій частині масиву з пункту 4. Область для пошуку елементів вибирається
згідно варіанту. Обов’язкові умови: Кожний пункт з «Реалізувати:» п.п. І.1 и І.2 має бути реалізованим
у вигляді окремої функції в межах однієї програми. В тілі функції реалізується тільки логіка роботи
программи (пунктів «Реалізувати:»). Інтерфейс роботи с користувачем, тобто ввід/вивід даних і
результатів роботи реалізуеться в тілі функції main або в будь-якій іншої окремої функції, але ж не в
функціях, реалізуючих пункти из «Реалізувати:».

Код:
#include <iostream>

#include <string>

#include <ctime>

#define DEBUG false

using namespace std;

char randomChar(int);

int parseInt(string);

int getInt(string, int);

string quickSort(string, int, int, bool);

void printDoubleArray(int**, int, int);

int minmaxOfArray(int**, int, int, bool);

bool isContainsAllChars(string, string);

string replace(string, string, char);

int numOfHits(string, string);

void main() {

setlocale(LC_ALL, "Russian");

system("chcp 1251");
system("cls");

string str, str2;

srand(time(NULL));

cout << "Виберiть метод: " << endl;

cout << "1. Ручне введення рядка" << endl;

cout << "2. Випадкове заповнення рядка" << endl;

bool random = getInt(" Виберiть вiдповiдь: ", 2) - 1;

// random = 1;

cout << endl;

if (random) {

int lenght = getInt("Введiть довжину рядка (до 100): ", 99);

cout << endl;

cout << "Заповнення рядка: " << endl;

cout << "1. Цифри" << endl;

cout << "2. Букви" << endl;

cout << "3. Будь-якi символи" << endl;

int type = getInt(" Виберiть вiдповiдь: ", 3);

// int type = 1;

str.resize(lenght);

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

str[i] = randomChar(type);

cout << endl;

cout << "Первий рядок: ";

cout << str;

cout << endl;

else {

cout << "Другий рядок: ";

cin >> str;

cout << "Другий рядок: ";

cin >> str2;

cout << endl;

cout << "Бажаете вивести хiд сортування? " << endl;

cout << "1. Да" << endl;

cout << "2. Нi" << endl;

bool print = !(getInt(" Выберiть вiдповiдь: ", 2) - 1);

// bool print = 1;

cout << endl;

if (print) {

for (int n = 0; n < str.size(); ++n) cout << "-";

cout << endl << str << endl << endl;

cout << endl << quickSort(str, 0, str.size() - 1, print) << endl;

if (print) {

for (int n = 0; n < str.size(); ++n) cout << "-";

cout << endl;

cout << (isContainsAllChars(str, str2) ? "Все" : "Не все") << " символи рядка 2 е в рядку 1" << endl << endl;

cout << str << endl;

cout << replace(str, str2, '#') << endl;

cout << "Другий рядок в первом зустрiчаеться " << numOfHits(str, str2) << " раз." << endl << endl;

system("pause");

/*--------------------------------------------------------------------------------------------*/

int n = getInt("Введiть n: ", 50);

int **square = new int*[n];

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

square[i] = new int[n];

srand(time(NULL));

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

for (int j = 0; j < n; ++j)

 square[i][j] = rand() % 101 - 50;

cout << endl;

cout << "Виберiть метод " << endl;

cout << "1. 0 (квадрат)" << endl;

cout << "2. 2 (верхній правий трикутник)" << endl;

cout << "3. 5 (вертикальний пiсочний годинник)" << endl;

cout << "4. 7 (лівий трикутник)" << endl;

int method = getInt(" Введiть вiдповiдь: ", 4);

printDoubleArray(square, n, method);

cout << " Мiнiмальне значення в даной областi: " << minmaxOfArray(square, n, method, false) << endl;

cout << "Максимальне значення в даной областi: " << minmaxOfArray(square, n, method, true) << endl;

cout << endl << endl;

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

delete[] square[i];

delete[] square;

system("pause");

//знаходженя спільних символів в рядках

string replace(string s1, string s2, char c) {

string sharps = "";

sharps.resize(s2.size());

for (int i = 0; i < s2.size(); ++i) sharps[i] = c;

int replaceNums = 0;

size_t found = s1.find(s2);

while (s1.find(s2) != string::npos) {

found = s1.find(s2, found++);

s1.replace(found, s2.size(), sharps);

++replaceNums;

return s1;
}

int numOfHits(string s1, string s2) {

string sp = "";

sp.resize(s2.size());

for (int i = 0; i < s2.size(); ++i) sp[i] = ' ';

int replaceNums = 0;

size_t found = s1.find(s2);

while (s1.find(s2) != string::npos) {

found = s1.find(s2, found++);

s1.replace(found, s2.size(), sp);

++replaceNums;

return replaceNums;

//випадок,коли два рядка однакових

bool isContainsAllChars(string s1, string s2) {

bool *check = new bool[s2.size()];

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

check[i] = false;

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

if (s2[i] == s1[j]) {

check[i] = true;

if (DEBUG) for (int n = 0; n < s2.size(); ++n)cout << "s2[" << n << "]" << ((n < 10) ? " " : "") << " : [" << s2[n] <<
"] : " << (check[n] ? "true" : "false") << endl;

for (int n = 0; n < s2.size(); ++n) if (!check[n]) return false;

return true;

int minmaxOfArray(int** square, int n, int region, bool max) {

struct stat {

int min = 0;

int max = 0;

} method;
 //робота з двовимірними масивами (області пошуку)

switch (region) {

case 1: {

#define J_from 0

#define J_to j<n

//---------------------------------------------------------------//

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

for (int j = J_from; J_to; ++j) {

if (square[i][j] < method.min) method.min = square[i][j];

if (square[i][j] > method.max) method.max = square[i][j];

//---------------------------------------------------------------//

break;

case 2: {

#define J_from 0

#define J_to (i<n)?(j<n-i):(j<i)

//---------------------------------------------------------------//

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

for (int j = J_from; J_to; ++j) {

if (square[i][j] < method.min) method.min = square[i][j];

if (square[i][j] > method.max) method.max = square[i][j];

//---------------------------------------------------------------//

break;

case 3: {

#define J_from (i<n/2+1)?(i):(n-i-1)

#define J_to (i<n/2+1)?(j<n-i):(j<i+1)

//---------------------------------------------------------------//

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

for (int j = J_from; J_to; ++j) {

if (square[i][j] < method.min) method.min = square[i][j];

 if (square[i][j] > method.max) method.max = square[i][j];

//---------------------------------------------------------------//

break;

case 4: {

#define J_from 0

#define J_to (i/2<n)?(j<n-i):(j<i+1)

//---------------------------------------------------------------//

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

for (int j = J_from; J_to; ++j) {

if (square[i][j] < method.min) method.min = square[i][j];

if (square[i][j] > method.max) method.max = square[i][j];

//---------------------------------------------------------------//

break;

return max ? method.max : method.min;

void printDoubleArray(int** square, int n, int region) {

cout << endl;

switch (region) {

case 1: {

#define J_print j<0

#define J_from 0

#define J_to j<n

//---------------------------------------------------------------//

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

for (int j = 0; J_print; ++j) cout << " ";

for (int j = J_from; J_to; ++j) {

cout << ((square[i][j] < 0) ? "" : " ") << ((abs(square[i][j]) < 10) ? " " : "") << square[i]
[j] << " ";
 }

cout << endl;

//---------------------------------------------------------------//

break;

case 2: {

#define J_print (i<n)?(j<i):(j<n-i-1)

#define J_from 0

#define J_to (i<n)?(j<n-i):(j<i)

//---------------------------------------------------------------//

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

for (int j = 0; J_print; ++j) cout << " ";

for (int j = J_from; J_to; ++j) {

cout << ((square[i][j] < 0) ? "" : " ") << ((abs(square[i][j]) < 10) ? " " : "") << square[i]
[j] << " ";

cout << endl;

//---------------------------------------------------------------//

break;

case 3: {

#define J_print (i<n/2)?(j<i):(j<n-i-1)

#define J_from (i<n/2)?(i):(n-i-1)

#define J_to (i<n/2)?(j<n-i):(j<i+1)

//---------------------------------------------------------------//

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

for (int j = 0; J_print; ++j) cout << " ";

for (int j = J_from; J_to; ++j) {

cout << ((square[i][j] < 0) ? "" : " ") << ((abs(square[i][j]) < 10) ? " " : "") << square[i]
[j] << " ";

cout << endl;

//---------------------------------------------------------------//
 break;

case 4: {

#define J_print j<0

#define J_from 0

#define J_to (i<n/2)?(j<=i):(j<n-i)

//---------------------------------------------------------------//

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

for (int j = 0; J_print; ++j) cout << " ";

for (int j = J_from; J_to; ++j) {

cout << ((square[i][j] < 0) ? "" : " ") << ((abs(square[i][j]) < 10) ? " " : "") << square[i]
[j] << " ";

cout << endl;

//---------------------------------------------------------------//

break;

cout << endl;

//Сортування масива

string quickSort(string s, int first, int last, bool print) {

if (first >= last) return s;

int p = first;

int i = first, j = last;

do {

while (s[i] < s[p]) ++i;

while (s[j] > s[p]) --j;

if (i < j) swap(s[i], s[j]);

else break;

++i; --j;

} while (true);

swap(s[p], s[j]);
 if (print) {

string t = s;

for (int n = 0; n < first; ++n) {

t[n] = ' ';

t[j] = '|';

for (int n = t.size() - 1; n > last; --n) {

t[n] = ' ';

cout << t << endl;

s = quickSort(s, first, j - 1, print);

s = quickSort(s, j + 1, last, print);

return s;

//Перетворення рядка в число

int parseInt(string s) {

int i;

if (!s[0])return 0;

for (i = 0; s[i]; ++i) {

if (!isdigit((unsigned char)s[i]) || i > 8) {

return 0;

return stoi(s);

//отримать занчення int з введеного рядка

int getInt(string text, int max) {

string s;

do {

cout << text;

cin >> s;

} while (!parseInt(s) || parseInt(s) > max);

return parseInt(s);
}

char randomChar(int type) {

const char nums[] = "0123456789";

const char chars[] =

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZабвгдежзийклмнопрстуфхцчшщъыьэюяАБВГДЕЖЗ
ИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ";

const char charsAndNums[] =

"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZабвгдежзийклмнопрстуфхцчшщъыьэ
юяАБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ,./\\?!:;\'\"@#$%^&*()_+=-`~№";

switch (type) {

case 1: return nums[rand() % (sizeof(nums) - 1)];

case 2: return chars[rand() % (sizeof(chars) - 1)];

case 3: return charsAndNums[rand() % (sizeof(charsAndNums) - 1)];