Дан целочисленный массив размера n. вывести все содержащиеся в данном массиве четные числа в порядке убывания их индексов, а также их количество k , написать код на языке python
Основное действие оставил функцией, так как проще потом осуществлять вызов в зависимости от того, какой массив больше
ответ (вариант исполнения 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
Основное действие оставил функцией, так как проще потом осуществлять вызов в зависимости от того, какой массив больше
ответ (вариант исполнения 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;
}
#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;
}