pull request

.classpath

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+  <classpathentry kind="src" path="src"/>
+  <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8"/>
+  <classpathentry kind="lib" path="/Users/bzanardo/eclipse/java-photon/plugins/junit-4.10.jar"/>
+  <classpathentry kind="output" path="bin"/>
+</classpath>

src/edu/nd/se2018/homework/hwk1/Question1.java

@@ -1,10 +1,27 @@
 package edu.nd.se2018.homework.hwk1;
+import java.util.*;
 
 public class Question1 {
 
 	public Question1(){}
 
 	public int getSumWithoutDuplicates(int[] numbers){
-		return 0;	
+		int total = 0;
+		Set<Integer> set = new HashSet<Integer>();
+		for (int i = 0; i < numbers.length; i++) {
+			if (!set.contains(numbers[i])) {
+				set.add(numbers[i]);
+				total += numbers[i];
+			}
+
+		}
+		return total;
+	}
+
+	public static void main(String[] args) {
+		int[] nums = {3, 3, 5, 5, 2};
+		Question1 getSum = new Question1();
+		int result = getSum.getSumWithoutDuplicates(nums);
+		System.out.println("The answer is:" + result);
 	}
 }

src/edu/nd/se2018/homework/hwk1/Question2.java

@@ -1,10 +1,56 @@
 package edu.nd.se2018.homework.hwk1;
+import java.util.*;
 
 public class Question2 {
 
 	public Question2(){}
 
 	public String getMostFrequentWord(String input, String stopwords){
-		return "";
+		HashMap<String, Integer> map = new HashMap<>();
+		Set<String> set = new HashSet<String>();
+		for (String stop : stopwords.split(" ")) {
+			if (!set.contains(stop)) {
+				set.add(stop);
+			}
+		}
+		for (String word : input.split(" ")) {
+			if (map.containsKey(word)) {
+				Integer n = map.get(word);
+				map.put(word, n + 1);
+			}
+			else {
+				if (!set.contains(word)) {
+					map.put(word, 1);
+				}
+			}
+		}
+		int max = 0;
+		String word = "";
+		Boolean duplicate = false;
+		for (Map.Entry<String, Integer> w : map.entrySet()) {
+			if (w.getValue() > max) {
+				max = w.getValue();
+				duplicate = false;
+				word = w.getKey();
+			}
+			else if (w.getValue() == max) {
+				duplicate = true;
+			}	
+		}
+		if (duplicate == false) {
+			return word;	
+		}
+		else {
+			return null;
+		}
 	}
+
+	public static void main(String[] args) {
+		String inputString2 = "giraffe elephant giraffe tiger tiger";
+		String stopWords = "and a hes the of up but with";
+		Question2 mostFrequentWord = new Question2();
+		String result = mostFrequentWord.getMostFrequentWord(inputString2, stopWords);
+		System.out.println("The answer is:" + result);
+	}
+
 }

src/edu/nd/se2018/homework/hwk1/Question3.java

@@ -4,6 +4,31 @@ public class Question3 {
 	public Question3(){}	
 
     public int getMirrorCount(int[] numbers){
-		return 0;	
+    	if (numbers.length == 0) {
+    		return 0;
+    	}
+    	int count = 0;
+    	for (int i = 0; i < numbers.length; i++) {
+    		int num = (numbers.length) - 1 - i;
+
+    		if (numbers[i] == numbers[num]) {
+    			count++;
+    		}
+    		else {
+    			count = 0;
+    		}
+    	}
+    	if (count == 0) {
+    		return 1;
+    	}
+    	else {
+    		return count;
+    	}
+	}
+
+    public static void main(String[] args) {
+		Question3 mirrorCount = new Question3();
+		int result = mirrorCount.getMirrorCount(new int[] {1,2,3,4,5});
+		System.out.println("The answer is:" + result);
 	}
 }

src/edu/nd/se2018/homework/hwk2/EarlySprint.java

@@ -0,0 +1,20 @@
+package edu.nd.se2018.homework.hwk2;
+
+public class EarlySprint implements RaceStrategy {
+	@Override
+	public double runStrategy(double position, double maxSpeed) {
+		double p;
+		if (position <= 2) {
+			p = position + maxSpeed;
+		}
+		else if (position < 10) {
+			p = position + (0.75 * maxSpeed);
+		}
+		else {
+			p = 10;
+		}
+		return p;
+
+	}
+
+}

src/edu/nd/se2018/homework/hwk2/Horse.java

@@ -0,0 +1,46 @@
+package edu.nd.se2018.homework.hwk2;
+import java.text.DecimalFormat;
+
+import edu.nd.se2018.homework.hwk2.RaceStrategy;
+
+public class Horse {
+	private static DecimalFormat df2 = new DecimalFormat(".##");
+
+	RaceStrategy raceStrategy;
+	public String name;
+	public int number;
+	public double position;
+	public double maxSpeed;
+
+	public Horse(RaceStrategy strategy, String n, int num, double p, double s) {
+		this.raceStrategy = strategy;
+		this.name = n;
+		this.number = num;
+		this.position = p;
+		this.maxSpeed = s;
+	}
+
+	public void run() {
+		double p = raceStrategy.runStrategy(this.position, this.maxSpeed);
+		this.position = p;
+	}
+
+	public void setStrategy(RaceStrategy strategy) {
+		this.raceStrategy = strategy;
+
+	}
+
+	public boolean done() {
+		if (position >= 10) {
+			return true;
+		}
+		else {
+			return false;
+		}
+	}
+
+	public void display() {
+		System.out.println(name + " is at position: " + df2.format(position));
+	}
+
+}

src/edu/nd/se2018/homework/hwk2/Main.java

@@ -0,0 +1,15 @@
+package edu.nd.se2018.homework.hwk2;
+
+public class Main {
+
+	public static void main(String[] args) {
+		Race race = new Race();
+		race.enrollHorse(new SteadyRun(), "Joe", 1, 0, 1);
+		race.enrollHorse(new EarlySprint(), "Mary", 2, 0, 1);
+		race.enrollHorse(new SlowStart(), "Spirit", 3, 0, 1);
+		race.enrollHorse(new EarlySprint(), "DingDing", 4, 0, 1);
+		race.enrollHorse(new SlowStart(), "Kelly", 5, 0, 1);
+		race.run();
+
+	}
+}

src/edu/nd/se2018/homework/hwk2/Race.java

@@ -0,0 +1,33 @@
+package edu.nd.se2018.homework.hwk2;
+
+public class Race {
+	public  Horse[] horseArray = new Horse[5];
+	public int count = 0;
+	int miles = 10;
+	boolean done = false;
+	String winner = "";
+
+	public void enrollHorse(RaceStrategy rs, String n, int num, double p, double ms) {
+		this.horseArray[this.count] = new Horse(rs, n, num, p, ms);
+		this.count = this.count + 1;
+
+	}
+
+	public Race() {}
+
+	public void run() {
+		while (!done) {
+			for (int i = 0; i < this.count; i++ ) {
+				this.horseArray[i].run();
+				this.horseArray[i].display();
+				if (this.horseArray[i].done()) {
+					winner = this.horseArray[i].name;
+					done = true;
+				}
+			}
+		}
+		System.out.println("The winner is: " + winner);
+	}
+
+
+}

src/edu/nd/se2018/homework/hwk2/RaceStrategy.java

@@ -0,0 +1,6 @@
+package edu.nd.se2018.homework.hwk2;
+
+public interface RaceStrategy {
+	public double runStrategy(double position, double maxSpeed);
+
+}

src/edu/nd/se2018/homework/hwk2/RaceTest.java

@@ -0,0 +1,36 @@
+package edu.nd.se2018.homework.hwk2;
+import org.junit.Test;
+
+public class RaceTest {
+	@Test
+	public void test() { 	// Same strategies, different max speeds
+		Race race = new Race();
+		race.enrollHorse(new SteadyRun(), "A1", 1, 0, 1);
+		race.enrollHorse(new SteadyRun(), "B1", 2, 0, 1.2);
+		race.enrollHorse(new SteadyRun(), "C1", 3, 0, 1.4);
+		race.run();
+		assert(race.winner == "C1");
+	}
+
+	@Test
+	public void test2() { 	// Same strategies, different max speeds
+		Race race2 = new Race();
+		race2.enrollHorse(new SteadyRun(), "A2", 1, 0, 1);
+		race2.enrollHorse(new EarlySprint(), "B2", 1, 0, 1);
+		race2.enrollHorse(new SlowStart(), "C2", 3, 0, 1);
+		race2.run();
+		assert(race2.winner == "C2");
+	}
+
+	@Test
+	public void test3() {
+		Race race3 = new Race();
+		race3.enrollHorse(new SteadyRun(), "A3", 1, 0, 2);
+		race3.enrollHorse(new SlowStart(), "B3", 2, 0, 1);
+		race3.enrollHorse(new EarlySprint(), "C3", 3, 0, 1.1);
+		race3.enrollHorse(new SlowStart(), "D3", 4, 0, 0.8);
+		race3.enrollHorse(new SteadyRun(), "E3", 5, 0, 0.9);
+		race3.run();
+		assert(race3.winner == "A3");
+	}
+}

src/edu/nd/se2018/homework/hwk2/SlowStart.java

@@ -0,0 +1,21 @@
+package edu.nd.se2018.homework.hwk2;
+
+public class SlowStart implements RaceStrategy {
+	public double runStrategy(double position, double maxSpeed) {
+		double p = position;
+		if (position <= 6) {
+			p = position + (0.75 * maxSpeed);
+		}
+		else if (position <= 1) {
+			p = position + (0.9 * maxSpeed);
+		}
+		else if (position < 10){
+			p = position + maxSpeed;
+		}
+		else {
+			position = 10;
+		}
+		return p;	
+	}
+
+}

src/edu/nd/se2018/homework/hwk2/SteadyRun.java

@@ -0,0 +1,15 @@
+package edu.nd.se2018.homework.hwk2;
+
+public class SteadyRun implements RaceStrategy {
+	public double runStrategy(double position, double maxSpeed) {
+		double p;
+		if (position < 10) {
+			p = position + (0.8 * maxSpeed);
+		}
+		else {
+			p = 10;
+		}
+		return p;		
+	}
+
+}

src/edu/nd/se2018/homework/hwk3/.classpath

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

src/edu/nd/se2018/homework/hwk3/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>hwk3</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>