## Heapify a vector

0 likes • Nov 19, 2022
C++

## More C++ Posts

//Get data file at https://codecatch.net/post.php?postID=91e87d73
//Iteration 1 of Wing Project. Solution breaks down around n=35
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
using namespace std;
int getSum(map<int, int> list);
void lowestPrice();
void findSums(int n, vector<map<int, int>>* sumsList, map<int, float>* data);
//void findSum(map<int, int> currList, int x, int n, vector<map<int, int>>* sumsList);
void findSum(map<int, int> currList, int x, int n, vector<map<int, int>>* sumsList, map<int, float>* data);
float getPrice(map<int, int> set, map<int, float>* data);
template <typename S>
ostream& operator<<(ostream& os, const vector<S>& vector)
{
// Printing all the elements using <<
for (auto element : vector) {
os << element << " ";
}
return os;
}
bool operator==(map<int, int> m1, map<int, int> m2)
{
if(m1.size() != m2.size())
return false;
bool ret = true;
for(auto it = m1.begin(); it !=m1.end() && ret; it++)
{
if(ret && m1.count(it->first) != m2.count(it->first))
ret = false;
if(ret && m1.count(it->first) == 1)
{
if(m1.at(it->first) != m2.at(it->first))
ret = false;
}
}
return ret;
}
int main()
{
map<int, float> data;
vector<map<int, int>> *sumsList;
sumsList = new vector<map<int, int>>;
findSums(40, sumsList, &data);
for(auto el : *sumsList)
{
for(auto it = el.begin(); it != el.end(); it++)
{
cout << it->first << "->" << it->second << " ";
}
cout << getPrice(el, &data) << endl;
}
return 0;
}
/* Returns the price of wings given a set of numbers of wings to buy.
* Returns -1 if the set contains a number that is not possible to buy.
*/
float getPrice(map<int, int> set, map<int, float>* data)
{
float price = 0;
for(auto it = set.begin(); it != set.end(); it++)
{
//If data doesn't contain an element of set, return -1
if(data->count(it->first) == 0)
return -1;
price += data->at(it->first) * it->second; //pricePerPacket * qtyOfPackets
}
return price;
}
/* Adds the elements of list.
* Suppose mapping is <num, qty>.
* Returns sum(num*qty)
*/
int getSum(map<int, int> list)
{
int sum = 0;
for(auto it = list.begin(); it != list.end(); it++)
sum += it->first * it->second;
return sum;
}
void findSums(int n, vector<map<int, int>>* sumsList, map<int, float>* data)
{
map<int, int> currList;
//Recur when currSum < n
auto it = data->begin();
while(it->first <= n && it != data->end())
{
findSum(currList, it->first, n, sumsList, data);
it++;
}
}
void findSum(map<int, int> currList, int x, int n, vector<map<int, int>>* sumsList, map<int, float>* data)
{
//Append x to currList
if(currList.count(x) == 0)
currList.emplace(x, 1);
else
{
int val = 1+ currList.at(x);
currList.erase(x);
currList.emplace(x, val);
}
//Determine current sum, check for return cases
int currSum = getSum(currList);
if(currSum > n)
return;
else if(currSum == n)
{
//Check to make sure no duplicates
for(auto list : *sumsList)
{
if(list == currList)
return;
}
sumsList->push_back(currList);
return;
}
//Recur when currSum < n
auto it = data->begin();
while(it->first <= n-x && it != data->end())
{
findSum(currList, it->first, n, sumsList, data);
it++;
}
}
{
ifstream file ("./data", ifstream::in);
if(file.is_open())
{
int i = 0;
while(!file.eof())
{
float wings, price;
string skipnl;
file >> wings;
file >> price;
data->emplace(wings, price);
getline(file, skipnl);
i++;
}
}
}
#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
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
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)
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 = '-';
}
}
}
// 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;
}
/*
Algorithm:
Step 1: Get radius of the cylinder from the user and store in variable r
Step 2: Get height of the cylinder from the user and store in variable h
Step 3: Multiply radius * radius * height * pi and store in v
Step 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;
cin>>r;
cout<<"Enter height:";
cin>>h;
v=r*r*h*pi; //compute volume
cout<<"\n************************\n";
cout<<"Volume:"<<v<<endl;//display volume
return 0;
}
//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
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 <iostream>
using namespace std;
main
{
cout << "No tabbing. That's very sad :(\n";
cout << "No in-editor highlighting either :(((\n";
cout << "Descriptions might be niice too.";
}
#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 DFS
bool 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 DFS
int t = 1; //Time used for DFS
int u, v, i, j, k, N = 0;
stack<int> st; //Stack for TopSort
multiset<pair<int, int>> s; //collection of pairs to sort by distance
pair<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;
for(i = 0; i < adj[s].size(); i++)
{
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)
{
}
}
N++; //calculate the number of vertices
}
//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.
}
}
}