Номер min элемента, произведение элементов массива

Уровень сложности:

Дан массив из N элементов (вещественные числа). Вычислить:

  1. номер минимального элемента массива;
  2. произведение элементов массива, расположенных между первым и вторым отрицательными элементами;
  3. преобразовать массив так, чтобы сначала располагались все элементы, модуль которых не превышает 1, а потом – элементы, все остальные.

Результат работы программы показан ниже:

// operations_array.cpp: определяет точку входа для консольного приложения.

#include "stdafx.h"
#include <iostream>
#include <ctime>
using namespace std;

int main(int argc, char* argv[])
{
    srand(time(NULL));
    setlocale(LC_ALL, "rus");
    int length_array;
    cout << "Укажите количество элементов массива: ";
    cin >> length_array;

    float *arrayPtr = new float [length_array]; // одномерный динамический массив

    // заполняем одномерный массив случайными числами
    for (int counter = 0; counter < length_array; counter++)
    {
        arrayPtr[counter] = - 5.00 + ((rand() % 101) / 10.0); // генерируем случайные числа [-5, 5]
        cout << arrayPtr[counter] << "  "; // вывод сгенерированного числа
    }
    cout << endl;

    float min = arrayPtr[0]; // инициализируем первым элементом массива
    int number_min = 0; // номер минимального элемента
    for (int counter = 0; counter < length_array; counter++)
    {
        if (min > arrayPtr[counter])
        {
            min = arrayPtr[counter]; // минимальный элемент
            number_min = counter; //  номер минимального элемента
        }
    }
    cout << "номер минимального элемента = " << (number_min + 1) << endl; //  номер минимального элемента

    double product = 1;
    for (int counter = 0; counter < length_array; counter++)
    {
        if (arrayPtr[counter] < 0) // находим первое отрицательное число
        {
            counter++; // переключаемся на следующий элемент
            while (arrayPtr[counter] > 0) // пока не нашли второе отрицательное число
            {
                product *= arrayPtr[counter]; // накапливаем произведение элементов
                counter++;
            }
            break; // выход из цикла for
        }
    }
    cout << "произведение = " << product << endl;

    float *relocation_arrayPtr = new float [length_array]; // одномерный динамический массив для перестановок
    int index = 0; // индекс массива перестановок

    // заполняем массив элементами, модуль которых не превышает 1
    for (int counter = 0; counter < length_array; counter++)
    {
        if (abs(arrayPtr[counter]) <= 1)
        {
            relocation_arrayPtr[index] = arrayPtr[counter];
            index++;
        }
    }

    // заполняем массив элементами, модуль которых больше 1
    for (int counter = 0; counter < length_array; counter++)
    {
        if (abs(arrayPtr[counter]) > 1)
        {
            relocation_arrayPtr[index] = arrayPtr[counter];
            index++;
        }
    }

    // напечатать преобразованный массив
    cout << "nПреобразованный массив:n";
    for (int counter = 0; counter < length_array; counter++)
    {
        cout << relocation_arrayPtr[counter] << "  ";
    }
    cout << endl;

    // высвобождение памяти отводимой под одномерный динамический массив:
    delete [] arrayPtr;
    delete [] relocation_arrayPtr;
    system("pause");
    return 0;
}

CppStudio.com
Укажите количество элементов массива: 15
-1  3.2  -3.8  4.2  -3.9  3.2  4  -3.4  -4.4  2.8  -2.6  4.6  2  4.6  -3.1  
номер минимального элемента = 9
произведение = 3.2

Преобразованный массив:
-1  3.2  -3.8  4.2  -3.9  3.2  4  -3.4  -4.4  2.8  -2.6  4.6  2  4.6  -3.1
Следующие статьи помогут вам в решении данной задачи:
Автор: admin
Дата: 12.09.2012
Поделиться:

Комментарии

  1. Костя Сатив

    int main()
    {
    	setlocale(0,"");
    	cout<<"Укажиет количество элементоы массива: ";
    	int size;
    	cin>>size;
    	double *arr=new double[size];
    	cout<<endl;
    	for(int i =0;i<size;i++)
    	{
    		cin>>arr[i];
    	}
    	double min=0; 
    	int 	j=0;
    	for(int i =0;i<size;i++)
    	{
    		if(min>arr[i])
    		{
    			min=arr[i];
    			j=i;
    
    		}
    	}
    	cout<<"Номер минимального элемента "<<j+1<<endl;
    	double mn=1;
    	for(int i =0;i<size;i++)
    	{
    		if(arr[i]<0)
    		{
    			j=i;
    			break;
    		}
    	}
    	j+=1;
    	for(int i =j;arr[i]>0;i++)
    	{
    		cout<<"ada";
    		mn*=arr[i];
    	}
    	cout<<"произведение = "<<mn<<endl;
    
    	for(int i =0;i<size;i++)
    	{
    		for(int j =i+1;j<size;j++)
    		{
    			if(abs(arr[j])==1 || abs(arr[j])==0)
    			{
    				swap(arr[i],arr[j]);
    			}
    		}
    	}
    	cout<<"Массив ";
    	for(int i =0;i<size;i++)
    	{
    		cout<<arr[i]<<" ";
    	}
    }
  2. Кайл Брофловски

    Кайл Брофловски

    #include <iostream>
    #include<list>
    #include<algorithm>
    
    using namespace std;
    
    double* sort_arr(double* arr, int dim, int& min, double& mult);
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	double my_arr[]{3.5, 0.6, 2.6, -1.7, 2.0, 3.5, 1.0, 0.5, 2.0, -5.2, 7.8, 0.1, -0.6, 4.1, 0.8, 2.5};
    	int mmin{};
    	double mmult{};
    	double* aarr = sort_arr(my_arr, 16, mmin, mmult);
    	for (int i = 0; i < 16; i++)
    	{
    		cout << aarr[i] << "   ";
    	}
    	cout << endl;
    	cout << "min index = " << mmin << endl;
    	cout << "mult = " << mmult << endl;
    	return 0;
    }
    
    double* sort_arr(double* arr, int dim, int& min, double& mult)
    {
    	using flag = bool;
    	flag first_neg{ false };
    	flag second_neg{ false };
    	double min_val{ *arr };
    	mult = 1;
    	auto Abs = [](double a){return (a < 0) ? -a : a; };
    	list<int>less_one;
    	list<int>greater_one;
    	for (int i = 0; i < dim; i++)
    	{
    		if (arr[i] < min_val)
    		{
    			min = i;
    			min_val = arr[i];
    		}
    		if (arr[i] < 0 && first_neg && !second_neg)
    			second_neg = true;
    		if (first_neg && (!second_neg))
    			mult *= arr[i];
    		if (arr[i] < 0 && !first_neg)
    			first_neg= true ;		
    		if (Abs(arr[i]) < 1)
    			less_one.push_back(i);
    		else
    			greater_one.push_back(i);
    	}
    
    	double* resarr = new double[dim];
    	
    	for (int i = 0; i < dim; i++)
    	{
    		if (!less_one.empty())
    		{
    			resarr[i] = arr[less_one.front()];
    			less_one.pop_front();
    		}
    		else if (!greater_one.empty())
    		{
    			resarr[i] = arr[greater_one.front()];
    			greater_one.pop_front();
    		}
    	}
    	return resarr;
    }
  3. gornyyvladimir

    gornyyvladimir

    #include <vcl.h>
    #include <ctime>
    #include <iostream.h>
    #include <vector>
    #include <iterator>
    #include <cmath>
    #pragma hdrstop
    
    #pragma argsused
    int main(int argc, char* argv[])
    {
        size_t N;
        cout<<"Enter mas size: ";
        cin>>N;
        srand( time( 0 ) );
        vector<double> mas;
        double min = 10.0;
        size_t minindex,first,second;
        for(size_t i=0; i<N; i++)
        {
            double randomValue = - 5.00 + ((rand() % 101) / 10.0);
            mas.push_back(randomValue);
            if(min>randomValue)
            {
                min = randomValue;
                minindex = i;
            }
        }
        copy( mas.begin(),
              mas.end(),
              ostream_iterator<double>(cout," ")
            );
        cout<<"\nIndex of min "<<minindex<<" = "<<min<<"\n\n";
        double mult = 1.0;
        for(size_t i=0; i<N; i++)
        {
            if(mas.at(i)<0)
            {
                for(size_t j=i+1; mas.at(j) > 0 && j<N; j++)
                {
                    mult*=mas.at(j);
                }
                break;
            }
        }
        for(size_t i=0; i<N; i++)
        {
            if(abs(mas.at(i)) < 1.0)
            {
                double tmp = mas.at(i);
                mas.erase(mas.begin() + i);
                mas.insert(mas.begin(),tmp);
            }
        }
        cout<<"Multiplication = "<<mult<<"\n\n";
        cout<<"New massive: \n";
        copy( mas.begin(),
              mas.end(),
              ostream_iterator<double>(cout," ")
            );
        system("pause");
        return 0;
    }
  4. Adam1983

    #include <conio.h>
    #include <iomanip>
    #include <iostream>
    #include <ctime>
    
    using namespace std;
    
    
    int main(int argc, char** argv)
    {
    
    setlocale (LC_ALL, "russian");
    //определяем величину массива
    int N;
    cout << "Введите размер массива" << endl;
    cin >>N;
    
    //выделяем динамическую память под массив
    double* arr = new double [N];
    
    srand(time(0));
    //заполняем массив случайными вещественными значениями от -10 до 10
    for (int i(0); i<N; i++)
    	{
    		arr[i] = (double)(rand()%100-50)/10;
    		cout << arr[i] << "  ";
    	}
    //находим минимальное значение массива
    double temp=arr[0];//присваеваем значение первого элемента временной переменной
    int index;
    //сохраняем значение минимального элемента и его индекс в пеерменных
    for (int i(1); i<N; i++)
    	if(arr[i]<temp)
    		{
    			temp=arr[i];
    			index = i;
    		}
    	
    //выводим результат на монитор
    cout << "\n\nминимальное значение массива = " << temp << endl;
    cout << "номер минимального элемента = " << index+1 << endl;
    
    //находим первое и второе отрицательное значение массива
    int first, second;
    
    for (int i(0); i<N; i++)
      if(arr[i]<0)
      {
    	  first = i;
    	    break;
      }
    
    for (int i(first+1); i<N; i++)
      if(arr[i]<0)
      {
    	  second = i;
    	  break;
      }
    
    //находим произведение между двумя отрицательными элементами массива и выводим на монитор
    temp=1;
    if ((second-first)<2)
    cout <<"между первыми двумя отрицательными значениями других значений нету\n\n";
    else
    {
    	for (int i(first+1); i<second; i++)
    	{
    	 temp*=arr[i];
    	}
    	cout <<endl << "произведение элементов массива = "<< temp << endl;
    }
    
    //сортировка массива, все значения по модулю меньше 1 перемещаем в начало массива.
    for (int i(0); i<N; i++)
      for(int j(N-1); j>i ;j--)
    	  if (fabs (arr[i])>1 && fabs (arr[j])<1)
    	   swap (arr[i],arr[j]);
    
    
    //вывод на монитор отсортированного массива
    for (int i(0); i<N; i++)
    		cout << arr[i] << "  ";
    
    
    //освобождаем память
    delete [] arr;
    
    _getch();
      return 0;
    }
  5. petruska

    petruska

    Мой вариант

    // MYPROJECT.cpp: определяет точку входа для консольного приложения.
    //
    
    #include "stdafx.h"
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    
    	srand(time(NULL)); // for real rand values
    	int size=0;
    	cout << "Enter size of array: ";
    	cin >>size;
    
    	double * pA=new double [size]; // create dyn array
    	// init and show array
    	cout << "Your array:" <<endl;
    	for (int i=0; i < size; i++)
    	{
    		pA[i] =rand() % 100 *0.1;
    		int rv= rand() % 2; // need fo
    		if ( rv == 1)      // negative values
    			pA[i]*=-1;    // in array
    
    		cout << pA[i] <<"  ";
    	}
    	cout <<endl<<endl;
    
    
    	// find min element (index)
    	double Min=pA[0];
    	int MinIndex=0;
    	for (int i=1; i < size; i++)
    	{
    		if ( Min > pA[i] )
    		{
    			Min=pA[i];
    			MinIndex=i;
    		}
    	}
        cout << "Number of min element: " <<MinIndex+1 <<endl<<endl;
    
    
    	// find product
    	int first=0,thecond=0;
    	double product=0;
    	// find and save index of first negative number
    	for (int i=0; i < size; i++)
    	{
    		if (pA[i] < 0)
    		{
    			first=i;
    			break;
    		}
    	}
    
        // find and save index of thecond negative number
    	for (int i=first+1; i < size; i++)
    	{
    		if (pA[i] < 0)
    		{
    			thecond=i;
    			break;
    		}
    	}
    
    	// sum values between indexes
    	for (int i=first+1; i < thecond; i++)
    		product+=pA[i];
    	cout << "Product between two negative numbers: " <<product <<endl<<endl; 
    
    
    
    	// filt array
    	double * pA2=new double [size]; // creat new array,were we will be paste values what need
    	int ind1=0,ind2=0;
    
    	for (int i=0; i < size; i++)
    	{
    		if ( fabs(pA[i]) < 1 ) // fabs-formula what return module
    		{
    			pA2[ind1]=pA[i];
    			ind1++;
    		}
    	}
    
    	for (int i=0; i < size; i++)
    	{
    		if ( fabs(pA[i]) >= 1 )
    		{
    			pA2[ind1+ind2]=pA[i];
    			ind2++;
    		}
    	}
    
    	cout << "Sort array:" <<endl;
    	for (int i=0; i < size; i++)
    	{
    		pA[i]=pA2[i];             // this string need if program must show exactly first array
    		cout << pA[i] <<"  ";
    	}
    	cout <<endl;
    
    	// delete arrays
    	delete []pA; 
    	delete []pA2;
    
    	return 0;
    }
  6. ValMan

    Почему бы не заменить 3-ю часть (54-87 строки) на 2 прогона исходного массива?

        cout << "\nПреобразованный массив:\n";
    
        for (int counter = 0; counter < length_array; counter++)     
        {                   
           if ( abs( arr[i]) <= 1) {
              cout << setw(5) << arr[counter];
           };
        };
        for (int counter = 0; counter < length_array; counter++)         
        {
           if (abs( arr[counter] > 1 ) { 
              cout << setw(5) << arr[counter];
           };
         };

Оставить комментарий

Вы должны войти, чтобы оставить комментарий.