Added binary search exercise

config.json

@@ -39,6 +39,7 @@
     "luhn",
     "pig-latin",
     "simple-linked-list",
+    "sum-of-multiples",
     "linked-list",
     "nth-prime",
     "pascals-triangle",
@@ -47,7 +48,11 @@
     "largest-series-product",
     "queen-attack",
     "minesweeper",
+<<<<<<< HEAD
     "binary-search"
+=======
+    "series"
+>>>>>>> upsetream/master
   ],
   "exercises": [
     {
@@ -226,6 +231,11 @@
       "topics": []
     },
     {
+      "slug": "sum-of-multiples",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
       "slug": "linked-list",
       "difficulty": 1,
       "topics": []
@@ -266,6 +276,11 @@
       "topics": []
     },
     {
+      "slug": "series",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
       "slug": "binary-search",
       "difficulty": 1,
       "topics": []

exercises/binary-search/src/example/java/BinarySearch.java

@@ -0,0 +1,70 @@
+
+import java.util.List;
+
+public class BinarySearch<T extends Comparable<T>> {
+
+    public static String ARRAY_MUST_BE_SORTED = "Array should be sorted.";
+
+    private List<T> array;
+    private int arraySize;
+
+    public BinarySearch(List<T> array) {
+        if (!isSorted(array)) {
+            throw new IllegalArgumentException(ARRAY_MUST_BE_SORTED);
+        }
+        this.array = array;
+        this.arraySize = array.size();
+    }
+
+    public int indexOf(T value) {
+        return search(value);
+    }
+
+    public List<T> getArray() {
+        return array;
+    }
+
+    private boolean isSorted(List<T> list) {
+        T previous, next;
+        int listSize;
+
+        if (list == null || list.isEmpty()) {
+            return false;
+        }
+
+        listSize = list.size();
+        if (listSize == 1) {
+            return true;
+        }
+
+        previous = list.get(0);
+        for (int i = 0, n = listSize - 1; i < n; i++) {
+            next = list.get(i + 1);
+            if (previous.compareTo(next) > 0) {
+                return false;
+            }
+            previous = next;
+        }
+        return true;
+    }
+
+    private int search(T value) {
+        int left = 0;
+        int right = this.arraySize - 1;
+        int middle;
+        T element;
+        while (left <= right) {
+            middle = (int) Math.floor(0.5 * (left + right));
+            element = this.array.get(middle);
+            if (value.compareTo(element) > 0) {
+                left = middle + 1;
+            } else if (value.compareTo(element) < 0) {
+                right = middle - 1;
+            } else {
+                return middle;
+            }
+        }
+        return -1;
+    }
+}
+

exercises/binary-search/src/main/java/BinarySearch.java

@@ -0,0 +1,4 @@
+
+public class BinarySearch {
+
+}

exercises/binary-search/src/test/java/BinarySearchTest.java

@@ -0,0 +1,100 @@
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class BinarySearchTest {
+
+    private static final List<Integer> SORTED_LIST
+            = Collections.unmodifiableList(
+                    Arrays.asList(1, 2, 3, 4, 5, 6)
+            );
+
+    public static final List<Integer> SORTED_LIST_OF_ODD_LENGTH
+            = Collections.unmodifiableList(
+                    Arrays.asList(0, 1, 2, 2, 3, 10, 12)
+            );
+
+    public static final List<Integer> UNSORTED_LIST
+            = Collections.unmodifiableList(
+                    Arrays.asList(10, 2, 5, 1)
+            );
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Test
+    public void shouldRequireASortedListOK() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        List<Integer> actual = sut.getArray();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(actual.size(), SORTED_LIST.size());
+        assertEquals(actual, SORTED_LIST);
+    }
+
+    @Ignore
+    @Test
+    public void shouldRequireASortedListButNotSorted() {
+        thrown.expect(IllegalArgumentException.class);
+        thrown.expectMessage(BinarySearch.ARRAY_MUST_BE_SORTED);
+        new BinarySearch<Integer>(UNSORTED_LIST);
+    }
+
+    @Ignore
+    @Test
+    public void shouldFindTheCorrectIndexInTheMiddleOfArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int number = 3;
+        final int actual = sut.indexOf(number);
+        final int expected = 2;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void shouldFindTheCorrectIndexAtTheBeginningOfArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int number = 1;
+        final int actual = sut.indexOf(number);
+        final int expected = 0;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void shouldFindTheCorrectIndexAtTheEndOfArray() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int number = 6;
+        final int actual = sut.indexOf(number);
+        final int expected = 5;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void shouldFindTheCorrectIndexInTheMiddleOfArrayOfOddLength() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST_OF_ODD_LENGTH);
+        final int number = 2;
+        final int actual = sut.indexOf(number);
+        final int expected = 3;
+        assertEquals(expected, actual);
+    }
+
+    @Ignore
+    @Test
+    public void shouldReturnMinusOneIfNotFound() {
+        BinarySearch<Integer> sut = new BinarySearch<>(SORTED_LIST);
+        final int number = 10;
+        final int actual = sut.indexOf(number);
+        final int expected = -1;
+        assertEquals(expected, actual);
+    }
+}

exercises/etl/src/main/java/Etl.java

@@ -2,7 +2,7 @@ import java.util.List;
 import java.util.Map;
 
 public class Etl {
-   public Map<String, Integer> transform(Map<Integer, List<String>> old) {
-      return null;
-   }
+    public Map<String, Integer> transform(Map<Integer, List<String>> old) {
+        return null;
+    }
 }

exercises/hello-world/GETTING_STARTED.md

@@ -20,7 +20,7 @@ $ gradle test
 
 ## Iterate through the tests
 
-After your first test passes, remove the `@Ignore` from the next test, and ierate on your solution,
+After your first test passes, remove the `@Ignore` from the next test, and iterate on your solution,
 testing after each change.
 
 ## All the tests pass?  Submit your solution!

exercises/hello-world/src/main/java/HelloWorld.java

@@ -1,5 +1,5 @@
 public class HelloWorld {
-	public static String hello(String name) {
-      return null;
-	}
+    public static String hello(String name) {
+        return null;
+    }
 }

exercises/nucleotide-count/src/test/java/NucleotideTest.java

@@ -7,87 +7,87 @@ import org.junit.Ignore;
 public class NucleotideTest {
 
     @Test
-  public void testEmptyDnaStringHasNoAdenosine() {
-    DNA dna = new DNA("");
-    assertThat(dna.count('A')).isEqualTo(0);
-  }
+    public void testEmptyDnaStringHasNoAdenosine() {
+        DNA dna = new DNA("");
+        assertThat(dna.count('A')).isEqualTo(0);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testEmptyDnaStringHasNoNucleotides() {
-    DNA dna = new DNA("");
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 0),
-        entry('C', 0),
-        entry('G', 0),
-        entry('T', 0)
-    );
-  }
+    public void testEmptyDnaStringHasNoNucleotides() {
+        DNA dna = new DNA("");
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 0),
+            entry('C', 0),
+            entry('G', 0),
+            entry('T', 0)
+        );
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testRepetitiveCytidineGetsCounted() {
-    DNA dna = new DNA("CCCCC");
-    assertThat(dna.count('C')).isEqualTo(5);
-  }
+    public void testRepetitiveCytidineGetsCounted() {
+        DNA dna = new DNA("CCCCC");
+        assertThat(dna.count('C')).isEqualTo(5);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testRepetitiveSequenceWithOnlyGuanosine() {
-    DNA dna = new DNA("GGGGGGGG");
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 0),
-        entry('C', 0),
-        entry('G', 8),
-        entry('T', 0)
-    );
-  }
+    public void testRepetitiveSequenceWithOnlyGuanosine() {
+        DNA dna = new DNA("GGGGGGGG");
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 0),
+            entry('C', 0),
+            entry('G', 8),
+            entry('T', 0)
+        );
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testCountsOnlyThymidine() {
-    DNA dna = new DNA("GGGGGTAACCCGG");
-    assertThat(dna.count('T')).isEqualTo(1);
-  }
+    public void testCountsOnlyThymidine() {
+        DNA dna = new DNA("GGGGGTAACCCGG");
+        assertThat(dna.count('T')).isEqualTo(1);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testCountsANucleotideOnlyOnce() {
-    DNA dna = new DNA("CGATTGGG");
-    dna.count('T');
-    assertThat(dna.count('T')).isEqualTo(2);
-  }
+    public void testCountsANucleotideOnlyOnce() {
+        DNA dna = new DNA("CGATTGGG");
+        dna.count('T');
+        assertThat(dna.count('T')).isEqualTo(2);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testDnaCountsDoNotChangeAfterCountingAdenosine() {
-    DNA dna = new DNA("GATTACA");
-    dna.count('A');
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 3),
-        entry('C', 1),
-        entry('G', 1),
-        entry('T', 2)
-    );
-  }
+    public void testDnaCountsDoNotChangeAfterCountingAdenosine() {
+        DNA dna = new DNA("GATTACA");
+        dna.count('A');
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 3),
+            entry('C', 1),
+            entry('G', 1),
+            entry('T', 2)
+        );
+    }
 
-  @Ignore
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
-  public void testValidatesNucleotides() {
-    DNA dna = new DNA("GACT");
-    dna.count('X');
-  }
+    public void testValidatesNucleotides() {
+        DNA dna = new DNA("GACT");
+        dna.count('X');
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testCountsAllNucleotides() {
-    String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";
-    DNA dna = new DNA(s);
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 20),
-        entry('C', 12),
-        entry('G', 17),
-        entry('T', 21)
-    );
-  }
+    public void testCountsAllNucleotides() {
+        String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";
+        DNA dna = new DNA(s);
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 20),
+            entry('C', 12),
+            entry('G', 17),
+            entry('T', 21)
+        );
+    }
 }

exercises/series/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+  testCompile "org.assertj:assertj-core:3.2.0"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/series/src/example/java/Series.java

@@ -0,0 +1,39 @@
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Series {
+
+    private final int digitsSize;
+    private List<Integer> digits;
+
+    public Series(String string) {
+        this.digits = Arrays
+                .asList(string.split(("")))
+                .stream()
+                .map(digit -> Integer.parseInt(digit))
+                .collect(Collectors.toList());
+        this.digitsSize = this.digits.size();
+    }
+
+    public List<List<Integer>> slices(int num) {
+        if (num > this.digitsSize) {
+            throw new IllegalArgumentException("Slice size is too big.");
+        }
+        final int limit = this.digitsSize - num + 1;
+        List<List<Integer>> result = new ArrayList<>(limit);
+        List<Integer> tmp;
+        for (int i = 0; i < limit; i++) {
+            tmp = this.digits.subList(i, i + num);
+            result.add(tmp);
+        }
+        return result;
+    }
+
+    public List<Integer> getDigits() {
+        return digits;
+    }
+
+}

exercises/series/src/main/java/Series.java

@@ -0,0 +1,3 @@
+public class Series {
+    
+}

exercises/series/src/test/java/SeriesTest.java

@@ -0,0 +1,154 @@
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import org.junit.Ignore;
+
+public class SeriesTest {
+
+    @Test
+    public void hasDigitsShort() {
+        Series sut = new Series("01234");
+        List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void hasDigitsLong() {
+        Series sut = new Series("0123456789");
+        List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void keepsTheDigitOrderIfReversed() {
+        Series sut = new Series("9876543210");
+        List<Integer> expected = Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void keepsArbitraryDigitOrder() {
+        Series sut = new Series("936923468");
+        List<Integer> expected = Arrays.asList(9, 3, 6, 9, 2, 3, 4, 6, 8);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByOne() {
+        Series sut = new Series("01234");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(0),
+                Arrays.asList(1),
+                Arrays.asList(2),
+                Arrays.asList(3),
+                Arrays.asList(4)
+        );
+        List<List<Integer>> actual = sut.slices(1);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByTwo() {
+        Series sut = new Series("98273463");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(9, 8),
+                Arrays.asList(8, 2),
+                Arrays.asList(2, 7),
+                Arrays.asList(7, 3),
+                Arrays.asList(3, 4),
+                Arrays.asList(4, 6),
+                Arrays.asList(6, 3)
+        );
+        List<List<Integer>> actual = sut.slices(2);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByThree() {
+        Series sut = new Series("01234");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(0, 1, 2),
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(2, 3, 4)
+        );
+        List<List<Integer>> actual = sut.slices(3);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByThreeWithDuplicateDigits() {
+        Series sut = new Series("31001");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(3, 1, 0),
+                Arrays.asList(1, 0, 0),
+                Arrays.asList(0, 0, 1)
+        );
+        List<List<Integer>> actual = sut.slices(3);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByFour() {
+        Series sut = new Series("91274");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(9, 1, 2, 7),
+                Arrays.asList(1, 2, 7, 4)
+        );
+        List<List<Integer>> actual = sut.slices(4);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByFive() {
+        Series sut = new Series("81228");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(8, 1, 2, 2, 8)
+        );
+        List<List<Integer>> actual = sut.slices(5);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    @Ignore
+    public void throwsAnErrorIfNotEnoughDigitsToSlice() {
+        new Series("01032987583").slices(12);
+    }
+}

exercises/settings.gradle

@@ -34,9 +34,11 @@ include 'robot-name'
 include 'roman-numerals'
 include 'prime-factors'
 include 'scrabble-score'
+include 'series'
 include 'sieve'
 include 'simple-cipher'
 include 'simple-linked-list'
+include 'sum-of-multiples'
 include 'space-age'
 include 'strain'
 include 'triangle'

exercises/sum-of-multiples/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/sum-of-multiples/src/example/java/SumOfMultiples.java

@@ -0,0 +1,27 @@
+import java.util.Arrays;
+public class SumOfMultiples {
+    
+    
+    public int Sum(int number, int[] set) {
+        
+        int sum = 0;
+        int count = 0;
+        
+        for (int i = 1; i < number; i++) {
+            
+            for (int j = 0; j < set.length; j++) {
+                if (i % set[j] == 0) {
+                    count++;
+                }
+            }
+            
+            if (count > 0) {
+                sum = sum + i;
+                count = 0;
+            }
+        }
+        
+        return sum;
+    }
+    
+}

exercises/sum-of-multiples/src/main/java/SumOfMultiples.java

@@ -0,0 +1,4 @@
+import java.util.Arrays;
+public class SumOfMultiples {
+    
+}

exercises/sum-of-multiples/src/test/SumOfMultiplesTest.java

@@ -0,0 +1,187 @@
+import static org.junit.Assert.*;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+public class SumOfMultiplesTest {
+    
+    
+    @Test
+    public void testSumOfMultiplesOf3and4UpToOne() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(1, set);
+        assertEquals(0, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToFour() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(4, set);
+        assertEquals(3, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToTen() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(10, set);
+        assertEquals(23, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToOneHundred() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(100, set);
+        assertEquals(2318, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf3and5UpToOneThousand() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            3,
+            5
+        };
+        int output = mySum.Sum(1000, set);
+        assertEquals(233168, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf7and13and17UpToTwenty() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            7,
+            13,
+            17
+        };
+        int output = mySum.Sum(20, set);
+        assertEquals(51, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf4and6UpToFifteen() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            4,
+            6
+        };
+        int output = mySum.Sum(15, set);
+        assertEquals(30, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf5and6and8UpToOneHundredFifty() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            5,
+            6,
+            8
+        };
+        int output = mySum.Sum(150, set);
+        assertEquals(4419, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf5and25UpToTwoHundredSeventyFive() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            5,
+            25
+        };
+        int output = mySum.Sum(51, set);
+        assertEquals(275, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOf43and47UpToTenThousand() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            43,
+            47
+        };
+        int output = mySum.Sum(10000, set);
+        assertEquals(2203160, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOfOneUpToOneHundred() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {
+            1
+        };
+        int output = mySum.Sum(100, set);
+        assertEquals(4950, output);
+        
+    }
+    
+    
+    @Test
+    @Ignore
+    public void testSumOfMultiplesOfNoneUpToTenThousand() {
+        
+        SumOfMultiples mySum = new SumOfMultiples();
+        int[] set = {};
+        int output = mySum.Sum(10000, set);
+        assertEquals(0, output);
+        
+    }
+    
+    
+    
+}