Question

C++ написать проверку на то, входит ли первый массив во второй и наоборот. массивы вводит пользователь.

Answer 1

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

Ответ (вариант исполнения 1):

#include <iostream>

using namespace std;

bool IsInclude(int* Find, int* Suorce, int sizeFind, int sizeSuorce);

int main()

{

int *A, *B, NA, NB;

setlocale(LC_ALL, "rus");

bool result;

cout << "Введите количество элементов первого массива: ";

cin >> NA;

A = new int[NA];

cout << "Введите элементы массива: " << endl;;

for (int i = 0; i < NA; i++) { cout << "A["<< i << "] = "; cin >> A[i]; }

cout << "Введите количество элементов второго массива: ";

cin >> NB;  

B = new int[NB];

cout << "Введите элементы массива: " << endl;;

for (int i = 0; i < NB; i++) { cout << "B[" << i << "] = "; cin >> B[i]; }

//Тепеь смотрим какой массив длиннее и в зависимости от этого запускаем функцию по разному

if (NA > NB)

{

 result = IsInclude(B, A, NB, NA);

 if (result) cout << "Массив B входит в массив A";

 else cout << "Массив B не входит в массив A";

}

else {

 result = IsInclude(A, B, NA, NB);

 if (result) cout << "Массив A входит в массив B";

 else cout << "Массив A не входит в массив B";

}

delete[] A;

delete[] B;

return 0;

}

bool IsInclude(int* Find, int* Suorce, int sizeFind , int sizeSuorce)

{

int CountInSuorce, CountInFind;

for (int i = 0; i < sizeFind; i++) { // Перебираем по одному все элементы меньшего массива  

 CountInSuorce = 0;

 CountInFind = 0;

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

 {

  if (Find[i] == Find[j] && j < sizeFind) CountInFind++; // Считаем сколько раз элемент искомого массива находится в нём самом

  if (Find[i] == Suorce[j]) CountInSuorce++; // Считаем сколько раз элемент искомого массива встретился в большем массиве

 }

 if (CountInFind > CountInSuorce) return false;// Если счётчик элементов в искомом массиве оказался больше чем в большем массиве, значит выходим и дальше не имеет смысла искать

}

return true;// Если счётчики большего массива были всегда не меньше счетчика искомого массива, то мы попадём сюда и меньший массив можно составить из элементов большего

}

Ответ (вариант исполнения 2):

#include <iostream>

using namespace std;

int IsInclude(int* First, int FirstCount, int* Second, int SecondCount);

int main()

{

int* A, * B, NA, NB;

setlocale(LC_ALL, "rus");

int result;

cout << "Введите количество элементов первого массива: ";

cin >> NA;

A = new int[NA];

cout << "Введите элементы массива: " << endl;;

for (int i = 0; i < NA; i++) { cout << "A[" << i << "] = "; cin >> A[i]; }

cout << "Введите количество элементов второго массива: ";

cin >> NB;

B = new int[NB];

cout << "Введите элементы массива: " << endl;

for (int i = 0; i < NB; i++) { cout << "B[" << i << "] = "; cin >> B[i]; }

result = IsInclude(A, NA, B, NB);

switch (result) {

 case 0: {cout << "Массивы A и B не входят друг в друга"; break; }

 case 1: {cout << "Массивы A и B имеют одинаковые элементы"; break; }

 case 2: {cout << "Массив A входит в массив B"; break; }

 case 3: {cout << "Массив B входит в массив A"; break; }

}

delete[] A;

delete[] B;

return 0;

}

int IsInclude(int* First, int FirstCount, int* Second, int SecondCount) // возвращаем 0 если массив не входид в другой, 1 если они одинаковые, 2 если первый входит во второй, 3 если второй входит в первый

{

int *Source, * Find, sizeSource, sizeFind, CountInSource, CountInFind;

bool Equal; // Флаг того что элементы одинаковые

bool AandB = FirstCount > SecondCount;

if(AandB)

{

 Source = First;

 sizeSource = FirstCount;

 Find = Second;

 sizeFind = SecondCount;

}

else  

{

 Find = First;

 sizeFind = FirstCount;

 Source = Second;

 sizeSource = SecondCount;

}

if (sizeFind == sizeSource) Equal = true;

else Equal = false;

for (int i = 0; i < sizeFind; i++) { // Перебираем по одному все элементы меньшего массива  

 CountInSource = 0;

 CountInFind = 0;

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

 {

  if (Find[i] == Find[j] && j < sizeFind) CountInFind++; // Считаем сколько раз элемент искомого массива находится в нём самом

  if (Find[i] == Source[j]) CountInSource++; // Считаем сколько раз элемент искомого массива встретился в большем массиве

 }

 if (CountInFind > CountInSource) return 0;// Если счётчик элементов в искомом массиве оказался больше чем в большем массиве, значит выходим и дальше не имеет смысла искать

 if (CountInFind != CountInSource) Equal = false; // Если количество в искомом и большом получилось различное, то сбрасываем флаг

}

// Если счётчики большего массива были всегда не меньше счетчика искомого массива, то мы попадём сюда и меньший массив можно составить из элементов большего

if (Equal) return 1; // если флаг не сброшен, то возврвщаем 1

if (!Equal && AandB) return 3; // если флаг не сброшен, то возврвщаем 1

else return 2;

}

Answer 2

Ответ:

#include <iostream>

#include <Windows.h> //локализация

using namespace std;

int main()

{

SetConsoleCP(1251); //локализация

SetConsoleOutputCP(1251);

short size{};

cout << "Введите размер массивов: ";

cin >> size;

int* arrA = new int[size];

int* arrB = new int[size];

cout << "\nВведите элементы первого массива:\n";

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

 cin >> arrA[i];

cout << "\nВведите элементы второго массива:\n";

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

 cin >> arrB[i];

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

{

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

 {

  if (arrB[i] == arrA[j]) //если значение элемента в массиве B найдётся в массиве A

  {

   int numOfRepeatsA{}, numOfRepeatsB{};

   for (int l = 0; l < size; l++) //подсчитываем количество повторений этих элементов

   {

    if (arrB[i] == arrB[l])

     numOfRepeatsB++;

    if (arrB[i] == arrA[l])

     numOfRepeatsA++;

   }

   if (numOfRepeatsA == numOfRepeatsB) //если элемент повторяется в массиве A столько же раз, сколько и в массиве B

    break; //переходим к проверке следующего элемента

   else //иначе очищаем память и завершаем программу, т.к. если хотя бы 1 элемент не прошёл проверку == дальше проверять нет смысла

   {

    cout << "\nМассивы не входят друг в друга";

    delete[] arrA;

    delete[] arrB;

    return 0;

   }

  }

 }

}

cout << "\nМассивы входят друг в друга"; //если в цикле программа не завершилась, значит ответ положительный

delete[] arrA;

delete[] arrB;

return 0;

}

Answer 3

Конечно, я могу помочь вам написать программу на языке C++ для проверки того, входит ли первый массив во второй и наоборот. Для этого можно воспользоваться стандартной библиотекой C++ и использовать циклы для сравнения элементов массивов.

Пример кода:

#include

using namespace std;

// Функция для проверки, входит ли массив a в массив b
bool isArrayInArray(int a[], int size_a, int b[], int size_b) {
    // Проверка на пустые массивы
    if (size_a == 0 || size_b == 0) {
        cout << "Один из массивов пуст!" << endl;
        return false;
    }

// Проверка на размеры массивов
    if (size_a > size_b) {
        cout << "Первый массив больше второго, вход невозможен." << endl;
        return false;
    }

// Поиск первого элемента первого массива во втором массиве
    for (int i = 0; i <= size_b - size_a; ++i) {
        bool found = true;
        for (int j = 0; j < size_a; ++j) {
            if (a[j] != b[i + j]) {
                found = false;
                break;
            }
        }
        if (found) {
            cout << "Первый массив входит во второй массив." << endl;
            return true;
        }
    }

cout << "Первый массив не входит во второй массив." << endl;
    return false;
}

int main() {
    const int MAX_SIZE = 100;

int size_a, size_b;

// Ввод размеров массивов
    cout << "Введите размер первого массива: ";
    cin >> size_a;

cout << "Введите элементы первого массива через пробел: ";
    int a[MAX_SIZE];
    for (int i = 0; i < size_a; ++i) {
        cin >> a[i];
    }

cout << "Введите размер второго массива: ";
    cin >> size_b;

cout << "Введите элементы второго массива через пробел: ";
    int b[MAX_SIZE];
    for (int i = 0; i < size_b; ++i) {
        cin >> b[i];
    }

// Проверка вхождения массивов
    isArrayInArray(a, size_a, b, size_b);

return 0;
}

Этот код запрашивает у пользователя размер и элементы двух массивов, затем вызывает функцию `isArrayInArray`, которая проверяет вхождение первого массива во второй и выводит соответствующее сообщение.