Generating signed numbers

[poloblue64]

Good Afternoon,

Can anyone help me to figure out why the program crashes when the show the list of the generated 1000 numbers and it doesn't output the results of the functions. Here is the code that I have.
Main cpp:

#include <iostream>
#include <fstream>
#include <time.h>
#include <iomanip>
#include "hw5_head.h"

using namespace std;

int main()

{
		ofstream outFile;
			
        const int n = 1000; //indicates array size
		int list[n]; //integer array for a list
        int avg,avgP,avgN,maximum;
		int value, counts;
		
		randomList(list, n);
        
		showList(list, n);    
		
	
		avgs(list,n,avg,avgP,avgN);

        maximum=max(list,n);

        printList(outFile,list,n,avg,avgP,avgN,maximum);

		cout<<"\nsearch using linear search"<<endl;

		cout<<"List contains: "<<linearSearch(list,n,value)<<endl;
		
		bubbleSort(list,n,counts);

        cout<<"\nAfter bubble sort list elements are: "<<endl;

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

            cout<<list[i]<<" ";

 

            cout<<"\n\nsearch using binary search"<<endl;

            cout<<"List contains: "<<(bool)binarySearch(list,n,value)<<endl;

           
            //closing the opened files

         
            outFile.close();

            return 0;

} 
Heade File:
[code]
#include <iostream>
#include <fstream>
#include <time.h>
#include <iomanip>

using namespace std;

#ifndef		HW5_HEAD_H
#define		HW5_HEAD_H

//generates random numbers and fills the array with those random numbers

void randomList(int list[], const int n)

{
	signed seed;
	cout << "Enter a random seed ";
	cin>>seed;
	srand(seed);

	for (int i = 0; i < n; i++)
	{
		list[i] = rand()%1000;
	}
	return;
}

//finds average of positive, negative and all numbers seperately.

void avgs (const int list[ ], const int n, int &avg, int &avgP, int &avgN)
{
	int posNums=0,negNums=0;
	int posSum=0,negSum=0;

            for(int i=0;i<n;i++)
			{
				if(list[i]>0)
					{
						posSum += list[i];
						posNums++;
					}
						else if(list[i]<0)
						{
							negSum += list[i];
							negNums++;
						}                     
			}
			avgP = posSum/posNums;
			avgN = negSum/negNums;
			avg=(avgP+avgN)/2;
}

//finds the maximum value in the list

int max (const int list[], const int n)
{
	int maximum =list[0];
		for(int i=1;i<n;i++)
		{
			if(list[i] >maximum)
				maximum=list[i];
		}
		 return maximum;
}

//prints the list values,averages and maximum into the file

void printList(ofstream & outFile, const int list[], const int n, const int avg, const int avgP, const int avgN, const int max)
{
	outFile<<"List elements are: "<<endl;
	cout<<"List elements are: "<<endl;
	for(int i=0;i<n;i++)
	{
		outFile<<list[i]<<" ";
		cout<<list[i]<<" ";
	}
	outFile<<"\n\nAverage of positive numbers: "<<avgP<<endl;
	cout<<"\n\nAverage of positive numbers: "<<avgP<<endl;
	outFile<<"Average of negitive numbers: "<<avgN<<endl;
	cout<<"Average of negitive numbers: "<<avgN<<endl;
	outFile<<"Average of all numbers: "<<avg<<endl;
	cout<<"Average of all numbers: "<<avg<<endl;
    outFile<<"Maximum is: "<<max<<endl;
    cout<<"Maximum is: "<<max<<endl<<endl;
}

//search for an element using linear search

bool linearSearch(const int list[ ], const int n, const int value)
{
	for(int i=0;i<n;i++)
	{
		if(list[i] == value)
			{
				return true;
			}
	}
		return false;
}

//sorting the list using bubble sort

void bubbleSort(int list[ ], const int n, int & counts)
{

   bool swap;
   int temp;
   int i,j;

   counts=0;

   for (i = 0; i<n; i++)
   {
	   swap = false;
	   for (j = 0; j < n - i - 1; j++)
	   {
		   if (list[j] > list [j+1])
		   {
			   swap = true;

			   temp = list[j];
			   list[j] = list[j+1];
			   list[j+1] = temp;

			   counts++;
		   }
	   }
		   if(!swap)
			   break;
	}
	   return;
}

   

//searching the array using binary serach

bool binarySearch(const int list[ ], const int n, const int value)
{
	int first = 0, last = n - 1, middle, position = -1;         
	bool found = false;       

    while (!found && first <= last)
	{
		middle = (first + last) / 2;     
		if (list[middle] == value)      
		{
			found = true;
			position = middle;
		}
		else if (list[middle] > value)  
			last = middle - 1;
		else
			first = middle + 1;          
	}
	return found;
}
void showList(const int list[], const int n)
{
	cout<<"The list is ..... " <<endl;
	for (int i=0; i<n; i++)
	{
		cout<<setw(8)<<right<<list[i];
		if ((i+1)%1000==0)
			cout<<endl;
	}
	cout<<endl;
}
#endif

[/code]

[S G H]

Every variable is NOT getting initialized. That is bad practice to my eyes. Initialize them all to 0, then check the results.

[vlad from moscow]

Functions randomList and showList are correct. However all array elements are positive. So the statement

avgN = negSum/negNums;

results in crash because negNums will be equal to 0.

[poloblue64]

EssGeEich,

I already initialized all the variables to 0 and still the program crashes

[poloblue64]

vlad from moscow,

How would implement to have the array elements as negative, so avgN = negSum/negNums won't crash

[vlad from moscow]

For example you could use the following expression

list[i] = rand() % n - n / 2;

[poloblue64]

vlad from moscow,

The program is now generating postive and negative numbers, but I having trouble with the function avg because it isn't outputting the correct results. Here is the print screen that I'm getting.

Average of positive numbers: 250
Average of negitive numbers: -252
Average of all numbers: -1
Maximum is: 499

[vlad from moscow]

I think it is becauss that you use incorrect formula. Try the following

avgP = posSum/posNums;
avgN = negSum/negNums;
avg = (avgP+avgN) / n;

Also it would be better if you define avg, avgP, avgN as float and the statenents above would be rewritten the following way


avgP = ( float )posSum/posNums;
avgN = ( float )negSum/negNums;
avg = ( float )(avgP+avgN) / n;

[S G H]

vlad from moscow wrote:

avgP = ( float )posSum/posNums;
avgN = ( float )negSum/negNums;
avg = ( float )(avgP+avgN) / n;

Or, even better:

avgP = ( float )posSum/(float)posNums;
avgN = ( float )negSum/(float)negNums;
avg = ( float )(avgP+avgN) / (float)n;

Otherwise it would be like a "float / int" which causes not-so-precise behaviour and a warning in most cases.

[vlad from moscow]

@EssGeEich
Do not make up stories .There are precise behaviour and none warnings. So the second casting is excessive. It is much better to write as I showed above.

[S G H]

Right you are. [offTopic]Just sayin', you look nervous these days, vlad... Not the first nor second time I see you getting nervous.[/offTopic]

[poloblue64]

thank you for your help