## 2D Array Chessboard Pattern

0 likes • Nov 18, 2022
C++

## More C++ Posts

```#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;}```
```/*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 <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();      }   }}```
```#include <iostream>using namespace std;
int main() {  const int ROW_SIZE = 2;  const int COLUMN_SIZE = 5;              //establish all variables  int matrix[ROW_SIZE][COLUMN_SIZE];  int minVal;
for (int i = 0; i < ROW_SIZE; ++i)    // for loop to ask user to enter data.  {    for (int h = 0; h < COLUMN_SIZE; ++h) {      cout << "Enter data for row #" << i + 1 << " and column #" << h + 1 << ": ";      cin >> matrix[i][h];    }  }  cout << "You entered: " << endl;  for (int i = 0; i < ROW_SIZE; ++i) //for statements to output the array neatly  {    for (int h = 0; h < COLUMN_SIZE; ++h) {      cout << matrix[i][h] << "\t";    }    cout << endl;  }
cout << "Minimum for each row is: {";  for (int i = 0; i < ROW_SIZE; i++) //for statements to find the minimum in each row  {    minVal = matrix[i][0];
for (int h = 0; h < COLUMN_SIZE; h++) {      if (matrix[i][h] < minVal) // if matrix[i][h] < minVal -> minVal = matrix[i][h];      {        minVal = matrix[i][h];      }    }    cout << minVal << ", ";  }  cout << "}" << endl;
cout << "Minimum for each column is: {";  for (int i = 0; i < COLUMN_SIZE; i++) //for statements to find the minimum in each column  {    minVal = matrix[0][i];    for (int h = 0; h < ROW_SIZE; h++) {      if (matrix[h][i] < minVal) //replaces minVal with array index for that column that is lowest      {        minVal = matrix[h][i];      }    }    cout << minVal << ", ";  }  cout << "}" << endl;
return 0;}```
```#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;}```
```#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);}```