Алгоритмы и программы по обработке одномерных и двумерных массивов

[Вероника Юшкевич]

Здравствуйте. Пишу Вам уже в который раз и прошу о помощи. НЕобходимо написать задачи. Вот текст: В одномерном массиве, состоящем из n ещественных элементов, вычислить:
1) колличество элементов массива, лежащих в диапазоне от А до В
2)сумму элементов массива, расположенных после максимального элемента
Упорядочить элементы массива по убыванию модулей элементов.
И ещё одну: осуществить циклический сдвиг элементов прямоуггольной матрицы на n элементов вправо или вниз . n может быть больше количества элементов в строке или в столбце.
Все эти задачи нужно сделать, используя статические массивы
заранее спасибо

[p51x]

Вам во фриланс

[dim565]

Сообщение от Вероника Юшкевич

Здравствуйте. Пишу Вам уже в который раз и прошу о помощи. НЕобходимо написать задачи. Вот текст: В одномерном массиве, состоящем из n ещественных элементов, вычислить:
1) колличество элементов массива, лежащих в диапазоне от А до В
2)сумму элементов массива, расположенных после максимального элемента
Упорядочить элементы массива по убыванию модулей элементов.
И ещё одну: осуществить циклический сдвиг элементов прямоуггольной матрицы на n элементов вправо или вниз . n может быть больше количества элементов в строке или в столбце.
Все эти задачи нужно сделать, используя статические массивы
заранее спасибо

Вот решение (есть только с использованием форм)

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

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int n,a,b,i,j,numab,elmax,sum_after_max,index_max,temp;    //описание переменных
int *x=new int [n];                                       //описание массива x
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)       //ОБРАБОТЧИК КНОПКИ "ВВОД"
{
a=StrToInt(Edit3->Text);          //А
b=StrToInt(Edit4->Text);           //B
n=StrToInt(Edit2->Text);          //макс.кол-во элементов

x[i]=StrToInt(Edit1->Text);       //Ввод нового элемента
i++;                            //увеличение счетчика
Edit1->SetFocus();                //установить фокус в Edit1
Edit1->Text="";                   //Очистка Edit1

if (i==n)                       //если счетчик дошел до установленного предела
{
Button1->Enabled=False;         //отключить кнопку "Ввод"
Button2->Enabled=True;          //включить кнопку "Вывод"
}
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)      //ОБРАБОТЧИК КНОПКИ "ВЫВОД"
{
for (i=0;i<n;i++)
{
Memo1->Lines->Add(x[i]);            //Вывод в memo1 введенного массива
if ((x[i]>a)&&(x[i]<b)) numab++;    //рассчет кол-ва элементов в пределах от А до Б
if (x[i]>elmax)                     //найти максимальный элемент
{
index_max=i;
elmax=x[i];
}
}
for (i=index_max+1;i<n;i++) sum_after_max+=x[i];   //найти сумму после макс.
Label3->Caption=IntToStr(numab);                   //Вывод найденного значения (кол-во элементов между А и Б)
Label4->Caption=IntToStr(sum_after_max);           //Вывод найденного значения: сумму после макс
Button3->Enabled=True;                             //Врубить кнопку "Упорядочить"
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button3Click(TObject *Sender)     //ОБРАБОТЧИК КНОПКИ "УПОРЯДОЧИТЬ"
{
Memo1->Clear();                          //Очистить memo
temp=0;                                  //Сортировка по убыванию методом позырьков
for(i = 0; i < n; i++)
{
for(j=i+1;j<n;j++)
{
 if (abs(x[i])<abs(x[j]))              //Чтоб по возрастанию - поставить знак >  abs - по модулю (по заданию)
 {
  temp=x[i];
  x[i]=x[j];
  x[j]=temp;
 }

}
Memo1->Lines->Add(x[i]);                   //Вывод нового упорядоченного элемента в memo1
}
Button2->Enabled=False;                    //Вырубить все кнопки
Button3->Enabled=False;
}
//---------------------------------------------------------------------------

[Rififi]

Вероника Юшкевич

В одномерном массиве, состоящем из n ещественных элементов, вычислить:
1) колличество элементов массива, лежащих в диапазоне от А до В
2)сумму элементов массива, расположенных после максимального элемента
Упорядочить элементы массива по убыванию модулей элементов.

#include <stdlib.h>
#include <time.h>

#include <numeric>
#include <algorithm>
#include <functional>
#include <iterator>

#include <locale>
#include <iostream>

template <typename T>
struct in_range : public std::unary_function<T, bool>
{
	in_range(T l, T h) : l_(l), h_(h) {}
	
	bool operator()(T v) const
	{
		return v >= l_ && v <= h_;
	}

	T l_, h_;
};

template <typename T, size_t N>
size_t count(const T (&arr)[N], T A, T B)
{
	return std::count_if(arr, arr + N, in_range<T>(A, B));
}

template <typename T, size_t N>
std::ostream& operator<<(std::ostream& os, const T (&arr)[N])
{
	typedef std::ostream_iterator<T> O;
	std::copy(arr, arr + N, O(std::cout, " "));
	return os;
}

template <size_t N>
std::ostream& operator<<(std::ostream& os, const char (&arr)[N])
{
	return os << &arr[0];
}

struct R
{
	int operator()() const
	{
		return rand() % 100 - 50;
	}
};

template <typename T>
struct less : public std::binary_function<T, T, bool>
{
	bool operator()(T v1, T v2) const
	{
		return abs(v1) < abs(v2);
	}
};

template <typename T, size_t N>
T (&sort(T (&arr)[N]))[N]
{
	std::sort(arr, arr + N, less<T>());
	return arr;
}

int main()
{
	const size_t N = 10;

	setlocale(LC_ALL, "");
	srand((unsigned) time(NULL));
	
	int arr[N] = {0};
	std::generate_n(arr, N, R());

	std::cout << "Array: " << arr << std::endl;

	std::cout << "Enter A, B: ";

	int A, B;
	std::cin >> A >> B;

	std::cout << "Number of elements in [A..B] range: " << count(arr, A, B) << std::endl;

	std::cout << "Sum after max: " << std::accumulate(
		std::max_element(arr, arr + N) + 1, arr+N, 0
		) << std::endl;

	std::cout << "Sorted array: " << sort(arr) << std::endl;
	
	return 0;
}

пример работы программы:

Array: 49 -24 42 -23 27 -29 -39 40 32 22
Enter A, B: -30 30
Number of elements in [A..B] range: 5
Sum after max: 48
Sorted array: 22 -23 -24 27 -29 32 -39 40 42 49