Skip to main content

Heapify a vector

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

More C++ Posts

Two Letter Combinations

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

C++ SigFigs

0 likes • Sep 7, 2022 • 0 views
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;
}

GCD using Stein's Algorithm

0 likes • Jun 30, 2023 • 1 view
C++
// Iterative C++ program to
// implement Stein's Algorithm
//#include <bits/stdc++.h>
#include <bitset>
using namespace std;
// Function to implement
// Stein's Algorithm
int gcd(int a, int b)
{
/* GCD(0, b) == b; GCD(a, 0) == a,
GCD(0, 0) == 0 */
if (a == 0)
return b;
if (b == 0)
return a;
/*Finding K, where K is the
greatest power of 2
that divides both a and b. */
int k;
for (k = 0; ((a | b) & 1) == 0; ++k)
{
a >>= 1;
b >>= 1;
}
/* Dividing a by 2 until a becomes odd */
while ((a & 1) == 0)
a >>= 1;
/* From here on, 'a' is always odd. */
do
{
/* If b is even, remove all factor of 2 in b */
while ((b & 1) == 0)
b >>= 1;
/* Now a and b are both odd.
Swap if necessary so a <= b,
then set b = b - a (which is even).*/
if (a > b)
swap(a, b); // Swap u and v.
b = (b - a);
} while (b != 0);
/* restore common factors of 2 */
return a << k;
}
// Driver code
int main()
{
int a = 12, b = 780;
printf("Gcd of given numbers is %d\n", gcd(a, b));
return 0;
}

Hello, World!

0 likes • Nov 18, 2022 • 2 views
C++
#include <iostream>
using namespace std;
int main()
{
cout << "Hello, World!" << endl;
return 0;
}

set hostname syscall

0 likes • Oct 7, 2023 • 7 views
C++
#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/utsname.h>
int main() {
char newHostname[] = "newhostname"; // Replace with the desired hostname
if (sethostname(newHostname, strlen(newHostname)) == 0) {
std::cout << "Hostname set to: " << newHostname << std::endl;
// Optionally, update the /etc/hostname file to make the change permanent
FILE *hostnameFile = fopen("/etc/hostname", "w");
if (hostnameFile != NULL) {
fprintf(hostnameFile, "%s\n", newHostname);
fclose(hostnameFile);
} else {
perror("Failed to update /etc/hostname");
}
} else {
perror("Failed to set hostname");
}
return 0;
}

Egg Problem Template

0 likes • Jul 10, 2023 • 3 views
C++
#include <iostream>
#include <vector>
#include <limits>
#define DEBUG_TRIAL false
class Trial{
public:
const size_t HEIGHT;
std::string record;
//Breaking height is the index of the floor, so 0 is the bottom floor, height-1 is the top floor.
//Eggs is the eggs remaining.
//Start is the bottom floor.
//End is one above the top floor.
const size_t BREAKING_HEIGHT;
size_t eggs;
size_t start;
size_t end;
size_t floorsLeft(){
return (end-start);
}
size_t middle(){
return start + (floorsLeft()/2UL);
}
size_t drops = 0;
Trial(const size_t BREAKING_HEIGHT, size_t eggs, size_t start, size_t end): BREAKING_HEIGHT(BREAKING_HEIGHT), eggs(eggs), start(start), end(end), HEIGHT(end), record(end, '_'){
record[BREAKING_HEIGHT] = 'B'; //Marking the breaking point
}
bool foundAnswer(){
return ((record[0] == 'X') || (record.find("OX")!=std::string::npos));
}
//returns true if the egg broke.
//height is the index of the floor, so 0 is the bottom floor, height-1 is the top floor.
bool drop(size_t height){
#if DEBUG_TRIAL
std::cout << "Start: " << start << ". End: " << end << ". Floors Left: " << floorsLeft() << ". Middle Index: " << middle() << std::endl;
#endif
drops++;
bool cracked = height >= BREAKING_HEIGHT;
if(cracked) --eggs;
//Update the record
record[height] = (height >= BREAKING_HEIGHT)? 'X' : 'O';
#if DEBUG_TRIAL
//Print the record
std::cout << record << std::endl;
#endif
return cracked;
}
size_t nowWhat(){
if(foundAnswer()){
return drops;
}else if(eggs <= 0){ //Ran out of eggs
throw "Algorithm failed! No more eggs!";
return 1UL;
}else if(eggs > 1){
return wrecklessSearch();
}else{
return safeSearch();
}
}
size_t safeSearch(){
if(drop(start)){
--end;
}else{
++start;
}
return nowWhat();
}
size_t wrecklessSearch(){
//If the egg breaks
if(drop(middle())){
end -= (floorsLeft()/2UL);
}else{ //egg doesn't crack
start += (floorsLeft()/2UL);
}
return nowWhat();
}
//returns the amount of drops needed to find the answer
size_t search(){
return nowWhat();
}
};
//Height is the height of the building in floors.
//Breaking height is the index of the floor, so 0 is the bottom floor, height-1 is the top floor.
//Eggs is the eggs given.
//returns the amount of drops needed to find the answer
size_t search(const size_t height, const size_t BREAKING_HEIGHT, size_t eggs){
Trial trial(BREAKING_HEIGHT, eggs, 0, height);
return trial.search();
}
class TrialStats {
public:
size_t min = std::numeric_limits<size_t>::max();
size_t max = 0;
double mean = -1.0;
void printStats(){
// Print the results
std::cout << "Minimum drops: " << min << std::endl;
std::cout << "Maximum drops: " << max << std::endl;
std::cout << "Mean drops: " << mean << std::endl;
}
};
//Benchmarks all the possible breaking points of a single building height with a number of eggs.
TrialStats trial(const size_t HEIGHT, const size_t eggs){
TrialStats stats;
int totaldrops = 0;
//Test every possible breaking point
//Breaking height is the index of the floor, so 0 is the bottom floor, height-1 is the top floor.
for (int breakingHeight = 0; breakingHeight < HEIGHT; ++breakingHeight) {
size_t drops = search(HEIGHT, breakingHeight, eggs);
stats.min = std::min(stats.min, drops);
stats.max = std::max(stats.max, drops);
totaldrops += drops;
}
// Calculate the mean number of drops
stats.mean = static_cast<double>(totaldrops) / HEIGHT;
return stats;
}
//Benchmarks a single building height from 1 egg to MAX_EGGS
void testTower(const size_t height, const size_t MAX_EGGS){
//Drop every amount of eggs that you'd need.
for (int eggs = 1; eggs <= MAX_EGGS; ++eggs) {
std::cout << "Building height: " << height << ". Num eggs: " << eggs << std::endl;
TrialStats stats = trial(height, eggs);
stats.printStats();
std::cout << std::endl << std::endl;
}
}
//Benchmarks all buildings from 0 to MAX_HEIGHT
void benchmark(const size_t MAX_HEIGHT){
const size_t MAX_EGGS = 2;
//Test every building
for (size_t height = 1; height <= MAX_HEIGHT; ++height) {
testTower(height, std::min(height, MAX_EGGS));
}
}
int main() {
constexpr size_t MAX_HEIGHT = 36;
benchmark(MAX_HEIGHT);
return 0;
}