1. Поменять местами элементы массива с четными и нечетными индексами
#include <iostream>
using namespace std;
// Функция для обмена элементов с четными и нечетными индексами
void swapEvenOdd(int* arr, int n) {
for (int i = 0; i < n / 2; i++) {
if (i % 2 == 0) {
// Меняем местами элементы с четным индексом и с нечетным
int* ptr1 = arr + 2*i; // Указатель на четный индекс
int* ptr2 = arr + 2*i + 1; // Указатель на нечетный индекс
swap(*ptr1, *ptr2); // Обмен значениями
}
}
}
// Функция для вывода массива
void printArray(int* arr, int n) {
for (int i = 0; i < n; i++) {
cout << *(arr + i) << " ";
}
cout << endl;
}
int main() {
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8};
int n = sizeof(arr) / sizeof(arr[0]);
swapEvenOdd(arr, n); // Вызов функции для обмена элементов
printArray(arr, n); // Вызов функции для вывода измененного массива
return 0;
}
Объяснение
Функция swapEvenOdd выполняет обмен элементов массива с четными и нечетными индексами.
Функция printArray выводит массив на экран.
2. Сформировать массив C[n+m], состоящий из элементов массивов A и B, упорядоченный по возрастанию
#include <iostream>
using namespace std;
// Функция для объединения двух массивов в третий
void mergeArrays(int* A, int* B, int* C, int n, int m) {
int* ptrC = C;
// Копируем элементы из A в C
for (int i = 0; i < n; i++) {
*(ptrC++) = *(A++);
}
// Копируем элементы из B в C
for (int i = 0; i < m; i++) {
*(ptrC++) = *(B++);
}
}
// Функция для сортировки массива (пузырьковая сортировка)
void bubbleSort(int* arr, int size) {
for (int i = 0; i < size - 1; i++) {
for (int j = i + 1; j < size; j++) {
if (*(arr + i) > *(arr + j)) {
swap(*(arr + i), *(arr + j));
}
}
}
}
// Функция для вывода массива
void printArray(int* arr, int size) {
for (int i = 0; i < size; i++) {
cout << *(arr + i) << " ";
}
cout << endl;
}
int main() {
int A[] = {1, 3, 5};
int B[] = {2, 4, 6};
int n = sizeof(A) / sizeof(A[0]);
int m = sizeof(B) / sizeof(B[0]);
int C[n + m];
mergeArrays(A, B, C, n, m); // Объединяем массивы A и B в C
bubbleSort(C, n + m); // Сортируем массив C
printArray(C, n + m); // Выводим отсортированный массив C
return 0;
}
Объяснение
Функция mergeArrays объединяет два массива в третий.
Функция bubbleSort сортирует массив с использованием "пузырьковой сортировки".
Функция printArray выводит массив на экран.
3. Создать третий массив с объединением и различиями элементов из массивов A и B
#include <iostream>
using namespace std;
// Функция для объединения двух массивов
void mergeArrays(int* A, int* B, int* C, int n, int m) {
for (int i = 0; i < n; i++) {
*(C++) = *(A++);
}
for (int i = 0; i < m; i++) {
*(C++) = *(B++);
}
}
// Функция для поиска общих элементов в двух массивах
void findCommon(int* A, int* B, int* D, int n, int m) {
int* ptrD = D;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (*(A + i) == *(B + j)) {
*(ptrD++) = *(A + i);
}
}
}
}
// Функция для поиска элементов A, которых нет в B
void findUniqueA(int* A, int* B, int* E, int n, int m) {
int* ptrE = E;
for (int i = 0; i < n; i++) {
bool found = false;
for (int j = 0; j < m; j++) {
if (*(A + i) == *(B + j)) {
found = true;
break;
}
}
if (!found) {
*(ptrE++) = *(A + i);
}
}
}
// Функция для поиска элементов B, которых нет в A
void findUniqueB(int* A, int* B, int* F, int n, int m) {
int* ptrF = F;
for (int i = 0; i < m; i++) {
bool found = false;
for (int j = 0; j < n; j++) {
if (*(B + i) == *(A + j)) {
found = true;
break;
}
}
if (!found) {
*(ptrF++) = *(B + i);
}
}
}
// Функция для поиска элементов, которые НЕ являются общими
void findNonCommon(int* A, int* B, int* G, int n, int m) {
int* ptrG = G;
for (int i = 0; i < n; i++) {
bool found = false;
for (int j = 0; j < m; j++) {
if (*(A + i) == *(B + j)) {
found = true;
break;
}
}
if (!found) {
*(ptrG++) = *(A + i);
}
}
for (int i = 0; i < m; i++) {
bool found = false;
for (int j = 0; j < n; j++) {
if (*(B + i) == *(A + j)) {
found = true;
break;
}
}
if (!found) {
*(ptrG++) = *(B + i);
}
}
}
// Функция для вывода массива
void printArray(int* arr, int size) {
for (int i = 0; i < size; i++) {
cout << *(arr + i) << " ";
}
cout << endl;
}
int main() {
int A[] = {1, 2, 3, 4};
int B[] = {3, 4, 5, 6};
int n = sizeof(A) / sizeof(A[0]);
int m = sizeof(B) / sizeof(B[0]);
int C[n + m], D[n + m], E[n + m], F[n + m], G[n + m];
mergeArrays(A, B, C, n, m); // Объединяем массивы
findCommon(A, B, D, n, m); // Находим общие элементы
findUniqueA(A, B, E, n, m); // Элементы A, которых нет в B
findUniqueB(A, B, F, n, m); // Элементы B, которых нет в A
findNonCommon(A, B, G, n, m); // Элементы, которые не общие
cout << "Объединенные элементы: ";
printArray(C, n + m);
cout << "Общие элементы: ";
printArray(D, n + m);
cout << "Элементы A, которых нет в B: ";
printArray(E, n + m);
cout << "Элементы B, которых нет в A: ";
printArray(F, n + m);
cout << "Элементы A и B, которые не общие: ";
printArray(G, n + m);
return 0;
}
Объяснение
Мы создали функции для каждой задачи:
mergeArrays — объединяет два массива в один (массив C).
findCommon — находит общие элементы между массивами A и B и записывает их в массив D.
findUniqueA — находит элементы массива A, которых нет в массиве B, и записывает их в массив E.
findUniqueB — находит элементы массива B, которых нет в массиве A, и записывает их в массив F.
findNonCommon — находит элементы, которые есть в одном массиве, но нет в другом, и записывает их в массив G (элементы, которые не общие для массивов A и B).
В конце программы мы выводим результаты для всех массивов: объединенных, общих, уникальных элементов и не общих элементов.