Skip to main content

C++ Range Slicer

Oct 31, 2023LeifMessinger
Loading...

More C++ Posts

Infection Simulation

Nov 18, 2022AustinLeath

0 likes • 2 views

/*
this program will simulate the spreading of a disease through a
grid of people, starting from a user-defined person. It will count
the number of turns taken before everyone on the grid is immunized
to the disease after having caught it once.
This program will user the SIR model (Susceptible, Infectious, Recovered)
and cellular automata to simulate the people in the grid.
*/
#include <iostream>
using namespace std;
/* Any and all global variables */
const int SIZE = 8; //Size of the square person array
/* Any and all functions */
void gridDefaultify(char[][SIZE], int);
//Purpose: Sets each item in the person array to 's'
//Parameters: A square, two-dimensional array
// The size of that array's bounds
void gridDisplay(char[][SIZE], int);
//Purpose: Formats and prints the information in the person grid
//Parameters: A square, two-dimensional array
// The value of the current day
void nextTurn(char[][SIZE], char[][SIZE], int&);
//Purpose: Updates the grid of people, and the current day
//Parameters: Two square, two-dimensional arrays
// A reference to the current day (so that it can be updated)
int countInfected(char[][SIZE], int);
//Purpose: Counts the number of infectious people on the grid
//Parameters: A square, two-dimensional array
// The size of that array's bounds
int main(){
int currentDay = 0; //Infection begins on day 0, and ends one day after the last person is Recovered
char gridCurrent[SIZE][SIZE]; //Grid of all people
char gridUpdate[SIZE][SIZE]; //Where the user chooses to start the infection
int xToInfect;
int yToInfect; //Set of coordinates for the initial infection position, given by user
//Initializes the grids to all 's'
gridDefaultify(gridCurrent, SIZE);
gridDefaultify(gridUpdate, SIZE);
//The below block gets the initial infection coordinates from the user
cout << "Please enter a location to infect: ";
while(true){
cin >> xToInfect >> yToInfect;
xToInfect--;
yToInfect--;
if(xToInfect < 0 || yToInfect < 0 || xToInfect >= SIZE || yToInfect >= SIZE){
cout << "Those coordinates are outside the bounds of this region." << endl;
cout << "Please enter another location to infect: ";
continue;
} else {
gridCurrent[xToInfect][yToInfect] = 'i';
break;
}
}
//Displays the initial state of the grid
gridDisplay(gridCurrent, currentDay);
//The below block will display and update the grid until the infection is done.
while(true){
nextTurn(gridCurrent, gridUpdate, currentDay);
gridDisplay(gridCurrent, currentDay);
if(countInfected(gridCurrent, SIZE) == 0) break; //Once there are no more infected, the game is done
}
//Displays the number of days taken for the infection to end
cout << "It took " << currentDay + 1 << " days for the outbreak to end";
cout << endl;
return 0;
}
void gridDefaultify(char arr[][SIZE], int arrSize){
for(int x = 0; x < arrSize; x++){
for(int y = 0; y < arrSize; y++){
arr[x][y] = 's'; //Sets all items in the passed-in array to 's'
}
}
return;
}
void gridDisplay(char arr[][SIZE], int day){
cout << "Day " << day << endl; //Prints the current day
for(int x = 0; x < SIZE; x++){
for(int y = 0; y < SIZE; y++){
cout << arr[x][y] <<" "; //Prints the array's contents
}
cout << endl; //Formats with newlines
}
cout << endl; //Some spacing
return;
}
void nextTurn(char today[][SIZE], char update[][SIZE], int& day){
day++; //Updates the day
int xCheck; //X coordinate to be checked
int yCheck; //Y coordinate to be checked
for(int x = 0; x < SIZE; x++){
for(int y = 0; y < SIZE; y++){
//Sets all 'i' to 'r' in the new grid
if(today[x][y] == 'i' || today[x][y] == 'r'){
update[x][y] = 'r'; //Updates all infectious to recovered, and keeps current recovered
}
if(today[x][y] == 's'){ // If the person is susceptible...
for(int xCheck = x-1; xCheck <= x+1; xCheck++){ // Check all x coordinates around the person
for(int yCheck = y-1; yCheck <= y+1; yCheck++){ // Check all y coordinates around the person
if(xCheck == x && yCheck == y){
// Don't check at the person because there is no need to check there
} else {
if(xCheck >= 0 && yCheck >= 0 && xCheck < SIZE && yCheck < SIZE){ // Make sure the checked coordinates are in bounds
if(today[xCheck][yCheck] == 'i'){ //Is the person at the checked coordinates infected?
update[x][y] = 'i'; //If so, update the 's' to 'i' in the new grid
}
}
}
}
}
}
}
}
for(int x = 0; x < SIZE; x++){
for(int y = 0; y < SIZE; y++){
today[x][y] = update[x][y]; //Updates today's grid with the new values
}
}
}
int countInfected(char arr[][SIZE], int arrSize){
int count = 0;
for(int x = 0; x < arrSize; x++){
for(int y = 0; y < arrSize; y++){
if(arr[x][y] == 'i') count++; //Increments count for each infected person in the grid
}
}
return count;
}

sum function

Sep 3, 2023AustinLeath

0 likes • 10 views

#include "stdio.h"
#include <stdlib.h>
int main (int argCount, char** args) {
int a = atoi(args[1]);
int b = atoi(args[2]);
unsigned int sum = 0;
unsigned int p = 1;
for (unsigned int i = 1; i < b; i++) {
p = p * i;
}
// (b!, (1 + b)!, (2 + b)!, ..., (n + b)!)
for (unsigned int i = 0; i < a; i++) {
p = p * (i + b);
sum = sum + p;
}
printf("y: %u\n", sum);
return 0;
}

PlaylistNode.cpp (lab 9)

Nov 18, 2022AustinLeath

0 likes • 1 view

#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();
}
}
}

Get Coefficient

Nov 18, 2022AustinLeath

0 likes • 4 views

#include <iostream>
using namespace std;
/* Function: get_coeff
Parameters: double& coeff, int pos passed from bb_4ac
Return: 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
coeff = 5; //input coeff
}
/* Function: bb_4ac
Parameters: 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!
}

Literal Bruh

Jul 30, 2023LeifMessinger

1 like • 5 views

//Constant prefix notation solver using bruh
//Could make it infix or postfix later
#include<string>
#include<vector>
#include<iostream>
std::vector<long double> bruhBuff;
long double operator ""bruh(long double a){
bruhBuff.push_back(a);
return a;
}
long double operator ""bruh(const char op){
if(bruhBuff.size() < 2) throw "Bruh weak";
long double b = bruhBuff.back();
bruhBuff.pop_back();
long double a = bruhBuff.back();
bruhBuff.pop_back();
switch(op){
case (int)('+'):
return a + b;
case (int)('-'):
return a - b;
case (int)('*'):
return a * b;
case (int)('/'):
return a / b;
}
return 69l;
}
int main(){
1.0bruh;
2.0bruh;
std::cout << '+'bruh << std::endl;
return 0;
}

Wing Project 1

Oct 31, 2021aedrarian

0 likes • 1 view

//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++;
}
}
}