## Hash Table Example

0 likes • Nov 18, 2022 • 0 views
C++

## More C++ Posts

#### Simple Greedy sort C++

0 likes • Jun 30, 2023 • 5 views
C++
`#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;}`

#### Daily: Cutting a Wall

0 likes • Dec 20, 2021 • 0 views
C++
```/*Good morning! Here's your coding interview problem for today.
A wall consists of several rows of bricks of various integer lengths and uniform height. Your goal is to find a vertical line going from the top to the bottom of the wall that cuts through the fewest number of bricks. If the line goes through the edge between two bricks, this does not count as a cut.
For example, suppose the input is as follows, where values in each row represent the lengths of bricks in that row:
[[3, 5, 1, 1],	[2, 3, 3, 2],	[5, 5],	[4, 4, 2],	[1, 3, 3, 3],	[1, 1, 6, 1, 1]]
The best we can we do here is to draw a line after the eighth brick, which will only require cutting through the bricks in the third and fifth row.
Given an input consisting of brick lengths for each row such as the one above, return the fewest number of bricks that must be cut to create a vertical line.
AUTHORS NOTE:Makes following assumptions:- Each row is same length- Data is in file called "data.dat" and formatted in space-separated rows- The cuts at the beginning and end of the wall are not solutions
This requires the following file named data.dat that is a space separated file, or similar formatted file:----START FILE----3 5 1 12 3 3 25 54 4 21 3 3 31 1 6 1 1----END FILE----*/
#include <algorithm>#include <iostream>#include <fstream>#include <map>#include <sstream>#include <string>#include <vector>using namespace std;
int main(){	vector<vector<int>> wall;
ifstream in;	in.open("data.dat");	if(!in.good())	{	cout << "ERROR: File failed to open properly.\n";	}
/* Get input from space separated file */	string line;	while(!in.eof())	{	getline(in, line);
int i;	vector<int> currv;	stringstream strs(line);	while(strs >> i)	currv.push_back(i);	wall.push_back(currv);	}

/* Convert each value from "length of brick" to "position at end of brick" */	for(int y = 0; y < wall.size(); y++)	{	wall.at(y).pop_back(); //Delet last val	for(int x = 1; x < wall.at(y).size(); x++) //Skip the first bc data doesn't need change	wall.at(y).at(x) += wall.at(y).at(x-1);	}
/* Check output. COMMENT OUT */	// for(auto row : wall)	// {	// for(int pos : row)	// cout << pos << " ";	// cout << endl;	// }
/* Determine which ending position is most common, and cut there */	//Exclude final position, which will be the size of the wall
int mode = -1;	int amt = -1;	vector<int> tried;	for(auto row : wall)	{	for(int pos : row) //For each pos in the wall	{	//Guard. If pos is contained in the list, skip pos	if(find(tried.begin(), tried.end(), pos) != tried.end())	continue;	tried.push_back(pos);
/* Cycle through each row to see if it contains the pos */	int curramt = 0;	for(auto currrow : wall)	{	if( find( currrow.begin(), currrow.end(), pos ) != currrow.end() )	curramt++;	}	//cout << pos << " " << curramt << endl;
if(curramt > amt)	{	amt = curramt;	mode = pos;	}	}	}
cout << "Please cut at position " << mode << endl;	cout << "This will cut through " << (wall.size() - amt) << " bricks." << endl;
return 0;}```

#### SAM 5 words with bitmaps

0 likes • Oct 23, 2022 • 1 view
C++
```//Leif Messinger//Finds all sets of 5 5 letter words that don't have duplicate letters in either themselves or each other.//First it reads the words in and puts them in groups of their bitmasks//After that, we recurse on each group. Before doing that, we remove the group from the set of other groups to check it against.#include <cstdio> //getchar, printf#include <cassert> //assert#include <vector>#include <set>#include <algorithm> //std::copy_if#include <iterator> //std::back_inserter
#define CHECK_FOR_CRLF true#define MIN_WORDS 5#define MAX_WORDS 5#define WORD_TOO_LONG(len) (len != 5)
const unsigned int charToBitmask(const char bruh){	assert(bruh >= 'a' && bruh <= 'z');	return (1 << (bruh - 'a'));}
void printBitmask(unsigned int bitmask){	char start = 'a';	while(bitmask != 0){		if(bitmask & 1){			putchar(start);		}
bitmask >>= 1;		++start;	}}
//Pointer needs to be deletedconst std::set<unsigned int>* getBitmasks(){	std::set<unsigned int>* bitmasksPointer = new std::set<unsigned int>;	std::set<unsigned int>& bitmasks = (*bitmasksPointer);
unsigned int bitmask = 0;	unsigned int wordLength = 0;	bool duplicateLetters = false;	for(char c = getchar(); c >= 0; c = getchar()){		if(CHECK_FOR_CRLF && c == '\r'){			continue;		}		if(c == '\n'){			if(!(WORD_TOO_LONG(wordLength) || duplicateLetters)) bitmasks.insert(bitmask);			bitmask = 0;			wordLength = 0;			duplicateLetters = false;			continue;		}		if((bitmask & charToBitmask(c)) != 0) duplicateLetters = true;		bitmask |= charToBitmask(c);		++wordLength;	}
void printBitmasks(const std::vector<unsigned int>& bitmasks){	for(unsigned int bruh : bitmasks){		printBitmask(bruh);		putchar(','); putchar(' ');	}	puts("");}
//Just to be clear, when I mean "word", I mean a group of words with the same letters.void recurse(std::vector<unsigned int>& oldBitmasks, std::vector<unsigned int> history, const unsigned int currentBitmask){	//If there's not enough words left	if(oldBitmasks.size() + (-(history.size())) + (-MIN_WORDS) <= 0){		//If there's enough words		if(history.size() >= MIN_WORDS){			//Print the list			printBitmasks(history);		}		return;	//To make it faster, we can stop it after 5 words too	}else if(history.size() >= MAX_WORDS){		//Print the list		printBitmasks(history);		return;	}
//Thin out the array with only stuff that matches the currentBitmask.	std::vector<unsigned int> newBitmasks;	std::copy_if(oldBitmasks.begin(), oldBitmasks.end(), std::back_inserter(newBitmasks), [&currentBitmask](unsigned int bruh){		return (bruh & currentBitmask) == 0;	});
while(newBitmasks.size() > 0){		//I know this modifies 'oldBitmasks' too. It's intentional.		//This makes it so that the word is never involved in any of the child serches or any of the later searches in this while loop.		const unsigned int word = newBitmasks.back(); newBitmasks.pop_back();
std::vector<unsigned int> newHistory = history;		newHistory.push_back(word);
recurse(bitmasks, std::vector<unsigned int>(), 0);
return 0;}```

#### Stock Options Analyzer

0 likes • Nov 18, 2022 • 0 views
C++
```#include <iostream>#include <cmath>#include <string.h>
using namespace std;
int main() {
string tickerName;    int numOfContracts;    float currentOptionValue;
cout << "Enter a stock ticker: ";    getline(cin, tickerName);
cout << "Enter the current number of " << tickerName << " contracts you are holding: ";    cin >> numOfContracts;

cout << "Enter the current price of the option: ";    cin >> currentOptionValue;

cout << "The value of your " << tickerName << " options are: \$" << (currentOptionValue * 100.00) * (numOfContracts);
cout << endl;
return 0;}```

#### Big O(n^2) Ascending Sort

0 likes • Nov 18, 2022 • 6 views
C++
```#include <iostream>using namespace std;
int main() {

int arr[5];        for(int i = 0; i < 5; i++) {        arr[i] = i;    }
for(int i = 0; i < 5; i++) {        cout << "Outputting array info at position " << i + 1 << ": " << arr[i] << endl;    }
for(int i=0;i<5;i++)	{				for(int j=i+1;j<5;j++)		{			if(arr[i]>arr[j])			{				int temp=arr[i];				arr[i]=arr[j];				arr[j]=temp;			}		}	}
cout << endl;
for(int i = 0; i < 5; i++) {        cout << "Outputting sorted array info at position " << i + 1 << ": " << arr[i] << endl;    }
return 0;}```

#### wordScore.cpp

0 likes • Apr 16, 2023 • 0 views
C++
```#include <iostream>#include <string>	//Should already be in iostream#include <cstdlib>
//A word score adds up the character values. a-z gets mapped to 1-26 for the values of the characters.
//wordScore [wordValue]//Pipe in the input into stdin, or type the words yourself.
//Lowercase words onlyint characterValue(const char b){	return ((b >= 'a') && (b <= 'z'))? ((b - 'a') + 1) : 0;}
int main(int argc, char** argv){    //The first argument specifies if you are trying to look for a certain word score	int wordValue = (argc > 1)? std::atoi(argv[1]) : 0;
std::string line;	while(std::getline(std::cin, line)){		int sum = 0;		for(const char c : line){			sum += characterValue(c);		}		if(wordValue){	//If wordValue is 0 or the sum is the correct value			if(wordValue == sum){				std::cout << line << std::endl;			}		} else {			std::cout << sum << "\t" << line << std::endl;		}	}	return 0;}```