/*
 * Programmer:       Jonathan Landrum
 * Date:             10 March 2012
 *
 * Program:          times.cpp
 * Purpose:          Returns the times table of the size the
 *                   user specifies.
 *
 * Assumptions:      1.) Input is in integer form. Real input
 *                       will cause the program to exit.
 */
 
#include <iostream>
using namespace std;
 
int main() {
	// Variables
	int input;
 
	// Introduce the program
	cout << "--------------------------" << endl;
	cout << "-      Times Tables      -" << endl;
	cout << "--------------------------" << endl;
	cout << endl;
	cout << "This program takes input" << endl;
	cout << "of an integer and returns" << endl;
	cout << "the times tables up to the" << endl;
	cout << "number specified." << endl;
	cout << endl;
	cout << "--------------------------" << endl;
	cout << endl;
	cout << "Enter a natural number: ";
	cin  >> input;
 
	// Sanity check
	while (input < 0) {
		cout << endl;
		cout << "ERROR: Bad input" << endl;
		cout << "Only positive input allowed" << endl;
		cout << endl;
		cout << "Enter a natural number: ";
		cin  >> input;
	} // End sanity check
 
	// Perform calculations
	for (int c = 0; c <= input; ++c) {
		for (int i = 0; i <= input; ++i)
			cout << i << " x " << c << " = " << i * c << "\t";
		cout << endl;
	} // End for
 
	// Exit program
	cout << endl;
	cout << "\\\\//_ Live long and prosper." << endl;
} // End main

/*
 *	Programmer:  Jonathan Landrum
 *	Date:        2 March 2012
 *
 *	Program:     leastCommonMultiple.cpp
 *	Purpose:     Finds the least common multiple
 *	             of two natural numbers using
 *	             Euclid's Algorithm.
 *
 *	Assumptions: 1.) Input is in natural number
 *	                 form. Real input will be cast
 *	                 to an integer, and negative
 *	                 input will cause a loop until
 *	                 positive input is received.
 */
 
#include <iostream>
 
using namespace std;
 
// --------------------------------------------------
// main():
// --------------------------------------------------
int main () {
 
	// Variables
	int input1 = 0;		// First input variable from user
	int input2 = 0;		// Second input variable from user
	int smaller = 0;	// Smaller of the two input variables
	int larger = 0;		// Larger of the two input variables
	int remainder = 0;	// The remainder from continued modulo
	int result = 0;		// Results returned from the operation
 
	// Introduce the program
	cout << endl;
	cout << "------------------------------------------" << endl;
	cout << "-    Least Common Multiple Calculator    -" << endl;
	cout << "------------------------------------------" << endl;
	cout << endl;
	cout << "This program uses Euclid's Algorithm to" << endl;
	cout << "find the least common multiple of two" << endl;
	cout << "natural numbers." << endl;
	cout << endl;
 
 
	// Get input from user
	cout << "Enter the first natural number: ";
	cin  >> input1;
	cout << endl;
 
	while (input1 < 1) {
		cout << "ERROR: Bad input" << endl;
		cout << "Enter the first natural number: ";
		cin  >> input1;
		cout << endl;
	} // End sanity check
 
	cout << "Enter the second natural number: ";
	cin  >> input2;
	cout << endl;
 
	while (input2 < 1) {
		cout << "ERROR: Bad input" << endl;
		cout << "Enter the second natural number: ";
		cin  >> input2;
		cout << endl;
	} // End sanity check
 
 
	// Find the smaller of the two
	if (input1 - input2 > 0) {
		smaller = input2;
		larger  = input1;
	} else {
		smaller = input1;
		larger  = input2;
	} // End if
 
	if (larger % smaller == 0) {
		result = larger;
	} else {
		remainder = larger % smaller;
		while (remainder != 0) {
			larger = smaller;
			smaller = remainder;
			remainder = larger % smaller;
		} // End while
		result = (input1 * input2) / smaller;
	} // End if
 
 
	// Return the results
	cout << "The least common multiple is " << result << endl << endl;
 
	cout << "\\\\//_ Live long and prosper." << endl;
	return (0);
} // End main

/*
 *	Programmer:  Jonathan Landrum
 *	Date:        29 February 2012
 *
 *	Program:     userInterface.cpp
 *	Purpose:     To provide a testbed for
 *                   developing a useful CLI.
 *	Assumptions: None.
 */
 
#include <iostream>
#include <cstdlib>
 
using namespace std;
 
// --------------------------------------------------------
// main():
// --------------------------------------------------------
int main () {
 
	// Variables
	char   response;	// User response to the UI
	string input;		// User input to return
	string buffer;		// Disgarded carriage returns
	int    random;		// Random number for random phrase
 
	// Introduce the program
	cout << endl;
	cout << "-------------------------------" << endl;
	cout << "-    Hello World Generator    -" << endl;
	cout << "-------------------------------" << endl;
	cout << endl;
	cout << endl;
	cout << "ENTER A COMMAND:" << endl;
	cout << endl;
	cout << "     Echo a phrase........[E]" << endl;
	cout << "     Random Message.......[R]" << endl;
	cout << endl;
	cout << "     This help document...[?]" << endl;
	cout << "     EXIT.................[X]" << endl;
	cout << endl;
	cin  >> response;
	cout << endl;
 
 
	// Ensure we have a valid command
	while (response != 'e' && response != 'E' &&
	       response != 'r' && response != 'R' &&
	       response != 'x' && response != 'X' &&
	       response != '?') {
		cout << endl;
		cout << "Error:  << UNKNOWN COMMAND >>" << endl;
		cout << endl;
		cout << endl;
		cout << "ENTER A COMMAND: ";
		cin  >> response;
		cout << endl;
	} // End while
 
 
	// Keep the user in the loop unless they type "X"
	while (response != 'x' || response != 'X') {
		if (response == 'e' || response == 'E') {
			// Get rid of extraneous carriage returns
			getline(cin,buffer);
			cout << "Enter a string: ";
			getline(cin,input);
			cout << endl;
			cout << input << endl << endl;
		} else if (response == 'r' || response == 'R') {
			// Gives us a "random" seed from system time
			srand  (time(NULL));
			// Gives us a natural number from 1 to 5
			random = (rand() % 5) + 1;
			cout << "How to say hello in..." << endl;
			switch (random) {
				case 1:
					cout << "привет (Russian)" << endl;
					break;
				case 2:
					cout << "Hola (Spanish)" << endl;
					break;
				case 3:
					cout << "Hallo (German)" << endl;
					break;
				case 4:
					cout << "Bonjour (French)" << endl;
					break;
				case 5:
					cout << "Hello (English)" << endl;
					break;
				default:
					break;
			} // End random hello switch
			cout << endl;
		} else if (response == '?') {
			cout << "     Echo a phrase........[E]" << endl;
			cout << "     Random Message.......[R]" << endl;
			cout << endl;
			cout << "     This help document...[?]" << endl;
			cout << "     EXIT.................[X]" << endl;
			cout << endl;
		} else {
			break;
		} // End if
 
		cout << "ENTER A COMMAND: ";
		cin  >> response;
		cout << endl;
		while (response != 'e' && response != 'E' &&
		       response != 'r' && response != 'R' &&
		       response != 'x' && response != 'X' &&
		       response != '?') {
			cout << endl;
			cout << "Error:  << UNKNOWN COMMAND >>" << endl;
			cout << endl;
			cout << endl;
			cout << "ENTER A COMMAND: ";
			cin  >> response;
			cout << endl;
		} // End while
	} // End while
 
	// Exit
	cout << "\\\\//_ Live long and prosper." << endl;
	return (0);
} // End main

/*
 *	Programmer:  Jonathan Landrum
 *	Date:        26 February 2012
 *
 *	Program:     variableSwap.cpp
 *	Purpose:     This program swaps the values of
 *                   two variables, without using a
 *                   temporary variable.
 *	Assumptions: None.
 */
 
#include <iostream>
#define SWAP(one,two) { one ^= two; two ^= one; one ^= two; }
 
using namespace std;
 
// --------------------------------------------------
// main():
// --------------------------------------------------
int main () {
 
	// Variables
	int one, two;
 
	// Introduce the program
	cout << endl;
	cout << "-----------------------------------" << endl;
	cout << "-    Two-Variable Value Swapper   -" << endl;
	cout << "-----------------------------------" << endl;
	cout << endl;
	cout << "This program exchanges values of two" << endl;
	cout << "variables WITHOUT using a temporary" << endl;
	cout << "variable." << endl;
	cout << endl;
	cout << "Enter a value for variable 1: ";
	cin  >> one;
	cout << "Enter a value for variable 2: ";
	cin  >> two;
	cout << endl;
 
	cout << "Variable 1 is " << one << endl;
	cout << "variable 2 is " << two << endl;
	cout << endl;
	cout << "Swapping the values..." << endl << endl;
 
	// Main processing loop
	SWAP(one,two);
 
	// Return the results
	cout << "Variable 1 is now " << one << endl;
	cout << "Variable 2 is now " << two << endl;
 
	cout << endl;
	cout << "\\\\//_ Live long and prosper." << endl;
 
	return (0);
} // End main

/*
 *	Programmer:  Jonathan Landrum
 *	Date:        25 February 2012
 *
 *	Program:     checkerboard.cpp
 *	Purpose:     Prints a checkerboard of
 *	             user-defined size.
 *	Assumptions: None.
 */
 
#include <iostream>
 
using namespace std;
 
// --------------------------------------------------
// main():
// --------------------------------------------------
int main () {
 
	// Variables
	int counter, iterator, input;
 
	// Introduce the program
	cout << endl;
	cout << "----------------------------------" << endl;
	cout << "-    C++ Checkerboard Printer    -" << endl;
	cout << "----------------------------------" << endl;
	cout << endl;
	cout << "             +-----+" << endl;
	cout << "             |     |" << endl;
	cout << "             |     |" << endl;
	cout << "             |     |" << endl;
	cout << "             +-----+" << endl;
	cout << endl;
	cout << "This program takes user input of an" << endl;
	cout << "integer and prints a checkerboard" << endl;
	cout << "of that size." << endl;
 
	cout << "What size checkerboard do you want: ";
	cin  >> input;
 
	// Main processing loop
	for (counter = 0; counter < input; ++counter) {
 
		// Print the top line
		for (iterator = 0; iterator < input; ++iterator) {
			cout << "+-----";
		} // End for
		cout << "+" << endl;
 
		// Print the sides
		for (iterator = 0; iterator < input; ++iterator) {
			cout << "|     ";
		} // End for
		cout << "|" << endl;
 
		for (iterator = 0; iterator < input; ++iterator) {
			cout << "|     ";
		} // End for
		cout << "|" << endl;
 
		for (iterator = 0; iterator < input; ++iterator) {
			cout << "|     ";
		} // End for
		cout << "|" << endl;
	} // End for
 
	// Print the last line after the loop
	for (iterator = 0; iterator < input; ++iterator) {
		cout << "+-----";
	} // End for
	cout << "+" << endl;
 
	return (0);
} // End main

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        20 February 2012
// ==================================================
// Program:     timeConverter.cpp
// Purpose:     Converts seconds input (integer) to
//              weeks, days, hours, minutes (etc.)
// Assumptions: 1.) Input is integer form. Floating
//                  point input will be rounded down
//                  to the nearest integer.
// ==================================================
 
#include <iostream>
using namespace std;
 
// --------------------------------------------------
// main():
// --------------------------------------------------
int main () {
 
	// Variables
	int years   = 0;
	int months  = 0; // 30 days
	int weeks   = 0;
	int days    = 0;
	int hours   = 0;
	int minutes = 0;
	int seconds = 0;
	unsigned long int input;
 
	// Introduce the program
	cout << endl;
	cout << "----------------------------" << endl;
	cout << "-      Time Converter      -" << endl;
	cout << "----------------------------" << endl;
	cout << endl;
	cout << "How many seconds to convert? ";
	cin  >> input;
 
	// Main processing loop
	years   = input / 31536000;
	months  = (input % 31536000) / 2592000;
	weeks   = ((input % 31536000) % 2592000) / 604800;
	days    = (((input % 31536000) % 2592000) % 604800) / 86400;
	hours   = ((((input % 31536000) % 2592000) % 604800) % 86400) / 3600;
	minutes = (((((input % 31536000) % 2592000) % 604800) % 86400) % 3600) / 60;
	seconds = ((((((input % 31536000) % 2592000) % 604800) % 86400) % 3600) % 60);
 
 
	// Return the results
	cout << "There are ";
	if (years != 0)
		cout << years << " years ";
 
	if (months != 0)
		cout << months << " months ";
 
	if (weeks != 0)
		cout << weeks << " weeks ";
 
	if (days != 0)
		cout << days << " days ";
 
	if (hours != 0)
		cout << hours << " hours ";
 
	if (minutes != 0)
		cout << minutes << " minutes ";
 
	if (seconds != 0) {
		if (input > 60)
			cout << "and " << seconds << " seconds ";
		else
			cout << seconds << " seconds ";
	} // End if. Will be rather uninpressive for input < 60.
 
	cout << "in " << input << " seconds." << endl;
 
	cout << endl;
	cout << "\\\\//_ Live long and prosper." << endl;
	cout << endl;
	return (0);
} // End main

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        16 February 2012
// ==================================================
// Program:     noFunctions.cpp
// Purpose:     Calculates up to 20!, sans functions.
// Assumptions: None.
// ==================================================
 
#include <iostream>
using namespace std;
 
// --------------------------------------------------
// main():
// Self-containing program
// --------------------------------------------------
int main () {
 
	// Variables
	long answer = 1;
	long response;
 
	// Introduce the program
	cout << endl;
	cout << "-----------------------------------------" << endl;
	cout << "-    Calculating Factorials up to 20!   -" << endl;
	cout << "-----------------------------------------" << endl;
	cout << endl;
	cout << "This program calculates factorials up to" << endl;
	cout << "20!. Larger factorials are impossible." << endl;
	cout << endl;
 
	// Get user response, then do some sanity checks
	do {
		cout << "Enter a positive integer less" << endl;
		cout << "than 21 to calculate: ";
		cin  >> response;
		cout << endl;
	} while (response < 0 || response > 20);
 
	// Calculate the answer
	for (int c = response; c > 1; c--)
		answer = answer * c;
 
	// Return the results
	cout << response << "! is " << answer << endl;
 
	return (0);
} // End main

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        15 February 2012
// ==================================================
// Program:     20Factorial.cpp
// Purpose:     Calculates up to 20! using a function
// Assumptions: None.
// ==================================================
 
#include <iostream>
using namespace std;
 
// Function Prototypes
long factorial(long);
 
// --------------------------------------------------
// main():
// Calls factorial() and returns the answer
// --------------------------------------------------
int main () {
 
	// Variables
	long answer  = 0;
	int  response;
 
	// Introduce the program
	cout << endl;
	cout << "-----------------------------------------" << endl;
	cout << "-    Calculating Factorials up to 20!   -" << endl;
	cout << "-----------------------------------------" << endl;
	cout << endl;
	cout << "This program calculates factorials up to" << endl;
	cout << "20!. Larger factorials are impossible." << endl;
	cout << endl;
 
	// Get user response, then do some sanity checks
	do {
		cout << "Enter a positive integer less" << endl;
		cout << "than 21 to calculate: ";
		cin  >> response;
		cout << endl;
	} while (response < 0 || response > 20);
 
	// Main processing call
	answer = factorial(response);
 
	// Return the results
	cout << response << "! is " << answer << endl;
 
	return (0);
} // End main
 
// --------------------------------------------------
// factorial():
// Recursive function; makes repeated calls to itself
// in order to find n!. Works for up to 20!.
// --------------------------------------------------
long factorial(long in) {
 
	// Variables
	long out;
 
	// Run recursive calculation
	if (in == 0 || in == 1)
		out = 1;
	else
		out = in * factorial (in - 1);
 
	// Return the results
	return out;
}

// Happy St. Valentine's Day!
 
#include <iostream>
using namespace std;
 
int main() {
	int ht;
	int row;
	int index;
	int topHt;
	int initSpace;
	do {
		cout << "Enter the height of your heart: ";
		cin  >> ht;
		if (ht < 3) {
			cout << "have a bigger heart!" << endl;
		} // end if
	} while (ht < 3);
 
	// get it down a couple spaces, and center a message to your Valentine
	cout << endl << endl;
	cout << "                               Roses are #FF0000;" << endl;
	cout << "                                   Violets are #0000FF;" << endl;
	cout << "                               All my base" << endl;
	cout << "                                   Are belong to you!" << endl << endl;
 
	// draw top of the heart
	topHt = ht + 1;
	initSpace = 40 - 2 * ht;
 
	// loop for each top row
	for (row = 2; row < topHt; row++) {
 
		// loop for centering spaces
		for (index = 0; index < initSpace; index++)
			cout << " ";
 
		// loop for initial spaces
		for (index = 0; index < (topHt - row); index++)
			cout << " ";
 
		// loop for right atrium (left side)
		for (index = 0; index < (row * 2 - 1); index++)
			cout << "*";
 
		// loop for aorta :~]
		for (index = 0; index < (2 * (topHt - row) - 1); index++)
			cout << " ";
 
		// loop for left atrium (right side)
		for (index = 0; index < (row * 2 - 1); index++)
			cout << "*";
 
		cout << endl;
	} // end main for
 
	// draw bottom of the heart
	ht = ht * 2 + 1;
	for (row = ht; row > 0; row--) {
 
		// loop for centering spaces
		for (index = 0; index < initSpace; index++)
			cout << " ";
 
		// loop for spaces
		for (index = 0; index < (ht - row); index++)
			cout << " ";
 
		// loop for asterisks
		for (index = 0; index < (row * 2 - 1); index++)
			cout << "*";
 
		cout << endl;
	} // end main for
 
	// add some more spacing at the end for looks
	cout << endl << endl;
 
	return 0;
 
} // end main

// ==================================================
// Programmer:  Jonathan Landrum
// Date:        10 February 2012
// ==================================================
// Program:     sumOfPrimes.cpp
// Purpose:     Adds together the prime numbers less
//              than 2,000,000.
// Assumptions: None.
// ==================================================
 
#include <iostream>
using namespace std;
 
// --------------------------------------------------
// Function prototypes
// --------------------------------------------------
bool prime(int);
 
 
// --------------------------------------------------
// main():
// Calls the prime() function to determine which
// numbers are prime, and then adds them to the sum.
// --------------------------------------------------
int main () {
 
	// ------------------------------------------
	// Variables
	// ------------------------------------------
	int  counter = 1;
	long sum = 0;
 
	// ------------------------------------------
	// Introduce the program
	// ------------------------------------------
	cout << endl;
	cout << "---------------------------" << endl;
	cout << "-      Sum of Primes      -" << endl;
	cout << "---------------------------" << endl;
	cout << endl;
	cout << "This program adds the prime" << endl;
	cout << "numbers less than 2,000,000" << endl;
	cout << endl;
 
	// ------------------------------------------
	// Main processing loop
	// ------------------------------------------
	while (counter < 2000000) {
		if (prime(counter))
			sum += counter;
		counter += 2;
	} // End while
 
	// ------------------------------------------
	// Return the results
	// ------------------------------------------
	cout << sum << endl;
	cout << "-----------------------------" << endl;
	cout << "\\\\//_ Live long and prosper." << endl;
	return (0);
} // End main
 
 
// --------------------------------------------------
// prime():
// Determines if a number is prime
// --------------------------------------------------
bool prime (int n) {
 
	// Variables
	bool result;
	int  i;
 
	// Do work
	if (n <= 1) {
		result = false; // 1 is not prime
 
	} else if ((n == 2) || (n == 3)) {
		result = true; // Hard code 2 and 3
 
	} else if (n % 2 == 0) {
		result = false; // Get rid of evens
 
		/* All other cases are out, so now we check
		 to see if n is divisible by the odd
		 numbers from 3 on. */
	} else {
		i = 3;
		result = true; // Assume it's prime, then prove
 
		while (true) {
			/* If i^2 is not a root of n, or if
			 n % i == 0. (Won't be larger than
			 the square.) */
			if ((i * i > n) || (n % i == 0))
				break;
			i += 2; // Iterate by 2 to get odds
		} // End while
 
		// Record the answer
		if (i * i > n)
			result = true;
		else
			result = false;
	} // End if
 
 
	// Return the answer
	return result;
}