Stock Options Analyzer

0 likes • Nov 18, 2022
C++

More C++ Posts

```/*Algorithm:Step 1: Get radius of the cylinder from the user and store in variable rStep 2: Get height of the cylinder from the user and store in variable hStep 3: Multiply radius * radius * height * pi and store in vStep 4: Display the volume*/
#include <iostream>using namespace std;

int main(){        float r; //define variable for radius        float h; //define variable for height        float v;        float pi;        pi=3.1416;
cout<<"Enter height:";        cin>>h;
v=r*r*h*pi;  //compute volume
cout<<"\n************************\n";
cout<<"Volume:"<<v<<endl;//display volume
return 0;}```
```/*this program will simulate the spreading of a disease through a grid of people, starting from a user-defined person. It will countthe number of turns taken before everyone on the grid is immunizedto the disease after having caught it once.This program will user the SIR model (Susceptible, Infectious, Recovered) and cellular automata to simulate the people in the grid.*/#include <iostream>using namespace std;
/* Any and all global variables */const int SIZE = 8; //Size of the square person array
/* Any and all functions */void gridDefaultify(char[][SIZE], int);	//Purpose: Sets each item in the person array to 's'	//Parameters: A square, two-dimensional array	//            The size of that array's boundsvoid gridDisplay(char[][SIZE], int);	//Purpose: Formats and prints the information in the person grid	//Parameters: A square, two-dimensional array	//            The value of the current dayvoid nextTurn(char[][SIZE], char[][SIZE], int&);	//Purpose: Updates the grid of people, and the current day	//Parameters: Two square, two-dimensional arrays	//            A reference to the current day (so that it can be updated)int countInfected(char[][SIZE], int);	//Purpose: Counts the number of infectious people on the grid	//Parameters: A square, two-dimensional array	//            The size of that array's bounds

int main(){	int currentDay = 0; //Infection begins on day 0, and ends one day after the last person is Recovered	char gridCurrent[SIZE][SIZE]; //Grid of all people	char gridUpdate[SIZE][SIZE]; //Where the user chooses to start the infection	int xToInfect;	int yToInfect; //Set of coordinates for the initial infection position, given by user		//Initializes the grids to all 's'	gridDefaultify(gridCurrent, SIZE);	gridDefaultify(gridUpdate, SIZE);		//The below block gets the initial infection coordinates from the user	cout << "Please enter a location to infect: ";	while(true){		cin >> xToInfect >> yToInfect;
xToInfect--;		yToInfect--;				if(xToInfect < 0 || yToInfect < 0 || xToInfect >= SIZE || yToInfect >= SIZE){			cout << "Those coordinates are outside the bounds of this region." << endl;			cout << "Please enter another location to infect: ";			continue;		} else {			gridCurrent[xToInfect][yToInfect] = 'i';			break;		}	}		//Displays the initial state of the grid	gridDisplay(gridCurrent, currentDay);		//The below block will display and update the grid until the infection is done.	while(true){		nextTurn(gridCurrent, gridUpdate, currentDay);		gridDisplay(gridCurrent, currentDay);		if(countInfected(gridCurrent, SIZE) == 0) break; //Once there are no more infected, the game is done	}		//Displays the number of days taken for the infection to end	cout << "It took " << currentDay + 1 << " days for the outbreak to end";		cout << endl;	return 0;}
void gridDefaultify(char arr[][SIZE], int arrSize){	for(int x = 0; x < arrSize; x++){		for(int y = 0; y < arrSize; y++){			arr[x][y] = 's'; //Sets all items in the passed-in array to 's'		}	}	return;}
void gridDisplay(char arr[][SIZE], int day){	cout << "Day " << day << endl; //Prints the current day	for(int x = 0; x < SIZE; x++){		for(int y = 0; y < SIZE; y++){			cout << arr[x][y] <<" "; //Prints the array's contents		}		cout << endl; //Formats with newlines	}	cout << endl; //Some spacing	return;}
void nextTurn(char today[][SIZE], char update[][SIZE], int& day){	day++; //Updates the day	int xCheck; //X coordinate to be checked	int yCheck; //Y coordinate to be checked		for(int x = 0; x < SIZE; x++){		for(int y = 0; y < SIZE; y++){			//Sets all 'i' to 'r' in the new grid			if(today[x][y] == 'i' || today[x][y] == 'r'){				update[x][y] = 'r'; //Updates all infectious to recovered, and keeps current recovered			}			if(today[x][y] == 's'){									// If the person is susceptible...				for(int xCheck = x-1; xCheck <= x+1; xCheck++){		// Check all x coordinates around the person					for(int yCheck = y-1; yCheck <= y+1; yCheck++){	// Check all y coordinates around the person						if(xCheck == x && yCheck == y){																	// Don't check at the person because there is no need to check there						} else {							if(xCheck >= 0 && yCheck >= 0 && xCheck < SIZE && yCheck < SIZE){ // Make sure the checked coordinates are in bounds								if(today[xCheck][yCheck] == 'i'){	//Is the person at the checked coordinates infected?									update[x][y] = 'i';				//If so, update the 's' to 'i' in the new grid								}							}						}					}				}			}		}	}		for(int x = 0; x < SIZE; x++){		for(int y = 0; y < SIZE; y++){			today[x][y] = update[x][y]; //Updates today's grid with the new values		}	}}
int countInfected(char arr[][SIZE], int arrSize){	int count = 0;		for(int x = 0; x < arrSize; x++){		for(int y = 0; y < arrSize; y++){			if(arr[x][y] == 'i') count++; //Increments count for each infected person in the grid		}	}		return count;}```

BFS/DFS/TopSort

rlbishop99
0 likes • Apr 30, 2021
C++
```#include <bits/stdc++.h>#define MAXSIZE 50000#define INF 100000
using namespace std;
bool visited[MAXSIZE]; //Checks if a node is visited or not in BFS and DFSbool isConnected = true; //Checks if the input graph is connected or not
int dist[MAXSIZE], discover[MAXSIZE], finish[MAXSIZE]; //Distance for BFS, in time and out time for DFSint t = 1; //Time used for DFSint u, v, i, j, k, N = 0;
stack<int> st; //Stack for TopSort
multiset<pair<int, int>> s; //collection of pairs to sort by distancepair<int, int> current; //pointer variable to a position in the multiset
void BFS(){	queue<int> q; //queue for BFS	q.push(1); //pushing the source	dist[1] = 0; //assign the distance of source as 0	visited[1] = 1; //marking as visited		while(!q.empty())	{	u = q.front();	q.pop();
if(!visited[v]) //if not visited, update the distance and push onto queue	{	visited[v] = 1;	dist[v] = dist[u]+1;	q.push(v);	}
}
}		for(i = 1; i <= N; i++)	{	s.insert(make_pair(dist[i], i)); //for sorted distance	}		cout << "BFS results:" << endl;		//prints BFS results and checks if the graph is connected	while(!s.empty())	{	current = *s.begin(); 	s.erase(s.begin());
i = current.second; 	j = current.first;
if(j == INF) //if any infinite value, graph is not connected	{	cout << i << " INF" << endl;	isConnected = false;	}	else	{	cout << i << " " << j << endl;	}
}
//marks blocks of memory as visited	memset(visited, 0, sizeof visited);}

void dfsSearch(int s){	visited[s] = 1; //marking it visited	discover[s] = t++; //assigning and incrementing time
int i, v;
if(!visited[v]) //if vertex is not visited then visit, else continue	{	dfsSearch(v);	}
}
st.push(s); //pushed onto stack for TopSort if it was called	finish[s] = t++; //out time}
void DFS(){
for(i = 1; i <= N; i++)	{	if(visited[i]) //if visited continue, else visit it with DFS	{	continue;	}
dfsSearch(i); //embedded function to actually perform DFS	}
for(i=1;i<=N;i++)	{	s.insert(make_pair(discover[i], i)); //minheap for sorted discovery time	}		cout << "DFS results:" << endl;
while(!s.empty()) //Prints DFS results as long as the multiset is not empty	{	current = *s.begin(); //duplicates the pointer to first object in the multiset	s.erase(s.begin()); //erases the first object in multiset
i = current.second;	cout << i << " " << discover[i] << " " << finish[i] << endl; //prints discover times and finish times	}
}
void TopSort(){	//call DFS so we can have a sorted stack to print	for(i=1;i<=N;i++)	{	if(visited[i])	{	continue;	}
dfsSearch(i);	}
cout<<"Topological Sort results:"<<endl;
//print sorted results from DFS	while(!st.empty())	{	i = st.top(); 	st.pop();
cout << i << endl;	}
//declare blocks of memory as visited	memset(visited, 0, sizeof visited);
}

int main(){	string str, num, input;	int selection, connectedChoice = 0;

//get to input any file, more freedom than declaring file in command line	cout << "Enter the exact name of your input file [case sensitive]: ";	cin >> input;		ifstream inputFile(input); //Read the input file
//checks if the ifstream cannot open	if(inputFile.fail())	{	cout << endl << "No input files matching that name. Terminating..." << endl;	return 0;	}
//Read until the end of file	while(!inputFile.eof())	{	getline(inputFile, str); //read the current line
if(str == "")	{	continue;	}
if(!isdigit(str[0])) //checks to see if the first item in a line is a digit or not	{	cout << "Invalid file format. You have a line beginning with a non-digit. Terminating..." << endl;	return 0;	}
stringstream ss;	ss << str; //convert the line to stream of strings		ss >> num; //read the line num	stringstream(num) >> u;		while(!ss.eof())	{	ss>>num;	if(stringstream(num) >> v)	{	adj[u].push_back(v); //read the adjacent vertices	}	}
N++; //calculate the number of vertices	sort(adj[u].begin(), adj[u].end()); //sort the adjacency list in case it is not sorted	}		//creates arbitrary values for distance, will check later if INF remain	for(i = 1; i <= N; i++)	{	dist[i] = INF;	}
cout << endl << "Valid Input file loaded!" << endl;
while(selection != 4)	{	cout << "************************************************" << endl;	cout << "What type of analysis would you like to perform?" << endl;	cout << "1: Breadth-First Search" << endl;	cout << "2: Depth-First Search" << endl;	cout << "3: Topological Sort" << endl;	cout << "4: Quit" << endl;	cout << "************************************************" << endl;		//read user input and execute selection	cin >> selection;
switch(selection)	{	case 1:	cout << endl;	BFS();	cout << endl;	cout << "Would you like to know if the graph is connected?" << endl;	cout << "1: Yes" << endl;	cout << "Any other key: No" << endl;	cin >> connectedChoice;
switch(connectedChoice)	{	case 1:	if(!isConnected)	{	cout << "The graph is not connected." << endl << endl;	}	else	{	cout << "The graph is connected!" << endl << endl;	}	break;	default:	break;	}	break;	case 2:	cout << endl;	DFS();	cout << endl;	break;	case 3:	cout << endl;	TopSort();	cout << endl;	break;	case 4:	return 0;	default:	cout << endl << "Invalid selection." << endl; //loops the selection prompt until a valid selection is input.	}
}	}```
```#include "goat.h" //include goat.h
void Goat::setBreed(string breed) {   this->breed = breed;}void Goat::setWeight(float weight) {   this->weight = weight;}void Goat::setName(string name) {   this->name = name;}void Goat::setGender(char gender) {   this->gender = gender;}void Goat::setSpayed(bool goatIsSpayed) {   this->goatIsSpayed = goatIsSpayed;}void Goat::setRegistrationID(string registrationID) {   this->registrationID = registrationID;}void Goat::setColor(string color) {   this->color = color;}void Goat::setOtherComments(string otherComments) {   this->otherComments = otherComments;}string Goat::getBreed() {   return breed;}float Goat::getWeight() {   return weight;}string Goat::getName() {   return name;}char Goat::getGender() {   return gender;}bool Goat::getSpayed() {   return goatIsSpayed;}string Goat::getRegistrationID() {   return registrationID;}string Goat::getColor() {   return color;}string Goat::getOtherComments() {   return otherComments;}
Goat::Goat() {   breed = "";   weight = 0.0;   name = "";   gender = '\0';   goatIsSpayed = false;   registrationID = "";   color = "";   otherComments = "";}
Goat::Goat(string goatBreed, float goatWeight, string goatName, char goatGender, bool goatSpayedStatus, string goatRegistrationID, string goatColor, string goatOtherComments) {     breed = goatBreed;   weight = goatWeight;   name = goatName;   gender = goatGender;   goatIsSpayed = goatSpayedStatus;   registrationID = goatRegistrationID;   color = goatColor;   otherComments = goatOtherComments;}
Goat::~Goat() {   cout << "goat destroyed" << endl;}
void Goat::printinfo() {     cout << "Breed: " << breed << endl << "weight: " << weight << endl << "Name: " << name << endl << "Gender: " << gender << endl << "is Spayed: ";   if(goatIsSpayed) {  //here I do a logical test on boolean goatIsSpayed. if true cout << true else cout << false      cout << "True";   } else {      cout << "False";   }   cout << endl << "Registration ID: " << registrationID << endl << "Color Description: " << color << endl << "Other Comments: " << otherComments << endl << endl;}```

Get Coefficient

AustinLeath
0 likes • Nov 18, 2022
C++
```#include <iostream>using namespace std;
/* Function: get_coeffParameters: double& coeff, int pos passed from bb_4acReturn: type is void so no return, but does ask for user to input data that establishes what a b and c are.*/void get_coeff(double& coeff, int pos) {  char position;  if(pos == 1) {    position = 'a';  } else if(pos == 2) {   //a simple system to determine what coefficient the program is asking for.    position = 'b';  } else {    position = 'c';  }  cout << "Enter the co-efficient" << position << ":"; //prompt to input coeff  cin >> coeff; //input coeff}
/* Function: bb_4acParameters: no parameters passed from main, but 3 params established in function, double a, b, c.Return: b * b - 4 * a * c*/double bb_4ac() {  double a, b, c; //coefficients of a quadratic equation  get_coeff(a, 1); // call function 1st time  get_coeff(b, 2); // call function 2nd time  get_coeff(c, 3); // call function 3rd time  return b * b - 4 * a * c; //return b * b - 4 * a * c}
int main() {  cout << "Function to calculate the discriminant of the equation. . . " << endl;  double determinate = bb_4ac(); //assign double determinate to bb_4ac function  cout << "The discriminant for given values is: " << determinate << endl;  //output the determinate!}```

Hello World!

joshwrou
0 likes • Aug 31, 2020
C++
```#include <iostream>using namespace std;
int main() {
cout << "Hello World!\n";// Prints out "Hello World"return 0;
}```