## Two Letter Combinations

0 likes • Nov 18, 2022 • 0 views
C++

## More C++ Posts

#### Simple Greedy sort C++

0 likes • Jun 30, 2023 • 5 views
C++
`#include <iostream>using namespace std;int main(){    int arr[] = {5, 1, 4, 20, 10, 2, 13, 11, 6, 21};    int greed[] = {0, 0, 0, 0};    int k = 0;    int i;    int set_index;    while (k < 4)    {        i = 0;        while (i < 10)        {            if (arr[i] > greed[k])            {                greed[k] = arr[i];                set_index = i;            }            i++;        }        arr[set_index] = 0;        k++;    }    cout << greed[0] << " " << greed[1] << " " << greed[2] << " " << greed[3] << endl;}`

#### Get Coefficient

0 likes • Nov 18, 2022 • 4 views
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  coeff = 5; //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!}```

#### Command line game

0 likes • Nov 19, 2022 • 1 view
C++
```#include <iostream>#include <vector>#include <utility>#include <algorithm>#include <chrono>using namespace std;
#include <stdio.h>#include <Windows.h>
int nScreenWidth = 120;			// Console Screen Size X (columns)int nScreenHeight = 40;			// Console Screen Size Y (rows)int nMapWidth = 16;				// World Dimensionsint nMapHeight = 16;
float fPlayerX = 14.7f;			// Player Start Positionfloat fPlayerY = 5.09f;float fPlayerA = 0.0f;			// Player Start Rotationfloat fFOV = 3.14159f / 4.0f;	// Field of Viewfloat fDepth = 16.0f;			// Maximum rendering distancefloat fSpeed = 5.0f;			// Walking Speed
int main(){	// Create Screen Buffer	wchar_t *screen = new wchar_t[nScreenWidth*nScreenHeight];	HANDLE hConsole = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE, 0, NULL, CONSOLE_TEXTMODE_BUFFER, NULL);	SetConsoleActiveScreenBuffer(hConsole);	DWORD dwBytesWritten = 0;
// Create Map of world space # = wall block, . = space	wstring map;	map += L"#########.......";	map += L"#...............";	map += L"#.......########";	map += L"#..............#";	map += L"#......##......#";	map += L"#......##......#";	map += L"#..............#";	map += L"###............#";	map += L"##.............#";	map += L"#......####..###";	map += L"#......#.......#";	map += L"#......#.......#";	map += L"#..............#";	map += L"#......#########";	map += L"#..............#";	map += L"################";
auto tp1 = chrono::system_clock::now();	auto tp2 = chrono::system_clock::now();		while (1)	{		// We'll need time differential per frame to calculate modification		// to movement speeds, to ensure consistant movement, as ray-tracing		// is non-deterministic		tp2 = chrono::system_clock::now();		chrono::duration<float> elapsedTime = tp2 - tp1;		tp1 = tp2;		float fElapsedTime = elapsedTime.count();

// Handle CCW Rotation		if (GetAsyncKeyState((unsigned short)'A') & 0x8000)			fPlayerA -= (fSpeed * 0.75f) * fElapsedTime;
// Handle CW Rotation		if (GetAsyncKeyState((unsigned short)'D') & 0x8000)			fPlayerA += (fSpeed * 0.75f) * fElapsedTime;				// Handle Forwards movement & collision		if (GetAsyncKeyState((unsigned short)'W') & 0x8000)		{			fPlayerX += sinf(fPlayerA) * fSpeed * fElapsedTime;;			fPlayerY += cosf(fPlayerA) * fSpeed * fElapsedTime;;			if (map.c_str()[(int)fPlayerX * nMapWidth + (int)fPlayerY] == '#')			{				fPlayerX -= sinf(fPlayerA) * fSpeed * fElapsedTime;;				fPlayerY -= cosf(fPlayerA) * fSpeed * fElapsedTime;;			}					}
// Handle backwards movement & collision		if (GetAsyncKeyState((unsigned short)'S') & 0x8000)		{			fPlayerX -= sinf(fPlayerA) * fSpeed * fElapsedTime;;			fPlayerY -= cosf(fPlayerA) * fSpeed * fElapsedTime;;			if (map.c_str()[(int)fPlayerX * nMapWidth + (int)fPlayerY] == '#')			{				fPlayerX += sinf(fPlayerA) * fSpeed * fElapsedTime;;				fPlayerY += cosf(fPlayerA) * fSpeed * fElapsedTime;;			}		}
for (int x = 0; x < nScreenWidth; x++)		{			// For each column, calculate the projected ray angle into world space			float fRayAngle = (fPlayerA - fFOV/2.0f) + ((float)x / (float)nScreenWidth) * fFOV;
// Find distance to wall			float fStepSize = 0.1f;		  // Increment size for ray casting, decrease to increase													float fDistanceToWall = 0.0f; //                                      resolution
bool bHitWall = false;		// Set when ray hits wall block			bool bBoundary = false;		// Set when ray hits boundary between two wall blocks
float fEyeX = sinf(fRayAngle); // Unit vector for ray in player space			float fEyeY = cosf(fRayAngle);
// Incrementally cast ray from player, along ray angle, testing for 			// intersection with a block			while (!bHitWall && fDistanceToWall < fDepth)			{				fDistanceToWall += fStepSize;				int nTestX = (int)(fPlayerX + fEyeX * fDistanceToWall);				int nTestY = (int)(fPlayerY + fEyeY * fDistanceToWall);								// Test if ray is out of bounds				if (nTestX < 0 || nTestX >= nMapWidth || nTestY < 0 || nTestY >= nMapHeight)				{					bHitWall = true;			// Just set distance to maximum depth					fDistanceToWall = fDepth;				}				else				{					// Ray is inbounds so test to see if the ray cell is a wall block					if (map.c_str()[nTestX * nMapWidth + nTestY] == '#')					{						// Ray has hit wall						bHitWall = true;
// To highlight tile boundaries, cast a ray from each corner						// of the tile, to the player. The more coincident this ray						// is to the rendering ray, the closer we are to a tile 						// boundary, which we'll shade to add detail to the walls						vector<pair<float, float>> p;
// Test each corner of hit tile, storing the distance from						// the player, and the calculated dot product of the two rays						for (int tx = 0; tx < 2; tx++)							for (int ty = 0; ty < 2; ty++)							{								// Angle of corner to eye								float vy = (float)nTestY + ty - fPlayerY;								float vx = (float)nTestX + tx - fPlayerX;								float d = sqrt(vx*vx + vy*vy); 								float dot = (fEyeX * vx / d) + (fEyeY * vy / d);								p.push_back(make_pair(d, dot));							}
// Sort Pairs from closest to farthest						sort(p.begin(), p.end(), [](const pair<float, float> &left, const pair<float, float> &right) {return left.first < right.first; });												// First two/three are closest (we will never see all four)						float fBound = 0.01;						if (acos(p.at(0).second) < fBound) bBoundary = true;						if (acos(p.at(1).second) < fBound) bBoundary = true;						if (acos(p.at(2).second) < fBound) bBoundary = true;					}				}			}					// Calculate distance to ceiling and floor			int nCeiling = (float)(nScreenHeight/2.0) - nScreenHeight / ((float)fDistanceToWall);			int nFloor = nScreenHeight - nCeiling;
// Shader walls based on distance			short nShade = ' ';			if (fDistanceToWall <= fDepth / 4.0f)			nShade = 0x2588;	// Very close				else if (fDistanceToWall < fDepth / 3.0f)		nShade = 0x2593;			else if (fDistanceToWall < fDepth / 2.0f)		nShade = 0x2592;			else if (fDistanceToWall < fDepth)				nShade = 0x2591;			else											nShade = ' ';		// Too far away
if (bBoundary)		nShade = ' '; // Black it out						for (int y = 0; y < nScreenHeight; y++)			{				// Each Row				if(y <= nCeiling)					screen[y*nScreenWidth + x] = ' ';				else if(y > nCeiling && y <= nFloor)					screen[y*nScreenWidth + x] = nShade;				else // Floor				{									// Shade floor based on distance					float b = 1.0f - (((float)y -nScreenHeight/2.0f) / ((float)nScreenHeight / 2.0f));					if (b < 0.25)		nShade = '#';					else if (b < 0.5)	nShade = 'x';					else if (b < 0.75)	nShade = '.';					else if (b < 0.9)	nShade = '-';					else				nShade = ' ';					screen[y*nScreenWidth + x] = nShade;				}			}		}
// Display Stats		swprintf_s(screen, 40, L"X=%3.2f, Y=%3.2f, A=%3.2f FPS=%3.2f ", fPlayerX, fPlayerY, fPlayerA, 1.0f/fElapsedTime);
// Display Map		for (int nx = 0; nx < nMapWidth; nx++)			for (int ny = 0; ny < nMapWidth; ny++)			{				screen[(ny+1)*nScreenWidth + nx] = map[ny * nMapWidth + nx];			}		screen[((int)fPlayerX+1) * nScreenWidth + (int)fPlayerY] = 'P';
// Display Frame		screen[nScreenWidth * nScreenHeight - 1] = '\0';		WriteConsoleOutputCharacter(hConsole, screen, nScreenWidth * nScreenHeight, { 0,0 }, &dwBytesWritten);	}
return 0;}```

#### Daily: Cutting a Wall

0 likes • Dec 20, 2021 • 0 views
C++
```/*Good morning! Here's your coding interview problem for today.
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 12 3 3 25 54 4 21 3 3 31 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;}```

#### Const value const pointer question

0 likes • Aug 25, 2023 • 11 views
C++
```#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```

#### Infection Simulation

0 likes • Nov 18, 2022 • 2 views
C++
```/*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;}```