#include <iostream>

int main()
  {
   cout<<"Hello World!"<<endl;
   return 0;
  }

 
#include<stdio.h> 

int main (int argc, char * argv[]) 
{ 
   printf("Hello world!\n"); 
   return 0; 
}

#include <iostream>
#include "user.h"
#include "powerizer.h"
#include "replay.h"
#include "header_footer.h"
using namespace std;


/*

	C++ Beginning - Lab 4 - 1307.xxx
	April 9, 2010.
	
	A-Option -
	Inputs:
		User enters number and power
		
	Outputs:

		Program prints number raised to power to stdout.

	Error conditions are handled during number submission
	and answer submission. Option to repeat the program is 
	included. 
*/

int main_driver();

int main(){

        // greet the user
	
	print_intro();

	// Initiate the main controlling section of the program
	
        main_driver();

	// die

	return 0;
		
}


int main_driver(){
     
     int number;
     int power;
     long int result;


     // get number from user
     // get power from user
     // raise number to power
     // print results
     // check for replay
     
     do{
	  
	  // get number and power
	  
	  cout << "Enter the number to raise to a power." << endl;
	  number = user_submitted.g_number();
	  cout << "Enter the power to raise number to." << endl;
	  power = user_submitted.g_number();

	  // do it
	  
	  result = process.raise_number_to_power(number, power);
	  
	  // print out the results
	  
	  print_results(number, power, result);

	  // check for replay
	  
     }while(option_for_replay());
     
return 0;
}

/*
 *	Welcome to user.h. This header file contains routines to
 *	handle user input regarding the numbers they want to
 *	work with in the program (and not for user input
 *	regarding whether or not the user wants to restart
 *	the program. That is handled by option_for_replay.h)
 */


#include <iostream>
using namespace std;

#define MAX_ELEMENT 20 // max elements in any array in this program.

#define debug 0 //   <- make this positive for debug messages.

/*
   In an effort to better understand C, I'll use
   structures for this assignment. In an effort to write
   better code, I've done all of this in an 80x25 terminal
   and using vi, which is the most challenging text editor
   I've come across so far. Also with a serious attempt at
   readable code. 
*/

// Build structures for user submitted info


/* user_submitted_entires pertains to the numer, and the power
     that the user entered. It contains public functions
     for getting a number, and printing number and power. */



struct user_submitted_entries{

     // g_number() gets a number and returns it.
     
     int g_number();
          
     private:

	  // Private variables number and power.

	  int power;
	  int number;

}user_submitted; // <-- create an object user_submitted that can be accessed globally.


/*	user_input pertains to the validity of the user's submissions.
	  it contains public functions to prepare the array for
	  the users entry, to check it, to get the length,
	  and to convert the array to an integer. */

struct user_input{
     
     // dot_array() goes from 0 to max_element filling the array with '.'s
     
     void dot_array(char array[]);

     // validate_entry() checks to see if the users submission was useable in the
     // rest of the program. It returns 1 if the answer is bad, 0 if it is good.
     
     int validate_entry(char ent_num[]);
     
     // g_num_of_elements_in() scans the array for things that aren't '.'s, and returns where the last one was found.
     
     int g_num_of_elements_in(char num[]);

     // make_char_array_a_number() takes an array and its length, and converts it into an integer.
     
     int make_char_array_a_number(char num[], int num_of_elements);

}input; // <-- create object input that can be accessed globally.



// I was happy to learn that part of an idea
// I came up with for multiplying numbers
// in a matrix that is designed to
// replicate physically writing math
/* on a piece of notebook paper would work in this program.


     ( the matrix-math program is useful because I can store more than
	   2^32 in a 100 element vector.. a lot more
	   in the end the idea would simulate long-hand multiplication,
	   addition, subtraction, and division of problems that could be
	   multiple pages wide. 

           --- UPDATE --- Professor says Arrays != Matrices

               For example -


	   2342342342378297834234
	   4534534534534543523423
	   *_____________________
	   //////////// A ////////
          /////////// lot of//////
	  //////////work  here///
	  +_____________________
	  /// bigger answer here      ///
	  // but remember that everything
	  // you see is an element in the
	  // matrix                 // )
*/



/* 
	this function moves through a char array,
	strips each element of its ASCII code, multiplies the
	the element by the power of 10 represented by its
	place in the array (123 = 3*1+2*10+1*100), and 
	assigns the result to "number", which is then returned.
	The char array is started from the end, because 123 is 
	stored in elements [0][1][2] respectively. I did this
	because I didn't know how to handle situations where
	a user is entering an integer number, but instead inputs
	a letter or some other nonsense. The results were generally overflows.
*/
	
int user_input::make_char_array_a_number(char num[], int num_of_elements){

	if(debug){ cout << "Entered make_char_array_a_number()" << endl; }

	int converted_to_number = 0;
	int current_power_of_ten;
	int current_element;

	for(	current_element = num_of_elements,  current_power_of_ten = 1;

				   --current_element >= 0;
	
	   current_power_of_ten *= 10          ){
	     
		    converted_to_number += (num[current_element] - '0') * current_power_of_ten;
	}

if(debug){ cout << "Leaving make_char_array_a_number()." << endl; }
         
	return converted_to_number;
}			


// get the number, and make sure it is a number!

int user_submitted_entries::g_number(){
	char entered_num[MAX_ELEMENT];
	int gotten_number;
	int length;
	
	
	if(debug){ cout << "Entered g_number()." << endl; }

        // prompt toggle changes the prompt from default friendly to
	// "restart and enter the right information" mode after the first run through the program
	// because, presumably, if you come back through for any reason, it is because you entered something wrong.
	
	int prompt_toggle = 0;
	do{
	         if(prompt_toggle == 0){
			 cout << ":";
		 }else{
			 cout << "Positive Entries Only" << endl;
		         cout << ":";
		 }
		 prompt_toggle++;


	         if(debug){ cout << "In g_number() -> dotting array" << endl; }

	       /* to avoid having the array cluttered with old answers, especially
	          in the case of wrong answers, it is necessary to clean the array
		  before each use. I hereby state that being full of periods is being clean.*/

	         input.dot_array(entered_num);

	         if(debug){ cout << "In g_number() -> Done dotting array" << endl; }
	
		 cin >> entered_num;


		 /* 
		   if entered_num turns out to be 
		   something other than a number or a '.',
		   then validate_entry will be positive.
		 */
	
	if(debug){ cout << "In g_number() -> validating entry" << endl; }
		
	}while( input.validate_entry(entered_num) );

	if(debug){ cout << "In g_number() -> Entry validated" << endl; }
	
	
	/* g_num_of_elements_in searches from 0 to MAX_ELEMENT
	   for a period. This will indicate the end of the
           entered number. It depends on validate_entry being called
	   before it. Convenient, since validate_entry is designed
	   to fit in the condition of a do{}while() loop.
	   g_num_of_elements_in does not care what you entered, just
	   how much you entered. As opposed to validate_entry
	   which does not care about how much you entered, but what
	   you actually entered.
	   */
		    

	if(debug){ cout << "In g_number() -> Getting Length" << endl; }

	length = input.g_num_of_elements_in(entered_num);	

	if(debug){ cout << "In g_number() -> Length Obtained" << endl; }

	
	/*
		this aptly named function does exactly
		what it says it does... as it tears apart
		an array of characters, walks through
		each one and multiplies it by the 
		power of 10 represented by its position
		in the array, the results are stored in an integer.
	        It returns that integer. 
	*/ 
	
	if(debug){ cout << "In g_number() -> Making char* to number" << endl; }


	       gotten_number = input.make_char_array_a_number(entered_num, length);
	

	if(debug){ cout << "In g_number() -> char* is now a number." << endl; }


	cout << "You entered [" << gotten_number << "]\n" << endl;

	if(debug){ cout << "Leaving g_number()" << endl; }

	// Finally, return the number you got.

	return gotten_number;
}


    /*
     my answer to the question of, "How do I initialize an array
     so that it is uniform except for situations I'm looking for,
     and that will allow me to perform mathematical operations on
     each element without any issues was to intialize the character
     array with periods, and use my tests based on whether or not
     something was a period, a number, or something I don't want.

     */


// Write to array[i] with periods.

inline void user_input::dot_array(char array[]){
	
	if(debug){ cout << "Entered dot_array()" << endl; }

	int current_element;
	for(current_element = MAX_ELEMENT;
	       --current_element >= 0; 		){

	    array[current_element] = '.';
	}
	if(debug){ cout << "Verification of write to array" << endl;
		   cout << "Start value [" << array[0] << "] End value [";
		   cout << array[MAX_ELEMENT - 1] << "]" << endl;
	}

	if(debug){ cout << "Leaving dot_array()" << endl; }

}

/* 
   This exceedingly inefficient, but Russian Reliable method
   for finding the length of an array is part of another idea I have.
   It works by going from one end of an array of dots to the other,
   looking for things that aren't dots. Mostly this is a result
   of my lack of understanding when it comes to reliably validating data.

   Though I will say this.. The issue with my user input method
   is not caused by cin or by the looping structure. It is caused by
   some buffer I am not aware of that retains the information even
   when my program rejects it. Some buffer that feeds cin. I don't know
   if it is operating system specific, or if it is specific to C++,
	but I have the same issue when I don't use cin (ex, happens with getch, getchar, scanf, etc)
	so stdin must have a buffer or something that bridges stdin to the program. 
*/

inline int user_input::g_num_of_elements_in(char check[]){

	if(debug){ cout << "Entered g_num_of_elements_in()" << endl; }


	int found_length;	
	int cur_elem;


	// go from 0 to max_element looking for things that are '.'
	
	for( cur_elem = 0; cur_elem  < MAX_ELEMENT; cur_elem++    ){

	
			if( check[cur_elem] == '.'){
				found_length = cur_elem-1;
				
				if(debug){	
					cout << "Found Last digit in element[";
					cout << cur_elem-2 << "]";
					cout << "\nRETURNING:  " << found_length;
					cout << endl;
				}
				if(debug){ cout << "leaving g_number()\n"; }

				
				return found_length;
			}else{
			// do nothing because it is not the number, but part of the number.
			}
	}

	if(debug){ cout << "Failed in g_num_of_elements_in()." << endl; }

	return 0;
}


// check to make sure the input is valid.

inline int user_input::validate_entry(char ent_num[]){

	if(debug){ cout << "Entered validate_entry" << endl; }


        int i;

	// TEST CONDITIONS FOR VALIDITY

	bool failed_entry = false;
        for(i = 0; i < MAX_ELEMENT && ent_num[i] != '\0'; i++){

	     if( !(ent_num[i] == '.') && !(isdigit(ent_num[i]))){ failed_entry = true; }

	}
	     


	  if(debug && !failed_entry){ cout << "Answer was good." << endl; }

     return failed_entry;
}

#include <iostream>
#include <cctype>
using namespace std;

// Brain freeze at 4AM..
// super obvious example ensues.

/*
	Basically, allow the user to enter whatever.
	After that, check only the first element of the char array
	that the user just filled with whatever. If it isn't
	yes or no, ask again (but also switch the message.)
	First pass through for the message is a greeting, 
	the next is a courteous error message.
*/

int option_for_replay(){
	char users_response_to_question[100];
	char extracted_answer;
	bool wrong_answer = false;      

	do{
		if(!wrong_answer){

		cout << "Would you like to go again? enter Yyes or Nno\n";

		}else{
		
		cout << "Please enter a valid response of Yyes or Nno" << endl;

		}

		cin >> users_response_to_question;
		extracted_answer = users_response_to_question[0];

		if(	isalpha(      extracted_answer     )  	){
			if(	extracted_answer			//is
					== 'y'			||	//or
				extracted_answer			//is
					== 'Y'			){
				// then the answer is yes

				cout << "Ok, restarting the program.\n\n";
				return true;

			}else if(	extracted_answer         	//is
						== 'n'		||	//or
					extracted_answer		//is
						=='N'   	){
				// then the answer is no
			
				cout << "Shutting down the program.\n" << endl;	
				return false;

			}else{
				wrong_answer = true;
			}
		}else{
			wrong_answer = true;
		} 
	}while(wrong_answer);
	
cout <<  "Never should have gotten here.. go ahead and restart then." << endl;
return true;

}

#include <iostream>
using namespace std;

// Struct declaration and definition

/*
	pretty basic way of raising num to pow.
	take the number that has been interrogated
	thoroughly, and multiply it by its power, which has
	also been interrogated.
	Store that result in number_raised_to_power;
*/

struct powerizer{

	// variable for storing the results

	long int number_raised_to_power;

	// function for factorializing a number

	int raise_number_to_power(int &num, int &pow);


}process; // object process to be accessible globally.



int powerizer::raise_number_to_power(int &base, int &pow){
       int p = pow;
       if(debug){ cout << "Entered raise_number_to_power(int base, int pow)" << endl; }

	// number_raised_to_power is assigned 1
	// because its first use is in multiplication.
	// pow controls the loop, num is the base

	number_raised_to_power = 1;



	for( ; --p >= 0; ){
		number_raised_to_power *= base;
		if(debug){ cout << pow << endl; }
	}
        
	return number_raised_to_power;

	if(debug){ cout << "Leaving raise_number_to_power()" << endl; }

}

#include <iostream>
using namespace std;

// Print welcome screen

void print_intro(){
        cout << "\n\n==================================================================" << endl;
	cout << "Welcome to Jonathan Findley's Powerizer v1.00" << endl;
	cout << "Part of C++ Lab 4 on loops, powers, and that sort of thing...." << endl;
	cout << "Enter the number you want to raise to a power, " << endl;
	cout << "and the program will print the result after exponentiation." << endl;
	cout << "==================================================================\n" << endl;
}

// Print results

void print_results(int &number, int &power, long int &result){
	cout << "======================================================" << endl;
	cout << number << " raised to the power of ";
	cout << power << " is equal to ";
	cout << result;
	cout << endl;
	cout << "======================================================" << endl;
}

#include <iostream>

int main()
  {
   cout<<"Hello Brian!"<<endl;
   return 0;
  }

#include<stdio.h> 

int main (int argc, char * argv[]) 
{ 
   printf("Hello Brian!\n"); 
   return 0; 
}

#include <stdio.h>
#include <stdlib.h>

int numIters = 0;

int Collatz(int num,int maxIters)
{
	printf("%i\n",num);
	numIters += 1;

	if(numIters <= maxIters)
	{
		if(num > 1)
		{
			if(num % 2 == 0)
				Collatz(num / 2,maxIters);
			else
				Collatz((num * 3) - 1,maxIters);
		}
		else
		{
			printf("The number provided reduces to 1.\nThis would be a point in a Collatz fractal.\n");
			return 0;
		}
	}
	else
	{
		printf("The number provided causes the iterations to escape to infinity.\nThis would not be a point in a Collatz fractal.\n");
		return 1;
	}

	return 0;
}

int main(int argc,char* argv[])
{
	if(argc != 3)
		printf("Usage: ./collatz <number> <max iterations>\nUsed for calculating a Collatz sequence based on the number passed to the\nprogram.\n");

	int numParam,iterParam;

	numParam = atoi(argv[1]);
	iterParam = atoi(argv[2]);

	Collatz(numParam,iterParam);

	return 0;
}

 
      PROGRAM HIWORLD(INPUT,OUTPUT,TAPE60=INPUT,TAPE61=OUTPUT)
      CHARACTER HIW*11
       PARAMETER HIW='Hello World"
      WRITE (200,61) HIW
200   FORMAT(1X, 11A1)
      END

SECTION .data

	msg	db	"Hello, world!",0xa ; 
	len	equ     $ - msg

	SECTION .text
	global main

main:
        mov     eax,4		; write system call
        mov     ebx,1           ; file (stdou)
        mov     ecx,msg         ; string
        mov     edx,len         ; strlen
	int     0x80		; call kernel

	mov	eax,1		; exit system call
        mov     ebx,0      
        int     0x80		; call kernel

#!/bin/bash

        echo "Hello world"

#include <stdio.h>

char* questions[3] = {"What are you doing now?",
		      "Who are you?",
		      "How are you feeling?"};

char* answers[3] = {"None of your beeswax...",
		    "Who are YOU?",
		    "Why do you care?"};

int main(int argc,char** argv)
{
	if(argc < 2)
	{
		printf("Usage: ./askme <phrase>\n");
		printf("(where <phrase> is a question)\n");
		
		return 1;
	}
	else
	{
		int i;
		for(i = 0; i <= 2; i++)
		{
			if(strcmp(*argv,questions[i]) == 0)
				printf("%s",answers[i]);
			else
				break;
		}
	}	

	return 0;
}