#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;
}

#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 Dimensions
int nMapHeight = 16;

float fPlayerX = 14.7f;			// Player Start Position
float fPlayerY = 5.09f;
float fPlayerA = 0.0f;			// Player Start Rotation
float fFOV = 3.14159f / 4.0f;	// Field of View
float fDepth = 16.0f;			// Maximum rendering distance
float 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;
}

#include <iostream>
using namespace std;
/*
 Description: uses switch case statements to determine whether it is hot or not outside.
 Also uses toupper() function which forces user input char to be uppercase in order to work for the switch statement
*/

int main() {
  char choice;
  cout << "S = Summer, F = Fall, W = Winter, P = Spring" << endl;
  cout << "Enter a character to represent a season: ";asdasdasdasd
  cin >> choice;

  enum Season {SUMMER='S', FALL='F', WINTER='W', SPRING='P'};

  switch(toupper(choice))  // This switch statement compares a character entered with values stored inside of an enum
  {
  case SUMMER:
    cout << "It's very hot outside." << endl;
    break;
  case FALL:
    cout << "It's great weather outside." << endl;
    break;
  case WINTER:
    cout << "It's fairly cold outside." << endl;
    break;
  case SPRING:
    cout << "It's rather warm outside." << endl;
    break;
  default:
    cout << "Wrong choice" << endl;
    break;
  }
  return 0;
}

#include "stdio.h"
#include <stdlib.h>

int main (int argCount, char** args) {
    int a = atoi(args[1]);
    int b = atoi(args[2]);

    unsigned int sum = 0;

    unsigned int p = 1;
    for (unsigned int i = 1; i < b; i++) {
        p = p * i;
    }

    // (b!, (1 + b)!, (2 + b)!, ..., (n + b)!)
    for (unsigned int i = 0; i < a; i++) {
        p = p * (i + b);
        sum = sum + p;
    }
    printf("y: %u\n", sum);
    return 0;
}

/*
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;
}

#include <iostream>
using namespace std;

int main()
{
    cout << "Hello, World!" << endl;
    return 0;
}