#define NUM_BITS 8

#include <iostream>


struct Number{
    int num : NUM_BITS;
    Number(){}
    Number(const int& bruh){
        num = bruh;
    }
    operator int() const { return num; }
    Number& operator=(const int& bruh){
        num = bruh;
        return (*this);
    }
};

using namespace std;

bool isNegative(const int& num){
    //This gets the bitwise and of num and 10000000000000000000000000000000
    //This implicit casts to bool, which means (num & (1 << 31)) != 0
    return (num & (1 << 31));
}

void printBinaryNumber(const int& num, const int numBits){
    for(int i = numBits; i > 0; --i){
        //8..1
        int bitMask = 1 << (i-1);
        if(num & bitMask){ //Test the bit
            cout << '1';
        }else{
            cout << '0';
        }
    }
}

void printCarryBits(const int& a, const int& b, const int numBits){
    int answer = 0;
    
    bool carry = false;
    for(int i = 0; i < numBits; ++i){
        //8..1
        int bitMask = 1 << i;
        bool aBit = a & bitMask;
        bool bBit = b & bitMask;
        if(aBit && bBit || aBit && carry || bBit && carry){ //Carry bit is true next
            if(carry)
                answer |= bitMask;
            carry = true;
        }else{
            if(carry)
                answer |= bitMask;
            carry = false;
        }
    }
    printBinaryNumber(answer, 8);
}


void printBorrowBits(const int& a, const int& b, const int numBits){
    int answer = 0;
    
    bool carry = false;
    for(int i = 0; i < numBits; ++i){
        //8..1
        int bitMask = 1 << i;
        bool aBit = a & bitMask;
        bool bBit = b & bitMask;
        if((!(aBit ^ carry)) && bBit){ //Carry bit is true next
            if(carry)
                answer |= bitMask;
            carry = true;
        }else{
            if(carry)
                answer |= bitMask;
            carry = false;
        }
    }
    printBinaryNumber(answer, 8);
}

void doProblem(const int& a, const int& b, const char& sign, const int& result, const int& numBits){
    if(sign == '+'){
        cout << ' '; printCarryBits(a, b, numBits); cout << endl;
    }else{
        cout << ' '; printBorrowBits(a, b, numBits); cout << endl;
    }
    cout << ' '; printBinaryNumber(a, numBits); cout << endl;
    cout << sign; printBinaryNumber(b, numBits); cout << endl;
    cout << "----------" << endl;
    cout << ""; printBinaryNumber(result, numBits + 1); cout << " = " << result;
    cout << endl;
}

int main(){
    
    Number a = 0b110;
    Number b = 0b011;
    cout<< a << endl << b << endl;
    
    doProblem(a, b, '+', a + b, NUM_BITS);
    doProblem(a, b, '-', a - b, NUM_BITS);
    doProblem(-a, b, '+', -a + b, NUM_BITS);
    doProblem(a, b, '-', -a - b, NUM_BITS);
    

    return 0;
}

//===============Header File==================
#include <iostream>
#include <sstream> //stringbuf
#include <utility> //exchange

//Couple rules:
//Characters given through the getter functions have to be removed from the buffer.
    //This is so that bufferEmpty() == buffer.in_avail() > 0 basically always.
    //skipWhitespace doesn't remove the text from the buffer, but it does return the number of characters.
//nextWord will trim whitespace before the word
//nextInt will trim non-numbers before the number
//hasNextInt and hasNextWord will trim the whitespace. If you think you need it, you should get nextWhitespace before doing any of those.
//Whitespace after a word or an int is left on the buffer.
//nextWhitespace will (get and) remove whitespace until the end of the line, including the newline character, but stops before the next line.
    //nextWhitespace won't read the next line when called before the end of the line, and it won't prompt the user for the next line if interactive.
        //If nextWhitespace is called after reading the end of the line, then it will read a new line into the buffer, which will prompt the user.
    //It acts like nextLine, but if there's something non-whitespace on the current line it stops there.
class Scanner {
    public:
        std::stringbuf buffer;
        std::istream& input;
        
        Scanner(std::istream& in = std::cin) : buffer(), input(in) {}
        
    //Buffer debugging
        bool fillBuffer();
    
        bool bufferEmpty();
        void printBufferEmpty();
        std::string getBuffer();
        size_t bufferLength();
        void printBufferStats();
    
    //Int
        bool hasNextInt();
        int nextInt();
    
    //Word
        bool hasNextWord();
        std::string nextWord();
    
    //Line
        bool hasNextLine();
    
    //Whitespace
        size_t skipWhitespace();    //Prob should be private, but I don't believe in that private shit.
        bool hasNextWhitespace();
        std::string nextWhitespace();
        std::string nextWhitespaceAll();
        std::string nextLine();
};

//===============Source File==================
bool Scanner::fillBuffer() {    //Returns if it had to get the next line from the input.
    const bool badInput = input.eof() || input.bad();
    const bool shouldFillBuffer = bufferEmpty() && !badInput;
    if (shouldFillBuffer) {
        std::string line;
        if (std::getline(input, line)) {
            buffer.str(buffer.str() + line + "\n");
        }
    }
    return shouldFillBuffer;
}

bool Scanner::bufferEmpty(){
    return buffer.str() == "";
}
void Scanner::printBufferEmpty(){
    std::cout << "The buffer is " << (bufferEmpty()? "" : "not") << " empty." << std::endl;
}

std::string Scanner::getBuffer(){
    return buffer.str();
}
size_t Scanner::bufferLength(){
    return buffer.str().length();
}
void Scanner::printBufferStats(){
    if(bufferEmpty()){
        std::cout << "The buffer is \"\"" << std::endl;
        return;
    }
    std::cout << "The length of the buffer is " << bufferLength() << std::endl;
    if(buffer.sgetc() == '\r'){
        std::cout << "The buffer is \\r\\n" << std::endl;
    }else if(buffer.sgetc() == '\n'){
        std::cout << "The buffer is \\n" << std::endl;
    }
}

bool Scanner::hasNextInt() {
    return hasNextWord() && (std::isdigit(buffer.sgetc()) || buffer.sgetc() == '-');
}

int Scanner::nextInt() {
    if (!hasNextInt()) {   //Will fill the buffer if not filled. Will also trim whitespace.
        return 0;
    }
    
    std::string num;
    size_t charactersRead = 0;
    while (buffer.in_avail() > 0 && (std::isdigit(buffer.sgetc()) || buffer.sgetc() == '-')) {
        num += buffer.sbumpc();
        ++charactersRead;
    }
    buffer.str(buffer.str().erase(0, charactersRead));
    return std::stoi(num);
}

bool Scanner::hasNextWord() {
    nextWhitespaceAll();
    return buffer.in_avail() > 0;
}

std::string Scanner::nextWord() {
    if (!hasNextWord()) {   //Will fill the buffer if not filled. Will also trim whitespace.
        return "";
    }
    
    std::string word;
    size_t charactersRead = 0;
    while (buffer.in_avail() > 0 && !std::isspace(buffer.sgetc())) {
        word += buffer.sbumpc();
        ++charactersRead;
    }
    buffer.str(buffer.str().erase(0, charactersRead));
    return word;
}

bool Scanner::hasNextLine() {
    return (!bufferEmpty()) || fillBuffer();
}

size_t Scanner::skipWhitespace() {   //Returns characters read
    size_t charactersRead = 0;
    while (buffer.in_avail() > 0 && std::isspace(buffer.sgetc())) {
        buffer.sbumpc();
        ++charactersRead;
    }
    return charactersRead;
}
bool Scanner::hasNextWhitespace(){
    fillBuffer();
    return buffer.in_avail() > 0 && std::isspace(buffer.sgetc());
}
std::string Scanner::nextWhitespace() {
    if (!hasNextWhitespace()) {   //Will fill the buffer if not filled
        return "";
    }
    const size_t charactersRead = skipWhitespace();
    std::string whitespace = buffer.str().substr(charactersRead);
    buffer.str(buffer.str().erase(0, charactersRead));
    return whitespace;
}
std::string Scanner::nextWhitespaceAll(){
    std::string whitespace;
    while(hasNextWhitespace()){
        std::string gottenWhiteSpace = nextWhitespace();
        whitespace += gottenWhiteSpace;
    }
    return whitespace;
}
std::string Scanner::nextLine(){
    if (!hasNextLine()) {
        return "";
    }
    
    fillBuffer();
    //Swap out the old buffer with an empty buffer, and get the old buffer as a variable.
    std::string line = std::exchange(buffer, std::stringbuf()).str();
    
    //Remove the newline.
    if(line[line.length() - 1] == '\n' || line[line.length() - 1] == '\r' ) line.pop_back();
    if(line[line.length() - 1] == '\r' || line[line.length() - 1] == '\n' ) line.pop_back();
    return line;
}


//=================Word and Int test=================
while(bruh.hasNextInt() || bruh.hasNextWord()){
    std::cout << "started loop" << std::endl;
    if(bruh.hasNextInt()){
        std::cout << "Int: " << bruh.nextInt() << " " << std::endl;
    }else{
        std::cout << "Word: " << bruh.nextWord() << " " << std::endl;
    }
    bruh.nextWhitespace();
}
//===================Line test======================
for(int count = 1; bruh.hasNextLine(); ++count){
    std::string line = bruh.nextLine();
    std::cout << "Line " << count << ": " << line << std::endl;
}

#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;

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

#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>
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!
}