Skip to main content
Loading...

More C++ Posts

#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;
}
/*
Good morning! Here's your coding interview problem for today.

This problem was asked by LinkedIn.

A wall consists of several rows of bricks of various integer lengths and uniform height. Your goal is to find a vertical line going from the top to the bottom of the wall that cuts through the fewest number of bricks. If the line goes through the edge between two bricks, this does not count as a cut.

For example, suppose the input is as follows, where values in each row represent the lengths of bricks in that row:

[[3, 5, 1, 1],
	[2, 3, 3, 2],
	[5, 5],
	[4, 4, 2],
	[1, 3, 3, 3],
	[1, 1, 6, 1, 1]]

The best we can we do here is to draw a line after the eighth brick, which will only require cutting through the bricks in the third and fifth row.

Given an input consisting of brick lengths for each row such as the one above, return the fewest number of bricks that must be cut to create a vertical line.

AUTHORS NOTE:
Makes following assumptions:
- Each row is same length
- Data is in file called "data.dat" and formatted in space-separated rows
- The cuts at the beginning and end of the wall are not solutions

This requires the following file named data.dat that is a space separated file, or similar formatted file:
----START FILE----
3 5 1 1
2 3 3 2
5 5
4 4 2
1 3 3 3
1 1 6 1 1
----END FILE----
*/

#include <algorithm>
#include <iostream>
#include <fstream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

int main()
{
	vector<vector<int>> wall;

	ifstream in;
	in.open("data.dat");
	if(!in.good())
	{
	cout << "ERROR: File failed to open properly.\n";
	}

	/* Get input from space separated file */
	string line;
	while(!in.eof())
	{
	getline(in, line);

	int i;
	vector<int> currv;
	stringstream strs(line);
	while(strs >> i)
	currv.push_back(i);
	wall.push_back(currv);
	}

	

	/* Convert each value from "length of brick" to "position at end of brick" */
	for(int y = 0; y < wall.size(); y++)
	{
	wall.at(y).pop_back(); //Delet last val
	for(int x = 1; x < wall.at(y).size(); x++) //Skip the first bc data doesn't need change
	wall.at(y).at(x) += wall.at(y).at(x-1);
	}

	/* Check output. COMMENT OUT */
	// for(auto row : wall)
	// {
	// for(int pos : row)
	// cout << pos << " ";
	// cout << endl;
	// }

	/* Determine which ending position is most common, and cut there */
	//Exclude final position, which will be the size of the wall

	int mode = -1;
	int amt = -1;
	vector<int> tried;
	for(auto row : wall)
	{
	for(int pos : row) //For each pos in the wall
	{
	//Guard. If pos is contained in the list, skip pos
	if(find(tried.begin(), tried.end(), pos) != tried.end())
	continue;
	tried.push_back(pos);

	/* Cycle through each row to see if it contains the pos */
	int curramt = 0;
	for(auto currrow : wall)
	{
	if( find( currrow.begin(), currrow.end(), pos ) != currrow.end() )
	curramt++;
	}
	//cout << pos << " " << curramt << endl; 

	if(curramt > amt)
	{
	amt = curramt;
	mode = pos;
	}
	}
	}

	cout << "Please cut at position " << mode << endl;
	cout << "This will cut through " << (wall.size() - amt) << " bricks." << endl;

	return 0;
}
#include <iostream>
int main(){
    const char* const hello = "Hello, world!";
    
    const char* bruh = hello;
    
    char* const yeet = hello;
    
    std::cout << bruh << std::endl;
    
    std::cout << yeet << std::endl;
    
    return 0;
}

/*
    Place your bets!
    
    Will the program:
    a.) Print "Hello, world!" twice?
    b.) Compile error on line 5 (bruh initialize line) because the pointer gets implicit cast to non-const?
    c.) Compile error on line 7 (yeet initialize line) because the char gets implicit cast to non-const?
    d.) Both b and c?
    e.) Compile error line 11 (print yeet) because the pointer is constant and can't be incremented
    f.) Print "Hello, world!" then print the pointer address in hexadecimal
    g.) Both b and e?
    h.) Both c and e?
    i.) B, c, and e?
    
*/

// The answer is in this base 64 string:
// T25seSBjLikKVGhlIGNvbXBpbGVyIGRvZXNuJ3QgYXBwcmVjaWF0ZSB5b3UgbWFraW5nIHRoZSBjaGFyYWN0ZXJzIHRoZSBwb2ludGVyIHJlZmVycyB0byBub24tY29uc3QsIGJ1dCBpdCdzIGZpbmUgd2l0aCB5b3UgY29weWluZyBhIGNvbnN0YW50IHZhbHVlLCBpLmUuIHRoZSBwb2ludGVyLCB0byBhIG5vbi1jb25zdGFudCB2YXJpYWJsZS4KSWYgeW91IHJlcGxhY2UgdGhhdCBsaW5lIHdpdGggY2hhciogY29uc3QgeWVldCA9IGNvbnN0X2Nhc3Q8Y2hhciogY29uc3Q+KGhlbGxvKTsgSXQnbGwgcHJpbnQgIkhlbGxvLCB3b3JsZCEiIHR3aWNlLCB3aGljaCBpcyB2ZXJ5IHN0cmFuZ2UgY29uc2lkZXJpbmcgdGhhdCB5ZWV0IGlzIGEgY29uc3QgcG9pbnRlciwgc28geW91J2QgdGhpbmsgaXQgd291bGQgcHJpbnQgYXMgYSBoZXhhZGVjaW1hbCBiZWNhdXNlIGlmIHlvdSB0cnkgdG8gKCsreWVldCkgd2hpbGUgbG9vcGluZyB0aHJvdWdoIHRoZSBzdHJpbmcsIHlvdSdkIGdldCBhbiBlcnJvciwgYmVjYXVzZSBpdCdzIGNvbnN0IGFuZCBjYW4ndCBiZSBjaGFuZ2VkLgpJbnN0ZWFkIG9mIHVzaW5nIGEgdGVtcGxhdGUgZnVuY3Rpb24gZm9yIG9zdHJlYW06Om9wZXJhdG9yPDwsIHRoZXkgbWFrZSBpdCBhIGZ1bmN0aW9uIHRoYXQgdGFrZXMgdHlwZSBjb25zdCBjaGFyKiwgYW5kIEMrKyBoYXMgbm8gcHJvYmxlbXMgcHJvbW90aW5nIGEgdmFyaWFibGUgdG8gY29uc3RhbnQgd2hlbiBpbXBsaWNpdCBjYXN0aW5nLCBhbmQgaXQgaGFzIG5vIHByb2JsZW1zIGltcGxpY2l0IGNhc3RpbmcgdGhlIGNvbnN0IHBvaW50ZXIgdG8gYSBub3JtYWwgcG9pbnRlciBiZWNhdXNlIGl0J3MgbWFraW5nIGEgY29weS4gVGhlIHBvaW50ZXIgZ2V0cyBjb3BpZWQgYmVjYXVzZSB0aGUgcG9pbnRlciBpcyBwYXNzZWQgYnkgdmFsdWUsIG5vdCByZWZlcmVuY2Uu
/*
this program will simulate the spreading of a disease through a 
grid of people, starting from a user-defined person. It will count
the number of turns taken before everyone on the grid is immunized
to 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 bounds
void 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 day
void 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;
}