Skip to main content

Heapify a vector

0 likes • Nov 19, 2022
C++
Loading...
Download

More C++ Posts

Compute Volume of Cylinder

AustinLeath
0 likes • Nov 18, 2022
C++
/*
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;
cout<<"Enter radius:";
cin>>r;
cout<<"Enter height:";
cin>>h;
v=r*r*h*pi; //compute volume
cout<<"Radius:"<<r<<"\tHeight:"<<h<<endl; //display radius and height
cout<<"\n************************\n";
cout<<"Volume:"<<v<<endl;//display volume
return 0;
}

2D Array Chessboard Pattern

AustinLeath
0 likes • Nov 18, 2022
C++
#include<iostream>
using namespace std;
const int rows = 8;
const int cols = 8;
char chessboard[rows][cols];
void setBoard(char chessboard[][cols]);
void printBoard(char chessboard[][cols]);
void setBoard(char chessboard[][cols]) {
for(int i = 0; i < rows; i++) {
for(int j = 0; j < cols; j++) {
if(i % 2 == 0 && j % 2 == 0) {
chessboard[i][j] = 'x';
} else {
if(i % 2 != 0 && j % 2 == 1) {
chessboard[i][j] = 'x';
} else {
chessboard[i][j] = '-';
}
}
}
}
return;
}
void printBoard(char chessboard[][cols]) {
for(int i = 0; i < rows; i++) {
for(int j = 0; j < cols; j++) {
cout << chessboard[i][j] << " ";
}
cout << endl;
}
return;
}
int main(int argc, char const *argv[])
{
setBoard(chessboard);
printBoard(chessboard);
return 0;
}

BFS/DFS/TopSort

rlbishop99
0 likes • Apr 30, 2021
C++
#include <bits/stdc++.h>
#define MAXSIZE 50000
#define INF 100000
using namespace std;
vector<int> adj[MAXSIZE]; //Adjacency List
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();
for(i=0; i < adj[u].size(); i++)
{
v = adj[u][i]; //Adjacent vertex
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++)
{
v = adj[s][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)
{
adj[u].push_back(v); //read the adjacent vertices
}
}
N++; //calculate the number of vertices
sort(adj[u].begin(), adj[u].end()); //sort the adjacency list in case it is not sorted
}
//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.
}
}
}

C++ SigFigs

ThiccDaddyLOAF
0 likes • Sep 7, 2022
C++
#include <iostream>
#include <cstring>
int main(int argc, char** argv){
//With decimal
if(strstr(argv[1], ".") != nullptr){
int i = 0;
//Skip i to first non 0 digit
while(argv[1][i] < '1' || argv[1][i] > '9') ++i;
//If digit comes before decimal
if((argv[1] + i) < strstr(argv[1], ".")){ //Good example of pointer arithmetic
std::cout << strlen(argv[1] + i) - 1 << std::endl; //Another good example
}else{
//If digit is after decimal
std::cout << strlen(argv[1] + i) << std::endl;
}
}else{
//Without decimal
int m = 0;
int i = 0;
while(argv[1][i] < '1' || argv[1][i] > '9') ++i; //In case of some number like 0045
for(; argv[1][i] != '\0'; ++i){
if(argv[1][i] >= '1' && argv[1][i] <= '9') m = i + 1;
}
std::cout << m << std::endl;
}
return 0;
}

Wing Project 1

aedrarian
0 likes • Oct 31, 2021
C++
//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 readData(map<int, float>* data);
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;
readData(&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++;
}
}
void readData(map<int, float>* data)
{
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++;
}
}
}

Enumeration Basics

AustinLeath
0 likes • Nov 18, 2022
C++
#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;
}