#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

//From https://create.arduino.cc/projecthub/abhilashpatel121/easyfft-fast-fourier-transform-fft-for-arduino-9d2677
#include <cmath>
#include <iostream>
const unsigned char sine_data[] = {	//Quarter a sine wave
	0, 
	4, 9, 13, 18, 22, 27, 31, 35, 40, 44, 
	49, 53, 57, 62, 66, 70, 75, 79, 83, 87, 
	91, 96, 100, 104, 108, 112, 116, 120, 124, 127, 
	131, 135, 139, 143, 146, 150, 153, 157, 160, 164, 
	167, 171, 174, 177, 180, 183, 186, 189, 192, 195, //Paste this at top of program
	198, 201, 204, 206, 209, 211, 214, 216, 219, 221, 
	223, 225, 227, 229, 231, 233, 235, 236, 238, 240, 
	241, 243, 244, 245, 246, 247, 248, 249, 250, 251, 
	252, 253, 253, 254, 254, 254, 255, 255, 255, 255
};
float sine(int i){	//Inefficient sine
	int j=i;
	float out;
	while(j < 0) j = j + 360;
	while(j > 360) j = j - 360;
	if(j > -1 && j < 91) out = sine_data[j];
	else if(j > 90 && j < 181) out = sine_data[180 - j];
	else if(j > 180 && j < 271) out = -sine_data[j - 180];
	else if(j > 270 && j < 361) out = -sine_data[360 - j];
	return (out / 255);
}

float cosine(int i){	//Inefficient cosine
	int j = i;
	float out;
	while(j < 0) j = j + 360;
	while(j > 360) j = j - 360;
	if(j > -1 && j < 91) out = sine_data[90 - j];
	else if(j > 90 && j < 181) out = -sine_data[j - 90];
	else if(j > 180 && j < 271) out = -sine_data[270 - j];
	else if(j > 270 && j < 361) out = sine_data[j - 270];
	return (out / 255);
}

//Example data:

//-----------------------------FFT Function----------------------------------------------//
float* FFT(int in[],unsigned int N,float Frequency){	//Result is highest frequencies in order of loudness. Needs to be deleted.
	/*
	Code to perform FFT on arduino,
	setup:
	paste sine_data [91] at top of program [global variable], paste FFT function at end of program
	Term:
	1. in[] : Data array, 
	2. N : Number of sample (recommended sample size 2,4,8,16,32,64,128...)
	3. Frequency: sampling frequency required as input (Hz)

	If sample size is not in power of 2 it will be clipped to lower side of number. 
	i.e, for 150 number of samples, code will consider first 128 sample, remaining sample will be omitted.
	For Arduino nano, FFT of more than 128 sample not possible due to mamory limitation (64 recomended)
	For higher Number of sample may arise Mamory related issue,
	Code by ABHILASH
	Contact: [email protected] 
	Documentation:https://www.instructables.com/member/abhilash_patel/instructables/
	2/3/2021: change data type of N from float to int for >=256 samples
	*/

	unsigned int sampleRates[13]={1,2,4,8,16,32,64,128,256,512,1024,2048};
	int a = N;
	int o;
	for(int i=0;i<12;i++){		//Snapping N to a sample rate in sampleRates
		if(sampleRates[i]<=a){
			o = i;
		}
	}
		 
	int in_ps[sampleRates[o]] = {}; //input for sequencing
	float out_r[sampleRates[o]] = {}; //real part of transform
	float out_im[sampleRates[o]] = {}; //imaginory part of transform
	int x = 0; 
	int c1;
	int f;
	for(int b=0;b<o;b++){ // bit reversal
		c1 = sampleRates[b];
		f = sampleRates[o] / (c1 + c1);
		for(int j = 0;j < c1;j++){ 
			x = x + 1;
			in_ps[x]=in_ps[j]+f;
		}
	}

	
	for(int i=0;i<sampleRates[o];i++){ // update input array as per bit reverse order
		if(in_ps[i]<a){
			out_r[i]=in[in_ps[i]];
		}
		if(in_ps[i]>a){
			out_r[i]=in[in_ps[i]-a];
		} 
	}


	int i10,i11,n1;
	float e,c,s,tr,ti;

	for(int i=0;i<o;i++){ //fft
		i10 = sampleRates[i]; // overall values of sine/cosine :
		i11 = sampleRates[o] / sampleRates[i+1]; // loop with similar sine cosine:
		e = 360 / sampleRates[i+1];
		e = 0 - e;
		n1 = 0;

		for(int j=0;j<i10;j++){
			c=cosine(e*j);
			s=sine(e*j); 
			n1=j;

			for(int k=0;k<i11;k++){
				tr = c*out_r[i10 + n1]-s*out_im[i10 + n1];
				ti = s*out_r[i10 + n1]+c*out_im[i10 + n1];

				out_r[n1 + i10] = out_r[n1]-tr;
				out_r[n1] = out_r[n1]+tr;

				out_im[n1 + i10] = out_im[n1]-ti;
				out_im[n1] = out_im[n1]+ti; 

				n1 = n1+i10+i10;
			} 
		}
	}

	/*
	for(int i=0;i<sampleRates[o];i++)
	{
	std::cout << (out_r[i]);
	std::cout << ("\t"); // un comment to print RAW o/p 
	std::cout << (out_im[i]); std::cout << ("i"); 
	std::cout << std::endl;
	}
	*/


	//---> here onward out_r contains amplitude and our_in conntains frequency (Hz)
	for(int i=0;i<sampleRates[o-1];i++){ // getting amplitude from compex number
		out_r[i] = sqrt(out_r[i]*out_r[i]+out_im[i]*out_im[i]); // to increase the speed delete sqrt
		out_im[i] = i * Frequency / N;
		std::cout << (out_im[i]); std::cout << ("Hz");
		std::cout << ("\t");	// un comment to print freuency bin 
		std::cout << (out_r[i]);
		std::cout << std::endl;
	}




	x = 0; // peak detection
	for(int i=1;i<sampleRates[o-1]-1;i++){
		if(out_r[i]>out_r[i-1] && out_r[i]>out_r[i+1]){
			in_ps[x] = i; //in_ps array used for storage of peak number
			x = x + 1;
		} 
	}


	s = 0;
	c = 0;
	for(int i=0;i<x;i++){ // re arraange as per magnitude
		for(int j=c;j<x;j++){
			if(out_r[in_ps[i]]<out_r[in_ps[j]]){
				s=in_ps[i];
				in_ps[i]=in_ps[j];
				in_ps[j]=s;
			}
		}
		c=c+1;
	}
	float* f_peaks = new float[sampleRates[o]];
	for(int i=0;i<5;i++){ // updating f_peak array (global variable)with descending order
		f_peaks[i]=out_im[in_ps[i]];
	}
	return f_peaks;
}

//------------------------------------------------------------------------------------//
//main.cpp
int data[64]={
14, 30, 35, 34, 34, 40, 46, 45, 30, 4, -26, -48, -55, -49, -37,
-28, -24, -22, -13, 6, 32, 55, 65, 57, 38, 17, 1, -6, -11, -19, -34, 
-51, -61, -56, -35, -7, 18, 32, 35, 34, 35, 41, 46, 43, 26, -2, -31, -50,
-55, -47, -35, -27, -24, -21, -10, 11, 37, 58, 64, 55, 34, 13, -1, -7
};

int main(){
	const unsigned int SAMPLE_RATE = 48*1000;	//48khz
	auto result = FFT(data,64,SAMPLE_RATE);
	std::cout << result[0] << " " << result[1] << " " << result[2] << " " << result[3] << std::endl;
	delete[] result;
	return 0;
}

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

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

int main() {

cout << "Hello World!\n";
// Prints out "Hello World"
return 0;

}

#include <iostream>
#include <fstream>
#include <string>
#include <cstring>

using namespace std;

//This program makes a new text file that contains all combinations of two letters.
// aa, ab, ..., zy, zz

int main(){
	string filename = "two_letters.txt";

	ofstream outFile;
	outFile.open(filename.c_str());

	if(!outFile.is_open()){
		cout << "Something's wrong. Closing..." << endl;
		return 0;
	}

	for(char first = 'a'; first <= 'z'; first++){
		for(char second = 'a'; second <= 'z'; second++){
			outFile << first << second << " ";
		}
		outFile << endl;
	}

	return 0;
}