Mine

#include <iostream>
#include "Hash.h"
using namespace std;

int main() {
	HashTable *numbers = new HashTable(211);

	// set numbers
	numbers->put("one", 1);
	numbers->put("two", 2);
	numbers->put("three", 3);
	numbers->put("four", 4);
	numbers->put("five", 5);

	numbers->put("neo", 10);

	numbers->put("TEST", 12);
	numbers->put("TEST2", 13);

	// retrieve numbers
	cout << 
		"one: " << numbers->get("one") << endl <<
		"two: " << numbers->get("two") << endl <<
		"three: " << numbers->get("three") << endl <<
		"four: " << numbers->get("four") << endl <<
		"five: " << numbers->get("five") << endl <<
		"neo: " << numbers->get("neo") << endl <<
		"TEST: " << numbers->get("TEST") << endl <<
		"TEST2: " << numbers->get("TEST2") << endl;
	return 0;
}
#ifndef HASHTABLE_H
#define HASHTABLE_H

#include <string>
using namespace std;

class HashTable {
	private:
		int max;
		int createHash(char[40]);
		void internalPut(char[40], int, int);
		int *hashTable;
		string *hashTableKeys;
	public:
		HashTable() {};
		HashTable(int);
		~HashTable();
		void put(char[40], int);
		int get(char[40]);
};
#endif
#include <iostream>
#include "Hash.h"
using namespace std;

HashTable::HashTable(int newMax) {
	max = newMax;
	hashTable = new int[max];
	hashTableKeys = new string[max];

	// set all values to 0 to default
	for(int i=0; i<max; hashTable[i++] = 0);

	// test duplicates

}

HashTable::~HashTable() {
	delete hashTable;
}

int HashTable::createHash(char word[40]) {
	if(strcmp(word, "TEST") == 0 || strcmp(word, "TEST2") == 0 ) {
		return 210;
	}

	unsigned long value = 0;
	int i = 0;

	while(word[i] != '\0') {
		value += (unsigned int) word[i];
		i++;
	}

	return (value % max);
}

void HashTable::put(char word[40], int value) {
	int hash = createHash(word);

	if(hash > max) {
		cout << "May not add to hash table. Value too large." << endl;
	} else {
		if(hashTable[hash] == 0) {
			internalPut(word, value, hash);
		} else {
			for(int i=hash; i<=max; i++) {
				if(hashTable[i] == 0) {
					internalPut(word, value, i);
					return;
				}
				if(i == max) {
					for(int x=0; x<hash; x++) {
						if(hashTable[x] == 0) {
							internalPut(word, value, x);
							return;
						}
					}
					cout << "Unable to find space to allocate for " << word << endl;
					return;
				}
			}
		}
	}
}

void HashTable::internalPut(char word[40], int value, int index) {
	cout << "inserting: " << word << "\t" << value << "\t" << index << endl;
	hashTable[index] = value;
	hashTableKeys[index] = word;
}

int HashTable::get(char word[40]) {
	int hash = createHash(word);
	if(hashTableKeys[hash] == word) {
		return hashTable[hash];
	} else {
		for(int i=hash; i<=max; i++) {
			if(hashTableKeys[i] == word) {
				return hashTable[i];
			}
			if(i == (max-1)) {
				for(int x=0; x<hash; x++) {
					if(hashTableKeys[x] == word) {
						return hashTable[x];
					}
				}
				cout << "ERROR COULD NOT LOCATE: " << word << endl;
				return -5;
			}
		}
	}
	//return 0;
}