浏览代码

simulation complete. all tests passing

Amy Gill 6 年前
父节点
当前提交
98703de122

+ 14
- 0
src/main/java/ArrayListCombiner/ArrayListCombiner.java 查看文件

@@ -1,5 +1,7 @@
1 1
 package ArrayListCombiner;
2 2
 
3
+import Table.Entry;
4
+
3 5
 import java.util.ArrayList;
4 6
 
5 7
 /**
@@ -9,4 +11,16 @@ import java.util.ArrayList;
9 11
  * The second method should be called superCombiner and should use ? super E
10 12
  */
11 13
 public class ArrayListCombiner {
14
+
15
+    public static <E> ArrayList extendCombiner(ArrayList <E> firstArray, ArrayList <? extends E> secondArray){
16
+        firstArray.addAll(secondArray);
17
+        return firstArray;
18
+
19
+    }
20
+
21
+    public static <E> ArrayList superCombiner(ArrayList <? super E> firstArray, ArrayList <E> secondArray){
22
+        firstArray.addAll(secondArray);
23
+        return firstArray;
24
+
25
+    }
12 26
 }

+ 10
- 0
src/main/java/MapFunc/MapFunc.java 查看文件

@@ -9,4 +9,14 @@ import java.util.function.Function;
9 9
  */
10 10
 public class MapFunc {
11 11
 
12
+    // in this case, T is input and R is output
13
+    public static <T, R> ArrayList<R> map(ArrayList<T> myInput, Function<T,R> myFunc){
14
+        ArrayList<R> output = new ArrayList<>();
15
+        for (T element : myInput){
16
+            output.add(myFunc.apply(element));
17
+        }
18
+        return output;
19
+
20
+    }
21
+
12 22
 }

+ 52
- 16
src/main/java/Pair/Arrays.java 查看文件

@@ -1,16 +1,52 @@
1
-//package Pair;
2
-//
3
-//import java.util.ArrayList;
4
-//import java.util.Collections;
5
-//
6
-///**
7
-// * In here you must make firstLast, which will return a pair of the first element in the array list and the last
8
-// * element in the arraylist.
9
-// * You must also make a min method that returns the smallest item in the array list
10
-// * A max method that returns the largest item in the arraylist
11
-// * And a minmax method that returns a pair containing the largest and smallest items from the array list
12
-// */
13
-//public class Arrays {
14
-//    public static <___> Pair<E> firstLast(ArrayList<___> a) {
15
-//    }
16
-//}
1
+package Pair;
2
+
3
+import java.util.ArrayList;
4
+import java.util.Collections;
5
+import java.util.Comparator;
6
+
7
+/**
8
+ * In here you must make firstLast, which will return a pair of the first element in the array list and the last
9
+ * element in the arraylist.
10
+ * You must also make a min method that returns the smallest item in the array list
11
+ * A max method that returns the largest item in the arraylist
12
+ * And a minmax method that returns a pair containing the largest and smallest items from the array list
13
+ */
14
+public class Arrays<E extends Comparable> {
15
+    public static <E extends Comparable> Pair<E> firstLast(ArrayList<E> arrayList) {
16
+       E firstItem = arrayList.get(0);
17
+       E lastItem = arrayList.get(arrayList.size()-1);
18
+
19
+       Pair<E> answer= new Pair<>(firstItem,lastItem);
20
+
21
+       return answer;
22
+
23
+    }
24
+
25
+    public static <E extends Comparable> E min (ArrayList<E> arrayList) {
26
+        arrayList.sort(Comparator.naturalOrder());
27
+        E minItem = arrayList.get(0);
28
+
29
+        return minItem;
30
+
31
+    }
32
+
33
+    public static <E extends Comparable> E max (ArrayList<E> arrayList) {
34
+        arrayList.sort(Comparator.naturalOrder());
35
+        E maxItem = arrayList.get(arrayList.size()-1);
36
+
37
+        return maxItem;
38
+
39
+
40
+    }
41
+
42
+    public static <E extends Comparable> Pair<E> minMax (ArrayList<E> arrayList) {
43
+        arrayList.sort(Comparator.naturalOrder());
44
+
45
+        Pair <E> answer = new Pair(arrayList.get(0), arrayList.get(arrayList.size()-1));
46
+
47
+        return answer;
48
+
49
+    }
50
+
51
+
52
+}

+ 34
- 1
src/main/java/Pair/Pair.java 查看文件

@@ -7,6 +7,39 @@ package Pair;
7 7
  * min -> returns the minimum of the pair
8 8
  * max -> returns the maximum of the pair
9 9
  */
10
-public class Pair {
10
+public class Pair<E extends Comparable> {
11
+
12
+    E firstVal;
13
+    E secondVal;
14
+
15
+    public Pair(E firstVal, E secondVal){
16
+        this.firstVal=firstVal;
17
+        this.secondVal=secondVal;
18
+    }
19
+
20
+    public E getFirst(){
21
+        return firstVal;
22
+    }
23
+
24
+    public E getSecond(){
25
+        return secondVal;
26
+    }
27
+
28
+    public E min(){
29
+
30
+        E smallerOfTwo;
31
+        smallerOfTwo= firstVal.compareTo(secondVal) == 1 ? secondVal:firstVal;
32
+
33
+        return smallerOfTwo;
34
+    }
35
+
36
+    public E max(){
37
+
38
+        E largerOfTwo;
39
+        largerOfTwo= firstVal.compareTo(secondVal) == 1 ? firstVal:secondVal;
40
+
41
+        return largerOfTwo;
42
+
43
+    }
11 44
 
12 45
 }

+ 35
- 35
src/test/java/ArrayListCombiner/ArrayListCombinerTest.java 查看文件

@@ -9,40 +9,40 @@ import org.junit.Assert;
9 9
 import java.util.ArrayList;
10 10
 
11 11
 public class ArrayListCombinerTest {
12
-//    Employee foo = new Employee("FOO", 100);
13
-//    Manager bar = new Manager("BAR", 100);
14
-//    @Test
15
-//    public void testExtendCombiner() throws Exception {
16
-//        // Given an array list with employees
17
-//        ArrayList<Employee> first = new ArrayList<>();
18
-//        first.add(foo);
19
-//        // An an array list with managers
20
-//        ArrayList<Manager> second = new ArrayList<>();
21
-//        second.add(bar);
22
-//        // When  I combine them
23
-//        ArrayListCombiner.extendCombiner(first, second);
24
-//        // Then I should get an arrayList with both
25
-//        ArrayList<Employee> expected = new ArrayList<>();
26
-//        expected.add(foo);
27
-//        expected.add(bar);
28
-//        Assert.assertEquals(expected, first);
29
-//    }
30
-//
31
-//    @Test
32
-//    public void testSuperCombiner() throws Exception {
33
-//        // Given an array list with employees
34
-//        ArrayList<Employee> first = new ArrayList<>();
35
-//        first.add(foo);
36
-//        // An an array list with managers
37
-//        ArrayList<Manager> second = new ArrayList<>();
38
-//        second.add(bar);
39
-//        // When  I combine them
40
-//        ArrayListCombiner.superCombiner(first, second);
41
-//        // Then I should get an arrayList with both
42
-//        ArrayList<Employee> expected = new ArrayList<>();
43
-//        expected.add(foo);
44
-//        expected.add(bar);
45
-//        Assert.assertEquals(expected, first);
46
-//    }
12
+    Employee foo = new Employee("FOO", 100);
13
+    Manager bar = new Manager("BAR", 100);
14
+    @Test
15
+    public void testExtendCombiner() throws Exception {
16
+        // Given an array list with employees
17
+        ArrayList<Employee> first = new ArrayList<>();
18
+        first.add(foo);
19
+        // An an array list with managers
20
+        ArrayList<Manager> second = new ArrayList<>();
21
+        second.add(bar);
22
+        // When  I combine them
23
+        ArrayListCombiner.extendCombiner(first, second);
24
+        // Then I should get an arrayList with both
25
+        ArrayList<Employee> expected = new ArrayList<>();
26
+        expected.add(foo);
27
+        expected.add(bar);
28
+        Assert.assertEquals(expected, first);
29
+    }
30
+
31
+    @Test
32
+    public void testSuperCombiner() throws Exception {
33
+        // Given an array list with employees
34
+        ArrayList<Employee> first = new ArrayList<>();
35
+        first.add(foo);
36
+        // An an array list with managers
37
+        ArrayList<Manager> second = new ArrayList<>();
38
+        second.add(bar);
39
+        // When  I combine them
40
+        ArrayListCombiner.superCombiner(first, second);
41
+        // Then I should get an arrayList with both
42
+        ArrayList<Employee> expected = new ArrayList<>();
43
+        expected.add(foo);
44
+        expected.add(bar);
45
+        Assert.assertEquals(expected, first);
46
+    }
47 47
 
48 48
 }

+ 36
- 36
src/test/java/MapFunc/MapFuncTest.java 查看文件

@@ -1,36 +1,36 @@
1
-//package MapFunc;
2
-//
3
-//import MapFunc.MapFunc;
4
-//import org.junit.Test;
5
-//
6
-//import java.util.ArrayList;
7
-//import org.junit.Assert;
8
-//
9
-//public class MapFuncTest {
10
-//    @Test
11
-//    public void testSingleTypeMap() throws Exception {
12
-//        // Given an integer array list
13
-//        ArrayList<Integer> intList = new ArrayList<>();
14
-//        intList.add(1);
15
-//        intList.add(2);
16
-//        // When it's mapped with a function to double the value
17
-//        ArrayList<Integer> mappedList = MapFunc.map(intList, num -> num*2);
18
-//        // Then all the values are doubled
19
-//        Assert.assertEquals(new Integer(2), mappedList.get(0));
20
-//        Assert.assertEquals(new Integer(4), mappedList.get(1));
21
-//    }
22
-//
23
-//    @Test
24
-//    public void testMultipleTypeMap() throws Exception {
25
-//        // Given an integer array list
26
-//        ArrayList<Integer> intList = new ArrayList<>();
27
-//        intList.add(1);
28
-//        intList.add(2);
29
-//        // When it's mapped with to string
30
-//        ArrayList<String> mappedList = MapFunc.map(intList, num -> num.toString());
31
-//        // Then all the values are doubled
32
-//        Assert.assertEquals("1", mappedList.get(0));
33
-//        Assert.assertEquals("2", mappedList.get(1));
34
-//    }
35
-//
36
-//}
1
+package MapFunc;
2
+
3
+import MapFunc.MapFunc;
4
+import org.junit.Test;
5
+
6
+import java.util.ArrayList;
7
+import org.junit.Assert;
8
+
9
+public class MapFuncTest {
10
+    @Test
11
+    public void testSingleTypeMap() throws Exception {
12
+        // Given an integer array list
13
+        ArrayList<Integer> intList = new ArrayList<>();
14
+        intList.add(1);
15
+        intList.add(2);
16
+        // When it's mapped with a function to double the value
17
+        ArrayList<Integer> mappedList = MapFunc.map(intList, num -> num*2);
18
+        // Then all the values are doubled
19
+        Assert.assertEquals(new Integer(2), mappedList.get(0));
20
+        Assert.assertEquals(new Integer(4), mappedList.get(1));
21
+    }
22
+
23
+    @Test
24
+    public void testMultipleTypeMap() throws Exception {
25
+        // Given an integer array list
26
+        ArrayList<Integer> intList = new ArrayList<>();
27
+        intList.add(1);
28
+        intList.add(2);
29
+        // When it's mapped with to string
30
+        ArrayList<String> mappedList = MapFunc.map(intList, num -> num.toString());
31
+        // Then all the values are doubled
32
+        Assert.assertEquals("1", mappedList.get(0));
33
+        Assert.assertEquals("2", mappedList.get(1));
34
+    }
35
+
36
+}

+ 74
- 74
src/test/java/Pair/ArraysTest.java 查看文件

@@ -1,74 +1,74 @@
1
-//package Pair;
2
-//
3
-//import org.junit.Assert;
4
-//import org.junit.Test;
5
-//
6
-//import java.util.ArrayList;
7
-//
8
-//public class ArraysTest {
9
-//    @Test
10
-//    public void firstLast() throws Exception {
11
-//        // Given an ArrayList of Integers
12
-//        ArrayList<Integer> al = new ArrayList<>();
13
-//        al.add(1);
14
-//        al.add(5);
15
-//        al.add(3);
16
-//        al.add(4);
17
-//        al.add(2);
18
-//        al.add(0);
19
-//        al.add(1000);
20
-//        // When firstLast is called
21
-//        Pair<Integer> result = Arrays.firstLast(al);
22
-//        // Then it should return the first and last items
23
-//        Assert.assertEquals(new Integer(1), result.getFirst());
24
-//        Assert.assertEquals(new Integer(1000), result.getSecond());
25
-//    }
26
-//
27
-//    @Test
28
-//    public void testMin() throws Exception {
29
-//        // Given an ArrayList of Integers
30
-//        ArrayList<Integer> al = new ArrayList<>();
31
-//        al.add(1);
32
-//        al.add(5);
33
-//        al.add(3);
34
-//        al.add(4);
35
-//        al.add(2);
36
-//        al.add(0);
37
-//        al.add(1000);
38
-//        // When min is called assert that it gets the smallest item
39
-//        Assert.assertEquals(new Integer(0), Arrays.min(al));
40
-//    }
41
-//
42
-//    @Test
43
-//    public void testMax() throws Exception {
44
-//        // Given an ArrayList of Integers
45
-//        ArrayList<Integer> al = new ArrayList<>();
46
-//        al.add(1);
47
-//        al.add(5);
48
-//        al.add(3);
49
-//        al.add(4);
50
-//        al.add(2);
51
-//        al.add(0);
52
-//        al.add(1000);
53
-//        // When min is called assert that it gets the largest item
54
-//        Assert.assertEquals(new Integer(1000), Arrays.max(al));
55
-//    }
56
-//
57
-//    @Test
58
-//    public void testMinMax() throws Exception {
59
-//        // Given an ArrayList of Integers
60
-//        ArrayList<Integer> al = new ArrayList<>();
61
-//        al.add(1);
62
-//        al.add(5);
63
-//        al.add(3);
64
-//        al.add(4);
65
-//        al.add(2);
66
-//        al.add(0);
67
-//        al.add(1000);
68
-//        // When minMax is called
69
-//        Pair<Integer> result = Arrays.minMax(al);
70
-//        // Then it should return the first and last items
71
-//        Assert.assertEquals(new Integer(0), result.min());
72
-//        Assert.assertEquals(new Integer(1000), result.max());
73
-//    }
74
-//}
1
+package Pair;
2
+
3
+import org.junit.Assert;
4
+import org.junit.Test;
5
+
6
+import java.util.ArrayList;
7
+
8
+public class ArraysTest {
9
+    @Test
10
+    public void firstLast() throws Exception {
11
+        // Given an ArrayList of Integers
12
+        ArrayList<Integer> al = new ArrayList<>();
13
+        al.add(1);
14
+        al.add(5);
15
+        al.add(3);
16
+        al.add(4);
17
+        al.add(2);
18
+        al.add(0);
19
+        al.add(1000);
20
+        // When firstLast is called
21
+        Pair<Integer> result = Arrays.firstLast(al);
22
+        // Then it should return the first and last items
23
+        Assert.assertEquals(new Integer(1), result.getFirst());
24
+        Assert.assertEquals(new Integer(1000), result.getSecond());
25
+    }
26
+
27
+    @Test
28
+    public void testMin() throws Exception {
29
+        // Given an ArrayList of Integers
30
+        ArrayList<Integer> al = new ArrayList<>();
31
+        al.add(1);
32
+        al.add(5);
33
+        al.add(3);
34
+        al.add(4);
35
+        al.add(2);
36
+        al.add(0);
37
+        al.add(1000);
38
+        // When min is called assert that it gets the smallest item
39
+        Assert.assertEquals(new Integer(0), Arrays.min(al));
40
+    }
41
+
42
+    @Test
43
+    public void testMax() throws Exception {
44
+        // Given an ArrayList of Integers
45
+        ArrayList<Integer> al = new ArrayList<>();
46
+        al.add(1);
47
+        al.add(5);
48
+        al.add(3);
49
+        al.add(4);
50
+        al.add(2);
51
+        al.add(0);
52
+        al.add(1000);
53
+        // When min is called assert that it gets the largest item
54
+        Assert.assertEquals(new Integer(1000), Arrays.max(al));
55
+    }
56
+
57
+    @Test
58
+    public void testMinMax() throws Exception {
59
+        // Given an ArrayList of Integers
60
+        ArrayList<Integer> al = new ArrayList<>();
61
+        al.add(1);
62
+        al.add(5);
63
+        al.add(3);
64
+        al.add(4);
65
+        al.add(2);
66
+        al.add(0);
67
+        al.add(1000);
68
+        // When minMax is called
69
+        Pair<Integer> result = Arrays.minMax(al);
70
+        // Then it should return the first and last items
71
+        Assert.assertEquals(new Integer(0), result.min());
72
+        Assert.assertEquals(new Integer(1000), result.max());
73
+    }
74
+}

+ 32
- 32
src/test/java/Pair/PairTest.java 查看文件

@@ -1,32 +1,32 @@
1
-//package Pair;
2
-//
3
-//import org.junit.Test;
4
-//import org.junit.Assert;
5
-//
6
-//public class PairTest {
7
-//
8
-//    @Test
9
-//    public void testGetters() throws Exception {
10
-//        // Given a pair with "Foo" and "Bar"
11
-//        Pair<String> p = new Pair<String>("Foo", "Bar");
12
-//        // When getFirst and getSecond are called, they should be returned.
13
-//        Assert.assertEquals("Foo", p.getFirst());
14
-//        Assert.assertEquals("Bar",  p.getSecond());
15
-//    }
16
-//
17
-//    @Test
18
-//    public void testMin() throws Exception {
19
-//        // Given a pair with two values
20
-//        Pair<Double> p = new Pair<Double>(1.23, 2.34);
21
-//        // When p.min() is called, the smallest should be returned.
22
-//        Assert.assertEquals(new Double(1.23), p.min());
23
-//    }
24
-//
25
-//    @Test
26
-//    public void testMax() throws Exception {
27
-//        // Given a pair with two values
28
-//        Pair<Double> p = new Pair<Double>(1.23, 2.34);
29
-//        // When p.max() is called, the largest should be returned.
30
-//        Assert.assertEquals(new Double(2.34), p.max());
31
-//    }
32
-//}
1
+package Pair;
2
+
3
+import org.junit.Test;
4
+import org.junit.Assert;
5
+
6
+public class PairTest {
7
+
8
+    @Test
9
+    public void testGetters() throws Exception {
10
+        // Given a pair with "Foo" and "Bar"
11
+        Pair<String> p = new Pair<String>("Foo", "Bar");
12
+        // When getFirst and getSecond are called, they should be returned.
13
+        Assert.assertEquals("Foo", p.getFirst());
14
+        Assert.assertEquals("Bar",  p.getSecond());
15
+    }
16
+
17
+    @Test
18
+    public void testMin() throws Exception {
19
+        // Given a pair with two values
20
+        Pair<Double> p = new Pair<Double>(1.23, 2.34);
21
+        // When p.min() is called, the smallest should be returned.
22
+        Assert.assertEquals(new Double(1.23), p.min());
23
+    }
24
+
25
+    @Test
26
+    public void testMax() throws Exception {
27
+        // Given a pair with two values
28
+        Pair<Double> p = new Pair<Double>(1.23, 2.34);
29
+        // When p.max() is called, the largest should be returned.
30
+        Assert.assertEquals(new Double(2.34), p.max());
31
+    }
32
+}

+ 15
- 15
src/test/java/Swap/SwapTest.java 查看文件

@@ -1,16 +1,16 @@
1 1
 package Swap;
2
-//
3
-//import org.junit.Assert;
4
-//import org.junit.Test;
5
-//
6
-///**
7
-// * Get the tests passing.
8
-// */
9
-//public class SwapTest {
10
-//    @Test
11
-//    public void testSwap() throws Exception {
12
-//        Double[] result = Swap.swap(0,1, 1.5, 2,3);
13
-//        Double[] expected = {2.0, 1.5, 3.0};
14
-//        Assert.assertArrayEquals(expected, result);
15
-//    }
16
-//}
2
+
3
+import org.junit.Assert;
4
+import org.junit.Test;
5
+
6
+/**
7
+ * Get the tests passing.
8
+ */
9
+public class SwapTest {
10
+    @Test
11
+    public void testSwap() throws Exception {
12
+        Double[] result = Swap.swap(0,1, 1.5, 2.0,3.0);
13
+        Double[] expected = {2.0, 1.5, 3.0};
14
+        Assert.assertArrayEquals(expected, result);
15
+    }
16
+}