import java.util.Properties;
import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
 
public class SmtpMail {
 
	private final MailConfig config;
 
	public SmtpMail(MailConfig config) {
		this.config = config;
	}
 
	public boolean send(String to, String from, String subject, String text) {
		return send(new String[] {to}, from, subject, text);
	}
 
	public boolean send(String[] to, String from, String subject, String text) {
 
		Properties props = new Properties();
		props.put("mail.smtp.auth", "true");
		props.put("mail.smtp.host", config.host);
		props.put("mail.smtp.user", config.username);
		props.put("mail.smtp.port", config.port);
		props.put("mail.smtp.password", config.password);
 
		Session session = Session.getInstance(props, new SmtpAuthenticator(config));
 
		try {
 
			Message message = new MimeMessage(session);
			message.setFrom(new InternetAddress(from));
 
			InternetAddress[] addressTo = new InternetAddress[to.length];
			for (int i = 0; i < to.length; i++) {
				addressTo[i] = new InternetAddress(to[i]);
			}
			message.setRecipients(Message.RecipientType.TO, addressTo);
			message.setSubject(subject);
			message.setText(text);
 
		   Transport.send(message);
 
		} catch (MessagingException e) { 
			e.printStackTrace();
			return false;
		}
		return true;
	}
}

import javax.mail.Authenticator;
import javax.mail.PasswordAuthentication;
 
public class SmtpAuthenticator extends Authenticator {
 
	private MailConfig config;
 
	public SmtpAuthenticator(MailConfig config) {
		super();
		this.config = config;
	}
 
	@Override
	public PasswordAuthentication getPasswordAuthentication() {
	    if ((config.username != null) && (config.username.length() > 0) &&
	    		(config.password != null) && (config.password.length   () > 0)) {
	        return new PasswordAuthentication(config.username, config.password);
	    }
	    return null;
	}
 
}

public class MailConfig {
 
	public String host = "";
 
	public int port = 587;
 
	public String username = "";
 
	public String password = "";
 
}

public class MailConfigFactory {
 
	private MailConfigFactory() {
 
	}
 
	public static MailConfig buildDefaultConfig() {
		MailConfig config = new MailConfig();
		config.host = "smtp.host.com";
		config.port = 1234;
		config.username = "username";
		config.password = "password";
 
		return config;
	}
 
}

import static org.junit.Assert.assertTrue;
 
import org.junit.Test;
 
public class SMTPMailTest {
 
	@Test
	public void test() {
		SmtpMail mail = new SmtpMail(MailConfigFactory.buildDefaultConfig());
		String to = "to@gmail.com";
		String from = "from@gmail.com";
		String subject = "Test Subject";
		String text = "This is a sample message body";
 
		assertTrue(mail.send(to, from, subject, text));
	}
 
}

package krunch.lib.ds.trie;
 
public class Trie {
 
	private ObjectTrie<Character> trie;
 
	public Trie() {
		trie = new ObjectTrie<Character>(' ');
	}
 
	public void insert(String s) {
		trie.insert(toArray(s));
	}
 
	public boolean search(String s) {
		return trie.search(toArray(s));
	}
 
	public int numberEntries() {
		return trie.numberEntries();
	}
 
	private Character[] toArray(String s) {
		Character[] cArray = new Character[s.length()];
		for(int i = 0; i < cArray.length; i++) {
			cArray[i] = s.charAt(i);
		}
		return cArray;
	}
 
	public String toString() {
		return trie.toString();
	}
 
}

package krunch.lib.ds.trie;
 
import java.util.ArrayList;
 
public class Node<T> {
 
	private T value;
 
	private boolean endMarker;
 
	public ArrayList<Node<T>> children;
 
 
	public Node(T value) {
		this.value = value;
		this.endMarker = false;
		this.children = new ArrayList<Node<T>>();
	}
 
	public Node<T> findChild(T value) {
		if(children != null) {
			for(Node<T> n : children) {
				if(n.getValue().equals(value)) {
					return n;
				}
			}
		}
		return null;
	}
 
	public T getValue() {
		return value;
	}
 
	public void setEndMarker(boolean endMarker) {
		this.endMarker = endMarker;
	}
 
	public boolean isEndMarker() {
		return endMarker;
	}
 
	public Node<T> addChild(T value) {
		Node<T> n = new Node<T>(value);
		children.add(n);
		return n;
	}
 
}

package krunch.lib.ds.trie;
 
public class ObjectTrie<T> {
 
	private Node<T> root;
 
	private int numberEntries;
 
	public ObjectTrie(T rootNodeValue) {
		root = new Node<T>(rootNodeValue); // "empty value", usually some "null"  value or "empty string"
		numberEntries = 0;
	}
 
	public void insert(T[] values) {
		Node<T> current = root;
		if (values != null) {
			if (values.length == 0) { // "empty value"
				current.setEndMarker(true);
			}
			for (int i = 0; i < values.length; i++) {
				Node<T> child = current.findChild(values[i]);
				if (child != null) {
					current = child;
				} else {
					current = current.addChild(values[i]);
				}
				if (i == values.length - 1) {
					if (!current.isEndMarker()) {
						current.setEndMarker(true);
						numberEntries++;
					}
				}
			}
		} else {
			System.out.println("Not adding anything");
		}
	}
 
	public boolean search(T[] values) {
		Node<T> current = root;
		for (int i = 0; i < values.length; i++) {
			if (current.findChild(values[i]) == null) {
				return false;
			} else {
				current = current.findChild(values[i]);
			}
		}
		/*
		 * Array T[] values found in ObjectTrie. Must verify that the "endMarker" flag
		 * is true
		 */
		if (current.isEndMarker()) {
			return true;
		} else {
			return false;
		}
	}
 
	public int numberEntries() {
		return numberEntries;
	}
 
	public String toString() {
		StringBuilder sb = new StringBuilder();
		sb.append("number entries: ");
		sb.append(numberEntries);
 
		return sb.toString();
	}
 
}

package krunch.lib.utils.ds.trie;
 
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
 
import java.util.HashMap;
 
import krunch.lib.ds.trie.Trie;
import krunch.lib.ds.trie.ObjectTrie;
 
import org.junit.Test;
 
public class TrieTest {
 
	@Test
	public void testStringTrie() {
		Trie trie = new Trie();
		assertEquals(0, trie.numberEntries());
		trie.insert("HELLO");
		assertEquals(1, trie.numberEntries());
		trie.insert("HELLO");					// duplicate words do not count
		assertEquals(1, trie.numberEntries());
		trie.insert("FROG");
		assertEquals(2, trie.numberEntries());	
 
		assertTrue(trie.search("HELLO"));		// should find it
		assertTrue(trie.search("FROG"));		// should find it
		assertFalse(trie.search("HEL"));		// not a full word
	}
 
 
	@Test
	public void testObjectTrie() {	
		ObjectTrie<Object> trie = new ObjectTrie<Object>(new Object());
		Object o1 = 12;
		Object o2 = "ASFAS";
		Object o3 = new Character('X');
		Object o4 = new HashMap<String, String>();
 
		Object[] oArray1 = new Object[] {o1, o1, o2, o3, o3, o4};
		Object[] oArray2 = new Object[] {o1, o2, o3, o4, o4, o1};
		Object[] oArray3 = new Object[] {o1, o1, o2, o2};
 
		assertEquals(0, trie.numberEntries());
		trie.insert(oArray1);
		assertEquals(1, trie.numberEntries());
		trie.insert(oArray1);					// duplicate words do not count
		assertEquals(1, trie.numberEntries());
		trie.insert(oArray2);
		assertEquals(2, trie.numberEntries());	
 
		assertTrue(trie.search(oArray1));		// should find it
		assertTrue(trie.search(oArray2));		// should find it
		assertFalse(trie.search(oArray3));		// not a full word
	}
 
}

#include <iostream>
#include<cstdlib>
#include<ctime>
 
const int DIMX = 6;
const int DIMY = 6;
const int MINES = 6;
const int MINE = -1;
const char COVERED = 'X';
const char UNCOVERED = ' ';
const char FLAG = 'F';
int state[DIMX][DIMY];
char display[DIMX][DIMY];
 
void init(); // initialize game states
int countSorroundingMines(int x, int y); // helper function used by init
void reveal(int x, int y);
void player(); // handle player input
void setFlag();
void uncover();
void print(); // print the minefield
void cheat(); // print out the mines
bool isWin();
bool isLose();
bool playNewGame();
 
int main() {
    std::cout << "Welcome to MineSweeper!" << std::endl;
    init();
    bool playing = true;
    while(playing) {
        print();
        player();
        if(isWin()) {
            std::cout << "You Win!" << std::endl;
            playing = false;
        } else if(isLose()) {
            std::cout << "You Lose!" << std::endl;
            playing = false;
        }
 
        if(!playing) {
            playing = playNewGame();
            if(playing) {
                init();
            }
        }
    }
    std::cout << "Exiting Minesweeper!" << std::endl;
    return 0;
}
 
void init() {
    std::cout << "New Game!" << std::endl;
    // set display to "uncovered"
    for(int y = 0; y < DIMY; y++) {
        for(int x = 0; x < DIMX; x++) {
            display[x][y] = COVERED;
        }
    }
    // initialize mines
    srand(time(0));
    for(int i = 0; i < MINES; i++) {
        bool placed = false;
        while(!placed) {
            int x = rand() % DIMX;
            int y = rand() % DIMY;
            if(state[x][y] != MINE) { // check mine not set
                placed = true;
                state[x][y] = MINE;
            }
        }
    }
    // place hint numbers
    for(int y = 0; y < DIMY; y++) {
        for(int x = 0; x < DIMX; x++) {
            state[x][y] = countSorroundingMines(x, y);
        }
    }
}
 
bool playNewGame() {
    bool selected = false;
    while(!selected) {
        char choice;
        std::cout << "Play another game? Y or N" << std::endl;
        std::cin >> choice;
        if(choice == 'N' || choice == 'n') {
            return false;
            selected = true;
        } else if(choice == 'Y' || choice == 'y') {
            return true;
            selected = true;
        } else {
            std::cout << "That is not a valid choice!" << std::endl;
        }
    }
}
 
void reveal(int x, int y) {
    if(x >= 0 && x < DIMX && y >= 0 && y < DIMY) { // check that x and y are valid
        if(display[x][y] == UNCOVERED) {
            return;
        }
        display[x][y] = UNCOVERED;
 
        if(state[x][y] == MINE || state[x][y] != 0) {
            return;
        }
        reveal(x - 1, y - 1);
        reveal(x, y - 1);
        reveal(x + 1, y - 1);
        reveal(x - 1, y);
        reveal(x + 1, y);
        reveal(x - 1, y + 1);
        reveal(x, y + 1);
        reveal(x + 1, y + 1);
    } else {
        return;
    }
}
 
/*
[x-1, y-1][x, y-1][x+1, y-1]
[x-1, y  ][x, y  ][x+1, y  ]
[x-1, y+1][x, y+1][x+1, y+1]
*/
int countSorroundingMines(int x, int y) {
    if(state[x][y] == MINE) {
        return MINE;
    }
    int num = 0;
    if(x > 0 && y > 0) { // top left
        if(state[x - 1][y - 1] == MINE) {
            num++;
        }
    }
    if(y > 0) { // top
        if(state[x][y - 1] == MINE) {
            num++;
        }
    }
    if(x < DIMX - 1  && y > 0) { // top  right
        if(state[x + 1][y - 1] == MINE) {
            num++;
        }
    }
    if(x > 0) { // left
        if(state[x - 1][y] == MINE) {
            num++;
        }
    }
    if(x < DIMX - 1) { // right
        if(state[x + 1][y] == MINE) {
            num++;
        }
    }
    if(x > 0 && y < DIMY - 1) { // bottom left
        if(state[x - 1][y + 1] == MINE) {
            num++;
        }
    }
    if(y < DIMY - 1) { // bottom
        if(state[x][y + 1] == MINE) {
            num++;
        }
    }
    if(x < DIMX - 1 && y < DIMY - 1) { // bottom right
        if(state[x + 1][y + 1] == MINE) {
            num++;
        }
    }
    return num;
}
 
bool isWin() {
    bool win = true;
    for(int y = 0; y < DIMY; y++) {
        for(int x = 0; x < DIMX; x++) {
            win &= ((display[x][y] == UNCOVERED && state[x][y] != MINE) ||
                    ((display[x][y] == COVERED || display[x][y] == FLAG) && state[x][y] == MINE));
        }
    }
    return win;
}
 
bool isLose() {
    for(int y = 0; y < DIMY; y++) {
        for(int x = 0; x < DIMX; x++) {
            if (display[x][y] == UNCOVERED && state[x][y] == MINE) {
                return true;
            }
        }
    }
    return false;
}
 
void player() {
    std::cout << "Commands: R => reveal square, F => set flag, C => cheat, N => New Game" << std::endl;
    bool selected = false;
    while(!selected) {
        char choice;
        std::cin >> choice;
        if(choice == 'R' || choice == 'r') {
            uncover();
            selected = true;
        } else if(choice == 'F' || choice == 'f') {
            setFlag();
            selected = true;
        } else if(choice == 'C' || choice == 'c') {
            cheat();
        } else if(choice == 'N' || choice == 'n') {
            init();
            selected = true;
        } else {
            std::cout << "Invalid Choice!" << std::endl;
        }
    }
 
}
 
void uncover() {
    bool selected = false;
    while(!selected) {
        int x;
        int y;
        std::cout << "Input X (1 - " << (DIMX) << ")" << std::endl;
        std::cin >> x;
        std::cout << "Input Y (1 - " << (DIMY) << ")" << std::endl;
        std::cin >> y;
        x--;
        y--;
        if(x >= 0 && x < DIMX && y >= 0 && y < DIMY) {
            reveal(x, y); // call recursive reveal algorithm
            selected = true;
        } else {
            std::cout << "(X,Y) Values out of range!" << std::endl;
        }
    }
}
 
void setFlag() {
    bool selected = false;
    while(!selected) {
        int x;
        int y;
        std::cout << "Input X (1 - " << (DIMX) << ")" << std::endl;
        std::cin >> x;
        std::cout << "Input Y (1 - " << (DIMY) << ")" << std::endl;
        std::cin >> y;
        x--;
        y--;
        if(x >= 0 && x < DIMX && y >= 0 && y < DIMY) {
            display[x][y] = FLAG;
            selected = true;
        } else {
            std::cout << "(X,Y) Values out of range!" << std::endl;
        }
    }
}
 
void cheat() {
    std::cout << "Cheating is bad!" << std::endl;
    std::cout << "   ";
    for(int x = 0; x < DIMX; x++) {
        std::cout << (x + 1) << " ";
    }
    std::cout << std::endl << "";
    for(int x = 0; x < DIMX; x++) {
        std::cout << "";
    }
    std::cout << std::endl;
    for(int y = 0; y < DIMY; y++) {
        std::cout << (y + 1) << "  ";
        for(int x = 0; x < DIMX; x++) {
            if(state[x][y] == MINE) {
                std::cout << "@ ";
            } else {
                if(state[x][y] == 0) {
                    std:: cout << "  ";
                } else {
                    std:: cout << state[x][y] << " ";
                }
            }
        }
        std::cout << std::endl;
    }
}
 
void print() {
    std::cout << "   ";
    for(int x = 0; x < DIMX; x++) {
        std::cout << (x + 1) << " ";
    }
    std::cout << std::endl << "";
    for(int x = 0; x < DIMX; x++) {
        std::cout << "";
    }
    std::cout << std::endl;
    for(int y = 0; y < DIMY; y++) {
        std::cout << (y + 1) << "  ";
        for(int x = 0; x < DIMX; x++) {
            if(display[x][y] == COVERED || display[x][y] == 'F') { // is it tile still uncovered
                std::cout << display[x][y] << " ";
            } else { // display the state
                if(state[x][y] == MINE) {
                    std::cout << "@ ";
                } else {
                    if(state[x][y] == 0) {
                        std:: cout << "  ";
                    } else {
                        std:: cout << state[x][y] << " ";
                    }
                }
            }
        }
 
        std::cout << std::endl;
    }
}