## Parking Lot Simulation

0 likes • Nov 18, 2022
C++

## More C++ Posts

```/*Good morning! Here's your coding interview problem for today.
This problem was asked by Stripe.
Given an array of integers, find the first missing positive integer in linear time and constant space. In other words, find the lowest positive integer that does not exist in the array. The array can contain duplicates and negative numbers as well.
For example, the input [3, 4, -1, 1] should give 2. The input [1, 2, 0] should give 3.
You can modify the input array in-place.*/#include <iostream>using namespace std;
int calcMissing(int* input, int size){	int sum = 0;	int n = 1; //add one to account for missing value	for(int i = 0; i < size; i++)	{	if(input[i] > 0)	{	sum += input[i];	n++;	}	}
//If no numbers higher than 0, answer is 1	if(sum == 0)	return 1;
return (n*(n+1)/2) - sum; //Formula is expectedSum - actualSum	/* expectedSum = n*(n+1)/2, the formula for sum(1, n) */}
int main(){
cout << calcMissing(new int{3, 4, -1, 1}, 4) << endl;	cout << calcMissing(new int{1, 2, 0}, 3) << endl;
//No positive numbers	cout << calcMissing(new int{0}, 1) << endl;}```
```#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;}```
```#include <string>#include <iostream>#include "PlaylistNode.h"using namespace std;
PlaylistNode::PlaylistNode() {   uniqueID = "none";   songName = "none";   artistName = "none";   songLength = 0;   nextNodePtr = 0;}
PlaylistNode::PlaylistNode(string uniqueID_, string songName_, string artistName_, int songLength_) {   uniqueID = uniqueID_;   songName = songName_;   artistName = artistName_;   songLength = songLength_;   nextNodePtr = 0;}
void PlaylistNode::InsertAfter(PlaylistNode* ptr) {   this->SetNext(ptr->GetNext());   ptr->SetNext(this);}
void PlaylistNode::SetNext(PlaylistNode* ptr) {   nextNodePtr = ptr;}
string PlaylistNode::GetID() {   return uniqueID;}
string PlaylistNode::GetSongName() {   return songName;}
string PlaylistNode::GetArtistName() {   return artistName;}
int PlaylistNode::GetSongLength() {   return songLength;}
PlaylistNode* PlaylistNode::GetNext() {   return nextNodePtr;}
void PlaylistNode::PrintPlaylistNode() {   cout << "Unique ID: " << uniqueID << endl;   cout << "Song Name: " << songName << endl;   cout << "Artist Name: " << artistName << endl;   cout << "Song Length (in seconds): " << songLength << endl;}
Playlist::Playlist() {   head = tail = 0;}
void Playlist::AddSong(string id, string songname, string artistname, int length) {   PlaylistNode* n = new PlaylistNode(id, songname, artistname, length);   if (head == 0) {      head = tail = n;   }   else {      n->InsertAfter(tail);      tail = n;   }}
bool Playlist::RemoveSong(string id) {   if (head == NULL) {      cout << "Playlist is empty" << endl;      return false;   }      PlaylistNode* curr = head;   PlaylistNode* prev = NULL;   while (curr != NULL) {      if (curr->GetID() == id) {         break;      }      prev = curr;      curr = curr->GetNext();   }      if (curr == NULL) {      cout << "\"" << curr->GetSongName() << "\" is not found" << endl;      return false;   }   else {      if (prev != NULL) {         prev ->SetNext(curr->GetNext());      }      else {         head = curr->GetNext();      }      if (tail == curr) {         tail = prev;      }      cout << "\"" << curr->GetSongName() << "\" removed." << endl;      delete curr;      return true;   }}
bool Playlist::ChangePosition(int oldPos, int newPos) {   if (head == NULL) {      cout << "Playlist is empty" << endl;      return false;   }      PlaylistNode* prev = NULL;   PlaylistNode* curr = head;      int pos;   if (head == NULL || head == tail) {      return false;   }      for (pos = 1; curr != NULL && pos < oldPos; pos++) {      prev = curr;      curr = curr->GetNext();   }   if (curr != NULL) {      string currentSong = curr->GetSongName();            if (prev == NULL) {         head = curr->GetNext();      }      else {         prev->SetNext(curr->GetNext());      }      if (curr == tail) {         tail = prev;      }            PlaylistNode* curr1 = curr;      prev = NULL;      curr = head;      for (pos = 1; curr != NULL && pos < newPos; pos++) {         prev = curr;         curr = curr->GetNext();      }      if (prev == NULL) {         curr1->SetNext(head);         head = curr1;      }      else {         curr1->InsertAfter(prev);      }      if (curr == NULL) {         tail = curr1;      }      cout << "\"" << currentSong << "\" moved to position " << newPos << endl;      return true;   }   else {      cout << "Song's current position is invalid" << endl;      return false;   }}
void Playlist::SongsByArtist(string artist) {   if (head == NULL) {      cout << "Playlist is empty" << endl;   }   else {      PlaylistNode* curr = head;      int i = 1;      while (curr != NULL) {         if (curr->GetArtistName() == artist) {            cout << endl << i << "." << endl;            curr->PrintPlaylistNode();         }         curr = curr->GetNext();         i++;      }   }}
int Playlist::TotalTime() {   int total = 0;   PlaylistNode* curr = head;      while (curr != NULL) {      total += curr->GetSongLength();      curr = curr->GetNext();   }   return total;}
void Playlist::PrintList() {   if (head == NULL) {      cout << "Playlist is empty" << endl;   }   else {      PlaylistNode* curr = head;      int i = 1;      while (curr != NULL) {         cout << endl << i++ << "." << endl;         curr->PrintPlaylistNode();         curr = curr->GetNext();      }   }}```
```/*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;}```
```#include <iostream>#include <vector>using namespace std;
void swap(int *a, int *b){  int temp = *b;  *b = *a;  *a = temp;}void heapify(vector<int> &hT, int i){  int size = hT.size();  int largest = i;  int l = 2 * i + 1;  int r = 2 * i + 2;  if (l < size && hT[l] > hT[largest])    largest = l;  if (r < size && hT[r] > hT[largest])    largest = r;
if (largest != i)  {    swap(&hT[i], &hT[largest]);    heapify(hT, largest);  }}void insert(vector<int> &hT, int newNum){  int size = hT.size();  if (size == 0)  {    hT.push_back(newNum);  }  else  {    hT.push_back(newNum);    for (int i = size / 2 - 1; i >= 0; i--)    {      heapify(hT, i);    }  }}void deleteNode(vector<int> &hT, int num){  int size = hT.size();  int i;  for (i = 0; i < size; i++)  {    if (num == hT[i])      break;  }  swap(&hT[i], &hT[size - 1]);
hT.pop_back();  for (int i = size / 2 - 1; i >= 0; i--)  {    heapify(hT, i);  }}void printArray(vector<int> &hT){  for (int i = 0; i < hT.size(); ++i)    cout << hT[i] << " ";  cout << "\n";}
int main(){  vector<int> heapTree;
insert(heapTree, 3);  insert(heapTree, 4);  insert(heapTree, 9);  insert(heapTree, 5);  insert(heapTree, 2);
cout << "Max-Heap array: ";  printArray(heapTree);
deleteNode(heapTree, 4);
cout << "After deleting an element: ";
printArray(heapTree);}```
```#include <iostream>using namespace std;
/* Function: get_coeffParameters: double& coeff, int pos passed from bb_4acReturn: type is void so no return, but does ask for user to input data that establishes what a b and c are.*/void get_coeff(double& coeff, int pos) {  char position;  if(pos == 1) {    position = 'a';  } else if(pos == 2) {   //a simple system to determine what coefficient the program is asking for.    position = 'b';  } else {    position = 'c';  }  cout << "Enter the co-efficient" << position << ":"; //prompt to input coeff  cin >> coeff; //input coeff}
/* Function: bb_4acParameters: no parameters passed from main, but 3 params established in function, double a, b, c.Return: b * b - 4 * a * c*/double bb_4ac() {  double a, b, c; //coefficients of a quadratic equation  get_coeff(a, 1); // call function 1st time  get_coeff(b, 2); // call function 2nd time  get_coeff(c, 3); // call function 3rd time  return b * b - 4 * a * c; //return b * b - 4 * a * c}
int main() {  cout << "Function to calculate the discriminant of the equation. . . " << endl;  double determinate = bb_4ac(); //assign double determinate to bb_4ac function  cout << "The discriminant for given values is: " << determinate << endl;  //output the determinate!}```