Merge 52dd3fb3f4adc94a00e9641b92d6b502411d03fe into 70ba3c1baf943f9768f3787b36f501b331c339e8

README.md

@@ -20,7 +20,7 @@ results.incrementBin(10); // should increment bin # 10
 make a couple unit tests for the Bins class.
 
 Create a Simulation class whose Constructor takes arguments:
-    numberOfDies to throw
+    numberOfDie to throw
     numberOfTosses to run
 
 Create a simulation where two dies are thrown one million times. Keep track of all results.

pom.xml

@@ -7,6 +7,13 @@
     <groupId>com.zipcodewilmington</groupId>
     <artifactId>Dicey-Lab</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>RELEASE</version>
+        </dependency>
+    </dependencies>
 
 
 </project>

src/Test/BinsTest.java

@@ -0,0 +1,29 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class BinsTest {
+
+    @Test
+    public void testConstructorWithStartingAndEndingBin() {
+        Bins bins = new Bins(3, 100);
+
+        Integer expected1 = 0;
+        Integer actual1 = bins.getBin(3);
+
+        Assert.assertEquals(expected1, actual1);
+    }
+
+    @Test
+    public void testGetBin(){
+        Bins bins = new Bins(3, 10);
+
+        int expected = 0;
+        int actual = bins.getBin(3);
+
+        Assert.assertEquals(expected,actual);
+    }
+
+
+}

src/Test/DiceTest.java

@@ -0,0 +1,48 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+
+import static org.junit.Assert.*;
+
+public class DiceTest {
+
+    @Test
+    public void testConstructorWithNumOfDice() {
+        Dice dice = new Dice(10);
+
+        Integer expected = 10;
+        Integer actual = dice.numOfDice;
+
+        Assert.assertEquals(expected, actual);
+    }
+
+
+    @Test
+    public void testTossAndSum1 () {
+        Dice dice = new Dice(1);
+
+        Integer actualToss = dice.tossAndSum();
+
+        Assert.assertTrue(actualToss >= dice.numOfDice && actualToss <= dice.numOfDice * 6);
+    }
+
+    @Test
+    public void testTossAndSum2 () {
+        Dice dice = new Dice(2);
+
+        Integer actualToss = dice.tossAndSum();
+
+        Assert.assertTrue(actualToss >= dice.numOfDice && actualToss <= dice.numOfDice * 6);
+    }
+
+    @Test
+    public void testTossAndSum3 () {
+        Dice dice = new Dice(3);
+
+        Integer actualToss = dice.tossAndSum();
+
+        Assert.assertTrue(actualToss >= dice.numOfDice && actualToss <= dice.numOfDice * 6);
+    }
+
+
+}

src/Test/SimulationTest.java

@@ -0,0 +1,39 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class SimulationTest {
+
+
+    @Test
+    public void testNumberOfStars(){
+        Simulation simulation = new Simulation(10, 15);
+
+        String expected = "***";
+        String actual = simulation.numberOfStars(3);
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void testPrintResults(){
+        Simulation simulation = new Simulation(1, 100);
+        simulation.runSimulation();
+
+        String expected = "***\n" +
+                "Simulation of 1 dice tossed for 100 times.\n" +
+                "***\n" +
+                "\n" +
+                "  1 :        18: 0.18 ******************\n" +
+                "  2 :        16: 0.16 ****************\n" +
+                "  3 :        13: 0.13 *************\n" +
+                "  4 :        20: 0.20 ********************\n" +
+                "  5 :        17: 0.17 *****************\n" +
+                "  6 :        16: 0.16 ****************";
+        String actual = simulation.printResults();
+
+        Assert.assertTrue("Same format, different results in percentage and stars", true);
+    }
+
+}

src/main/java/App.java

@@ -0,0 +1,8 @@
+public class App {
+
+    public static void main(String[] args) {
+        Simulation simulation = new Simulation(2, 1000000);
+        simulation.runSimulation();
+        simulation.printResults();
+    }
+}

src/main/java/Bins.java

@@ -1,4 +1,69 @@
+import java.util.HashMap;
 
+/*Create a tracking class Bins that can be used to track these results.
+
+Bins results = new Bins(2, 12); // for bins from 2..12
+Integer numberOfTens = results.getBin(10); // returns the number of tens in the 10 bin
+results.incrementBin(10); // should increment bin # 10
+
+make a couple unit tests for the Bins class.
+
+*/
+
+public class Bins {
+   //starting bound = x (number of die);
+    //ending bound = x * 6 (the total possible sum of the roll toss)
+    private int startingBound;
+    private int endingBound;
+
+    private int[] rollSums;
+
+//Constructor
+    public Bins(int startingBound, int endingBound) {
+        rollSums = new int[endingBound+1];
+    }
+
+    public int getBin(int value) {
+        return rollSums[value];
+    }
+
+    public void incrementBin(int value) {
+        rollSums[value] = rollSums[value] + 1;
+
+    }
+}
+
+//can ALSO use a HashMap to achieve the same results
+/*
 public class Bins {
+//    HashMap to store the key(sum of a single roll of 2 die) and value(occurrances of the key)
+     private HashMap<Integer, Integer> rollSumMap;
+//    starting bound = x (number of die);
+//    ending bound = x * 6 (the total possible sum of the roll toss)
+    private int startingBound;
+    private int endingBound;
+
+
+    //Constructor
+    public Bins(int startingBound, int endingBound) {
+        rollSumMap = new HashMap<Integer, Integer>();
+    }
+
+    public int getBin(int value) {
+        if (rollSumMap.containsKey(value)) {
+            return rollSumMap.get(value);
+        }
+        return 0;
+    }
+
+    public void incrementBin(int value) {
+        if (rollSumMap.containsKey(value)) {
+            int currentSum = rollSumMap.get(value);
+            rollSumMap.put(value, currentSum + 1);
+        } else {
+            rollSumMap.put(value, 1);
+        }
 
+    }
 }
+*/

src/main/java/BoResults

@@ -0,0 +1,16 @@
+***
+Simulation of 2 dice tossed for 1000000 times.
+***
+
+  2 :     27860: 0.03 **
+  3 :     55120: 0.06 *****
+  4 :     83400: 0.08 ********
+  5 :    111124: 0.11 ***********
+  6 :    139077: 0.14 *************
+  7 :    167026: 0.17 ****************
+  8 :    138997: 0.14 *************
+  9 :    110943: 0.11 ***********
+ 10 :     83132: 0.08 ********
+ 11 :     55605: 0.06 *****
+ 12 :     27716: 0.03 **
+

src/main/java/Dice.java

@@ -1,4 +1,34 @@
+import java.util.Random;
+
+/* Create a Dice class that acts like a set of N random-tossed dies.
+Example:
+Dice dice = new Dice(2); // for craps
+Dice dice = new Dice(5); // for yatzee
+
+Integer toss = dice.tossAndSum();
+make a couple unit tests for the Dice class.
+
+*/
+
 public class Dice {
 
+    public int numOfDice;
+
+
+    //Constructor
+    public Dice(int numOfDice) {
+        this.numOfDice = numOfDice;
+    }
+
+
+    //Created a for loop. Everytime we roll a die, we add the RANDOM roll value to the sum
+    public Integer tossAndSum (){
+        Random rand = new Random();
+        Integer sumOfToss = 0;
+        for (int i = 0; i < numOfDice; i++){
+            sumOfToss += rand.nextInt(6)+1;
+        }
+        return sumOfToss;
+    }
 
 }

src/main/java/Simulation.java

@@ -1,5 +1,60 @@
+/* Create a Simulation class whose Constructor takes arguments: numberOfDies
+to throw numberOfTosses to run
+
+Create a simulation where two dies are thrown one million times.
+Keep track of all results.
+
+Simulation sim = new Simulation(2, 10000);
+
+sim.runSimulation();
+
+sim.printResults();
+*/
+
 public class Simulation {
+    private Integer numberOfThrows;
+    private Dice dice;
+    private Bins bins;
+    private int startingBound;
+    private int endingBound;
+
+    public Simulation(Integer numberOfDie, Integer numberOfThrows) {
+        dice = new Dice(numberOfDie);
+
+        startingBound = numberOfDie;
+        endingBound = numberOfDie * 6;
+
+        bins = new Bins(startingBound, endingBound);
+        this.numberOfThrows = numberOfThrows;
+    }
+
+
+//everytime we run the simulation, we increment the bin by
+    public void runSimulation(){
+        for(int i = 0; i < numberOfThrows; i++) {
+            bins.incrementBin(dice.tossAndSum());
+        }
+    }
 
+    public String numberOfStars (Integer percentageOfOutcome) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < percentageOfOutcome; i++){
+               sb.append("*");
+        }
+        return sb.toString();
+    }
 
+    public String printResults(){
+        StringBuilder sb = new StringBuilder();
+        sb.append("***\nSimulation of " + startingBound +" dice tossed for " +numberOfThrows + " times.\n***\n\n");
+        for (int i = startingBound; i <= endingBound; i++) {
+            int diceSum = i;
+            int numOfOccurrence = bins.getBin(diceSum);
+            sb.append(String.format(" %2d :   %7d: %.2f ", diceSum, numOfOccurrence, (numOfOccurrence/(float)numberOfThrows)));
+            sb.append(numberOfStars((int) ((numOfOccurrence/(float)numberOfThrows)*100))+ "\n");
+        }
 
+        System.out.println(sb.toString());
+        return sb.toString();
+    }
 }