Статические массивы (C++)

[Dikins]

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

Помогите пожалуйста, буду благодарен

[Chainik!]

Наработки есть?

[Stilet]

Или хотя бы покажи код ввода массива.

[Poma][a]

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main()
{
	int n;
	cin >> n;
	
	vector<int> v(n);
	for (int i = 0; i < n; i++)
		cin >> v[i];

	cout << *max_element(v.begin(), v.end()) * *min_element(v.begin(), v.end()) << endl;
	iter_swap(find_if(v.begin(), v.end(), [](int n) {return n < 0; }), find_if(v.rbegin(), v.rend(), [](int n) {return n > 0; }));

	for (int i = 0; i < n; i++)
		cout << v[i] << " ";

	return 0;
}

[Stilet]

Рома, у автора статические массивы.

[Chainik!]

#include "stdafx.h"
#include <iostream>
#include <conio.h>
#include <time.h>
using namespace std;
//-----------------------------------------------------------------------------------
void randomnumber(double *arr, int n)
{
	for(int i = 0; i < n; i++)
		*(arr + i) = (double)(rand()%10001 - 1000)/100;
}
//-----------------------------------------------------------------------------------
void print(double *arr, int n)
{
	for(int i = 0; i < n; i++)
		cout << *(arr + i) << "\t";
}
//-----------------------------------------------------------------------------------
int indexmax(double *arr, int n)
{
	int max = *(arr + 0);
	int index = 0;
	for(int i = 1; i < n; i++)
	{
		if(*(arr + i) > max)
		{
			max = *(arr + i);
			index = i;
		}
	}
	return index;
}
//-----------------------------------------------------------------------------------
int indexmin(double *arr, int n)
{
	int min = *(arr + 0);
	int index = 0;
	for(int i = 1; i < n; i++)
	{
		if(*(arr + i) < min)
		{
			min = *(arr + i);
			index = i;
		}
	}
	return index;
}
//-----------------------------------------------------------------------------------
int indexnegativ(double *arr, int n)
{
	int negativ = 0;
	for(int i = 0; i < n; i++)
	{
		if(*(arr + i) < 0)
		{
			negativ = i;
			i = n;
		}
	}
	return negativ;
}
//-----------------------------------------------------------------------------------
int indexpositiv(double *arr, int n)
{
	int positiv = 0;
	for(int i = (n - 1); i > - 1; i--)
	{
		if(*(arr + i) > 0)
		{
			positiv = i;
			i = -1;
		}
	}
	return positiv;
}
//-----------------------------------------------------------------------------------
int main()
{
	setlocale(LC_ALL,"Rus");
	srand(time(NULL));
	int n, p = 0, q = 0, pos = 0, neg = 0;
	double *arr;
	cout << "Введите размер последовательности: ";
	cin >> n;
	arr = new double[n];
	randomnumber(arr,n);
	cout << "\nМассив имеет вид: \n\n";
	print(arr,n);
	p = indexmax(arr,n);
	q = indexmin(arr,n);
	cout << "\n\nПроизведение индексов максимального и минимального элементов: " << ((p + 1) * (q + 1));
	pos = indexpositiv(arr,n);
	neg = indexnegativ(arr,n);
	swap(*(arr + pos),*(arr + neg));
	cout << "\n\nПосле форматирования, массив преобрёл вид: \n\n";
	print(arr,n);
	delete [] arr;
	getch();
	return 0;
}

[igoreshka3333]

Ну и я захотел решить)

#include <iostream>
using namespace std;

double MinMaxMultiplication( double[], int ); // умножение индексов min и max 
int negIndex( double[], int );                // возвращает первый негативный
int positiveIndex( double[], int );           // возвращает последний позитивный

int main()
{
    int size;
    double *Array;
    
    cout << "Enter the size of the array: ";
    cin >> size;
    cout << endl;
    
    Array = new double[size];               // пользователь указывает размер массива
    
    for( int i = 0; i < size; i++ ){         // заполняет
        cout << '[' << i + 1 << "]= ";
        cin >> Array[i];
        cout << endl;
    }
    
    cout << "The result of multiplying max & min elements: "
         << MinMaxMultiplication( Array, size ) << endl ;  // функция умножения
    
    int negInd = negIndex( Array, size );                  // получаем первый негативный 
    int positiveInd = positiveIndex( Array, size );        // получаем последний позитивный 
    
    double temp = Array[negInd];                           //иеняем местами с помощью переменной
    Array[negInd] = Array[positiveInd];                    // temp
    Array[positiveInd] = temp;
    
    cout << "\nArray after moving: ";
    
    for( int i = 0; i < size; i++ ){
        cout << '[' << i + 1 << "]= ";
        cout << Array[i];
        cout << endl;
    }
    
    return 0;
}

double MinMaxMultiplication( double Array[], int size )
{
    int min = 0;
    
    for( int i = 1; i < size; i++ ){ 
        if( Array[min] > Array[i] )
            min = i;
    }
    
    int max = size;
    
    for( int i = size - 1; i > -1; i-- ){
        if( Array[max] < Array[i] )
            max = i;
    }
    
    return min * max;
    
}

int negIndex( double Array[], int size )
{
    
    int negIndex;
    
    for( int i = 0; i < size; i++ ){
        if( Array[i] < 0 ){
            negIndex = i;
            i = size;
        }
    }
    return negIndex;
}

int positiveIndex( double Array[], int size )
{
    
    int positiveIndex;
    
    for( int i = size - 1; i > -1; i-- ){
        if( Array[i] > 0 ){
            positiveIndex = i;
            i = -1;
        }
    }
    
    return positiveIndex;
}