done

README.md

@@ -1,88 +0,0 @@
-# ArraysGoneWild
-
-This is a series of java array problems to prove your array knowledge.
-
-__You may ONLY use the information in the DocumentationOnArrays folder only...__
-
-## NO GOOGLE on this lab.
-
-At this point you should be able to write up these methods without searching for code patterns
-on google.
-
-## NO STACK-OVERFLOW on this lab.
-
-At this point you should be able to write up these methods without searching for code patterns
-on StackOverflow.
-
-At this point in the cohort, you should be able to glance at the problem, write a couple tests,
-nd then implement the method.
-
-### For each problem.
-
-For each of these problems, you need to write the method itself, and two tests for each method. 
-If the method is named `sumValuesOfArray`, you should write two test methods:
-* test1sumValuesOfArray
-* test2sumValuesOfArray
-
-### Problem list
-
-Write a method in the Arraz class for each of these:
-
-* sum values of an array of integers `sumValuesOfArray`
-* sum values of an array of doubles `sumDoublesOfArray`
-* calculate the average value of an integer array - return an integer `averageOfArray`
-* calculate the average value of an double array - return an double `doubleAverageOfArray`
-* to test if an integer array contains a specific value, pass both array and value as arguments `containsValue`
-* reverse an array of integer values `reverseArray`
-* find the number of even and odd integers in a given array of integers `getOddEvensOfArray`, return an object of type
-```java
-public class OddEven{
-    public int odds;
-    public int evens;
-}
-```
-
-* find the index of an array element, pass both array and value as arguments `findIndexOf`
-* copy an array by iterating the array `copyArrayByInterator`
-* copy an array by looping thru the array `copyArrayByLoop`
-* remove a specific element from an array `removeElementFromArray`
-* insert an element into an array a specific position `insertIntoArrayAt`
-* find the maximum and minimum value of an array `findMaxMinOfArray` return a 
-```java
-public class MaxMin{
-    public int max;
-    public int min;
-}
-```
-* remove duplicate elements from an array, return new array `removeDupesFromArray` (make it an array of Integers)
-* find the second largest element in an array of Doubles `find2ndLargestValueFromArray`
-
-* convert an array to ArrayList `makeMeAnArrayListFromArray`
-* convert an ArrayList to an array `makeMeAnArrayFromArrayList`
-* test the equality of two arrays `check2ArraysForEqual`
-* compute the average value of an array of integers except the largest and smallest values (be thinking
-of code re-use for this one) `averageArrayWithoutMaxMin`
-* check if an array of integers contains two specified elements: 65 and 77, returns a boolean `arrayHas65and77`
-* check if the sum of all the 10's in the array is exactly 30. Return false if the condition does not satisfy, otherwise true. `theTotalofTensIs30`
-* find smallest and second smallest elements of a given array
-
-* copy an array of integers, reverse it, and return it. `makeMeACopyPlease`
-* remove the last element from an array of integers, return a copy `removeLastItemAndCopy`
-* remove the first element from an array of integers, return a copy `removeFirstItemAndCopy`
-* insert a new element at the start of an array, return a copy `insertAtStartAndCopy`
-* insert a new element at the end of an array, return a copy `insertAtEndAndCopy`
-
-* separate even and odd numbers of an given array of integers. Put all even numbers first, and then odd numbers `sortArrayIntoEvensThenOdds`
-
-If you need an array of ints use this one.
-```java
-int[] spiffyHandyIntArray = new int[] {4,5,102,6,-7,12,-32,92,8};
-```
-
-
-If you need an array of Doubles use this one.
-```java
-Double[] spiffyHandyDoubleArray = new Double[] {1.0, 0.5, 3.6, 38.4, 17.3, 62.0, 9.0, 3.375, 0, 3.14159};
-```
-
-__But, if you don't like these arrays, feel free to make your own.__

arraz/.gitignore

@@ -0,0 +1 @@
+.idea/

arraz/arraz.iml

@@ -5,11 +5,10 @@
     <output-test url="file://$MODULE_DIR$/target/test-classes" />
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
       <sourceFolder url="file://$MODULE_DIR$/src/test/java" isTestSource="true" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
-    <orderEntry type="jdk" jdkName="1.8" jdkType="JavaSDK" />
+    <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
     <orderEntry type="library" name="Maven: junit:junit:4.0" level="project" />
   </component>

arraz/src/main/java/Arraz.java

@@ -1,2 +1,238 @@
+import help.OddEven;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+
 public class Arraz {
+
+    public int sumValuesOfArray(int[] a){
+        int sum = 0;
+        for (int i : a)
+            sum += i;
+
+        return sum;
+    }
+
+    public double sumDoubleofArray(double[] a){
+        double sum = 0;
+        for (double i : a)
+            sum += i;
+
+        return sum;
+    }
+
+    public int averageOfArray(int[] a){
+        int sum = 0;
+        for (int i : a)
+            sum+=i;
+        return sum/a.length;
+    }
+
+    public double doubleAverageOfArray(double[] a){
+        double sum = 0;
+        for (double i : a)
+            sum+=i;
+        return sum/a.length;
+    }
+
+    public boolean containsValue(int[] a, int val){
+        for (int i : a)
+            if (i == val)
+                return true;
+        return false;
+    }
+
+    public OddEven oddEven(int[] a){
+        int odd = 0;
+        int even = 0;
+        for (int i : a) {
+            if (i % 2 == 0)
+                even++;
+            else odd++;
+        }
+
+        return new OddEven(odd,even);
+    }
+
+    public Integer findIndexOf(Integer[] a, Integer i){
+        for (int x=0; x<a.length; x++){
+            if (a[x] == i)
+                return x;
+        }
+        return -1;
+    }
+
+    public Integer[] copyArrayByIterator(Integer[] a){
+        List<Integer> l = Arrays.asList(a);
+        List<Integer> b = new ArrayList<Integer>();
+        Iterator<Integer> it = l.iterator();
+        while (it.hasNext()){
+            b.add(it.next());
+        }
+
+        return b.toArray(new Integer[0]);
+    }
+
+    public int[] copyArrayByLoop(int[] a){
+        int[] b = new int[a.length];
+        for (int i=0; i<a.length;i++)
+            b[i] = a[i];
+        return b;
+    }
+
+    public Integer[] removeElementFromArray(Integer[] a, Integer b){
+        int idx = findIndexOf(a,b);
+        Integer[] copy = new Integer[a.length -1];
+        for (int i=0; i<a.length; i++){
+            if (i < idx)
+                copy[i] = a[i];
+            else if (i > idx)
+                copy[i-1] = a[i];
+        }
+        return copy;
+    }
+
+    public Integer[] removeDupesFromArray(Integer[] a){
+        StringBuilder sb = new StringBuilder();
+
+        for (int i=0; i<a.length; i++)
+            for (int j=i+1; j<a.length-1; j++)
+                if (a[i].equals(a[j])) {
+                    sb.append(a[i]).append("-");
+                    break;
+                }
+
+        String[] strArr = sb.toString().split("-");
+        for (String str : strArr) {
+            a = removeElementFromArray(a, Integer.valueOf(str));
+        }
+        return a;
+    }
+
+    public Double find2ndLargestValueFromArray(Double[] d){
+        Double max = Double.MIN_VALUE;
+        Double min = Double.MIN_VALUE;
+
+        for (int i=0; i<d.length; i++){
+            if (d[i] > max){
+                min = max;
+                max = d[i];
+            } else if (d[i] > min && d[i] < max)
+                min = d[i];
+        }
+
+        return min;
+    }
+
+    public List<Integer> makeArrayListFromArray(Integer[] a){
+        List<Integer> l = Arrays.asList(a);
+        return l;
+    }
+
+    public boolean check2ArraysForEqual(Object[] a, Object[] b){
+        if (a.length != b.length) return false;
+        for (int i=0; i<a.length; i++){
+            if (!a[i].equals(b[i]))
+                return false;
+        }
+        return true;
+    }
+
+    public boolean arrayHas65and77(Integer[] a){
+        boolean has65 = false;
+        boolean has77 = false;
+        for (Integer i:a){
+            if (i == 65) has65 = true;
+            else if (i == 77) has77 = true;
+        }
+        return has65 && has77;
+    }
+
+    public boolean theTotalofTensIs30(Integer[] a) {
+        int count = 0;
+        for (Integer i : a)
+            if (i == 10)
+                count++;
+        return count == 3;
+    }
+
+    public Integer[] findTwoSmallest(Integer[] a){
+        Integer small = Integer.MAX_VALUE;
+        Integer secSmall = Integer.MAX_VALUE;
+
+        for (int i=0; i<a.length; i++){
+            if (a[i] < small){
+                secSmall = small;
+                small = a[i];
+            } else if (a[i] < secSmall && a[i] > small)
+                secSmall = a[i];
+        }
+
+        return new Integer[]{small, secSmall};
+    }
+
+    public Integer[] makeMeACopyPlease(Integer[] a){
+        Integer[] b = new Integer[a.length];
+        int j=0;
+        for (int i=a.length-1; i>=0; i--){
+            b[j] = a[i];
+            j++;
+        }
+        return b;
+    }
+
+    public Integer[] removeLastItemAndCopy(Integer[] a){
+        Integer[] b = new Integer[a.length-1];
+        for (int i=0; i<a.length-1; i++){
+            b[i] = a[i];
+        }
+        return b;
+    }
+
+    public Integer[] removeFirstItemAndCopy(Integer[] a){
+        Integer[] b = new Integer[a.length-1];
+        for (int i=1; i<a.length; i++){
+            b[i-1] = a[i];
+        }
+        return b;
+    }
+
+    public Integer[] insertAtStartAndCopy(Integer[] a, Integer insert){
+        Integer[] b = new Integer[a.length+1];
+        b[0] = insert;
+        for (int i=0; i<a.length; i++)
+            b[i+1] = a[i];
+        return b;
+    }
+
+    public Integer[] insertAtEndAndCopy(Integer[] a, Integer insert){
+        Integer[] b = new Integer[a.length+1];
+        for (int i=0; i<a.length; i++)
+            b[i] = a[i];
+        b[b.length-1] = insert;
+        return b;
+    }
+
+    public Integer[] sortArrayIntoEvensThenOdds(Integer[]a){
+        StringBuilder evens = new StringBuilder();
+        StringBuilder odds = new StringBuilder();
+
+        for (Integer i : a) {
+            if (i % 2 == 0)
+                evens.append(i + " ");
+            else odds.append(i + " ");
+        }
+
+        evens.append(odds);
+        String[] s = evens.toString().split(" ");
+        Integer[] split = new Integer[s.length];
+
+        for (int i=0; i<s.length; i++)
+            split[i] = Integer.valueOf(s[i]);
+        return split;
+    }
+
+
 }

arraz/src/main/java/help/OddEven.java

@@ -0,0 +1,27 @@
+package help;
+
+public class OddEven {
+    public int odd;
+    public int even;
+
+    public OddEven(int odd, int even) {
+        this.odd = odd;
+        this.even = even;
+    }
+
+    public int getOdd() {
+        return odd;
+    }
+
+    public void setOdd(int odd) {
+        this.odd = odd;
+    }
+
+    public int getEven() {
+        return even;
+    }
+
+    public void setEven(int even) {
+        this.even = even;
+    }
+}

arraz/src/test/java/ArrazTest.java

@@ -1,5 +1,320 @@
-import static org.junit.Assert.*;
+import help.OddEven;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.List;
 
 public class ArrazTest {
+    Arraz test = new Arraz();
+
+    @Test
+    public void testSumOfArray_int1(){
+        Assert.assertEquals(10, test.sumValuesOfArray(new int[]{4, 3, 2, 1}));
+    }
+
+    @Test
+    public void testSumOfArray_int2(){
+        Assert.assertEquals(-15, test.sumValuesOfArray(new int[]{-5,20,-30}));
+    }
+
+    @Test
+    public void testSumOfArray_double1(){
+        Assert.assertEquals(10.5, test.sumDoubleofArray(new double[]{4.0,3,2,1.5}),.1);
+    }
+
+    @Test
+    public void testSumOfArray_double2(){
+        Assert.assertEquals(0, test.sumDoubleofArray(new double[]{-5.0,20,-15.0}),.1);
+    }
+
+    @Test
+    public void testAverageOfArray_int1(){
+        Assert.assertEquals(7, test.averageOfArray(new int[]{3,20,-1}));
+    }
+
+    @Test
+    public void testAverageOfArray_int2(){
+        Assert.assertEquals(29, test.averageOfArray(new int[]{12,50,15,39}));
+    }
+
+    @Test
+    public void testDoubleAverageOfArray_double1(){
+        Assert.assertEquals(1.0, test.doubleAverageOfArray(new double[]{3,-5,5.0}),.1);
+    }
+
+    @Test
+    public void testDoubleAverageOfArray_double2(){
+        Assert.assertEquals(12, test.doubleAverageOfArray(new double[]{12,4,20,12}),.1);
+    }
+
+    @Test
+    public void testContainsValue1(){
+        Assert.assertTrue(test.containsValue(new int[]{1,2,3,4},3));
+    }
+
+    @Test
+    public void testContainsValue2(){
+        Assert.assertFalse(test.containsValue(new int[]{1,2,3,4},5));
+    }
+
+    @Test
+    public void testOddEven1(){
+        OddEven oe = test.oddEven(new int[]{1,2,3,4,5});
+        Assert.assertEquals(3,oe.getOdd());
+    }
+
+    @Test
+    public void testOddEven2(){
+        OddEven oe = test.oddEven(new int[]{1,2,3,4,5});
+        Assert.assertEquals(2,oe.getEven());
+    }
+
+    @Test
+    public void testFindIndexOf1(){
+        Assert.assertEquals(2, test.findIndexOf(new Integer[]{1,2,3,4,5},3));
+    }
+
+    @Test
+    public void testFindIndexOf2(){
+        Assert.assertEquals(-1, test.findIndexOf(new Integer[]{1,2,3,4,5},6));
+    }
+
+    @Test
+    public void testCopyArrayByIterator1(){
+        Integer[] a = {1,2,3};
+        Integer[] b = test.copyArrayByIterator(a);
+        Assert.assertEquals(1, b[0]);
+    }
+
+    @Test
+    public void testCopyArrayByIterator2(){
+        Integer[] a = {1,2,4};
+        Integer[] b = test.copyArrayByIterator(a);
+        Assert.assertEquals(4, b[2]);
+    }
+
+    @Test
+    public void testCopyArrayByLoop(){
+        int[] a = {1,2,3};
+        int[] b = test.copyArrayByLoop(a);
+        Assert.assertEquals(1, b[0]);
+    }
+
+    @Test
+    public void testCopyArrayByLoop2(){
+        int[] a = {1,2,3};
+        int[] b = test.copyArrayByLoop(a);
+        Assert.assertEquals(3, b[2]);
+    }
+
+    @Test
+    public void testRemoveElementFromArray1(){
+        Integer[] a = {1,2,3};
+        Integer[] b = test.removeElementFromArray(a,2);
+        Assert.assertEquals(3,b[1]);
+    }
+
+    @Test
+    public void testRemoveElementFromArray2(){
+        Integer[] a = {1,2,3,4,5,6,7};
+        Integer[] b = test.removeElementFromArray(a,4);
+        Assert.assertEquals(5,b[3]);
+    }
+
+    @Test
+    public void testRemoveDupesFromArray(){
+        Integer[] a = {1,1,2,3,4};
+        Integer[] b = test.removeDupesFromArray(a);
+        Assert.assertEquals(4,b.length);
+        Assert.assertEquals(2,b[1]);
+    }
+
+    @Test
+    public void testRemoveDupesFromArray2(){
+        Integer[] a = {1,1,2,3,4,4,5,1,6};
+        Integer[] b = test.removeDupesFromArray(a);
+        Assert.assertEquals(6,b.length);
+        Assert.assertEquals(1,b[4]);
+    }
+
+    @Test
+    public void testFind2ndLargest1(){
+        Double[] d = {1.0,2.0,3.0,4.0};
+        Assert.assertEquals(3.0,test.find2ndLargestValueFromArray(d));
+    }
+
+    @Test
+    public void testFind2ndLargest2(){
+        Double[] d = {1.0,1.0,2.0,2.0,2.0,2.0};
+        Assert.assertEquals(1.0,test.find2ndLargestValueFromArray(d));
+    }
+
+    @Test
+    public void testMakeArrayList1(){
+        Integer[] a = {1,2,3,4};
+        List<Integer> b = test.makeArrayListFromArray(a);
+        Assert.assertEquals(4,b.size());
+        Assert.assertEquals(4,b.get(3));
+    }
+
+    @Test
+    public void testMakeArrayList2(){
+        Integer[] a = {1,2,3,4,6};
+        List<Integer> b = test.makeArrayListFromArray(a);
+        Assert.assertEquals(5,b.size());
+        Assert.assertEquals(6,b.get(4));
+    }
+
+    @Test
+    public void testCheck2ArraysForEqual1(){
+        Integer[] a = {1,2,3,4};
+        Integer[] b = {1,2,3,4};
+        Assert.assertTrue(test.check2ArraysForEqual(a,b));
+    }
+
+    @Test
+    public void testCheck2ArraysForEqual2(){
+        Integer[] a = {1,2,3,4};
+        Integer[] b = {1,2,3,5};
+        Assert.assertFalse(test.check2ArraysForEqual(a,b));
+    }
+
+    @Test
+    public void testHas65and77_1(){
+        Integer[] a = {1,2,3,4,65};
+        Integer[] b = {1,2,3,4,77};
+        Integer[] c = {1,2,3,4};
+        Assert.assertFalse(test.arrayHas65and77(a));
+        Assert.assertFalse(test.arrayHas65and77(b));
+        Assert.assertFalse(test.arrayHas65and77(c));
+    }
+
+    @Test
+    public void testHas65and77_2(){
+        Integer[] a = {1,2,3,4,65,77};
+        Assert.assertTrue(test.arrayHas65and77(a));
+    }
+
+    @Test
+    public void testTotalofTensIs30_1(){
+        Integer[] a = {1,2,10,10,10,10};
+        Integer[] b = {1,2,10,10};
+        Assert.assertFalse(test.theTotalofTensIs30(a));
+        Assert.assertFalse(test.theTotalofTensIs30(b));
+    }
+
+    @Test
+    public void testTotalofTensIs30_2(){
+        Integer[] a = {1,2,10,10,10};
+        Integer[] b = {10,2,10,10};
+        Assert.assertTrue(test.theTotalofTensIs30(a));
+        Assert.assertTrue(test.theTotalofTensIs30(b));
+    }
+
+    @Test
+    public void testFindTwoSmallest1(){
+        Integer[] a = {1,2,3,4,5};
+        Integer[] b = test.findTwoSmallest(a);
+
+        Assert.assertEquals(1,b[0]);
+        Assert.assertEquals(2,b[1]);
+    }
+
+    @Test
+    public void testFindTwoSmallest2(){
+        Integer[] a = {1,1,1,2,2,3,4,5};
+        Integer[] b = test.findTwoSmallest(a);
+
+        Assert.assertEquals(1,b[0]);
+        Assert.assertEquals(2,b[1]);
+    }
+
+    @Test
+    public void testMakeMeACopyPlease1(){
+        Integer[] a = {1,2,3,4};
+        Integer[] b = {4,3,2,1};
+
+        Assert.assertEquals(b,test.makeMeACopyPlease(a));
+    }
+
+    @Test
+    public void testMakeMeACopyPlease2(){
+        Integer[] a = {1,2,3,4,5,1,1};
+        Integer[] b = {1,1,5,4,3,2,1};
+
+        Assert.assertEquals(b,test.makeMeACopyPlease(a));
+    }
+
+    @Test
+    public void testRemoveLastItemAndCopy1(){
+        Integer[] a = {1,2,3,4,5};
+        Integer[] b = {1,2,3,4};
+
+        Assert.assertEquals(b,test.removeLastItemAndCopy(a));
+    }
+
+    @Test
+    public void testRemoveLastItemAndCopy2(){
+        Integer[] a = {1,2,3,4,5,6};
+        Integer[] b = {1,2,3,4,5};
+
+        Assert.assertEquals(b,test.removeLastItemAndCopy(a));
+    }
+
+    @Test
+    public void testRemoveFirstItemAndCopy1(){
+        Integer[] a = {1,2,3,4,5};
+        Integer[] b = {2,3,4,5};
+
+        Assert.assertEquals(b,test.removeFirstItemAndCopy(a));
+    }
+
+
+    @Test
+    public void testInsertAtStartAndCopy1(){
+        Integer[] a = {1,2,3,4,5,6};
+        Integer[] b = {5,1,2,3,4,5,6};
+
+        Assert.assertEquals(b,test.insertAtStartAndCopy(a,5));
+    }
+
+    @Test
+    public void testInsertAtStartAndCopy2(){
+        Integer[] a = {1,2,3,4,5,6};
+        Integer[] b = {6,1,2,3,4,5,6};
+
+        Assert.assertEquals(b,test.insertAtStartAndCopy(a,6));
+    }
+
+    @Test
+    public void testInsertAtEndAndCopy1(){
+        Integer[] a = {1,2,3,4,5,6};
+        Integer[] b = {1,2,3,4,5,6,12};
+
+        Assert.assertEquals(b,test.insertAtEndAndCopy(a,12));
+    }
+
+    @Test
+    public void testInsertAtEndAndCopy2(){
+        Integer[] a = {1,2,6};
+        Integer[] b = {1,2,6,13};
+
+        Assert.assertEquals(b,test.insertAtEndAndCopy(a,13));
+    }
+
+    @Test
+    public void testSortArrayIntoEvensThenOdds1(){
+        Integer[] a = {4,5,102,6,-7,12,-32,92,8};
+        a = test.sortArrayIntoEvensThenOdds(a);
+        Integer[] b = {4,102,6,12,-32,92,8,5,-7};
+        Assert.assertEquals(b,test.sortArrayIntoEvensThenOdds(a));
+    }
 
+    @Test
+    public void testSortArrayIntoEvensThenOdds2(){
+        Integer[] a = {4,5,102,6,-7,12,-32,92,8,29, 15, 105, -8};
+        a = test.sortArrayIntoEvensThenOdds(a);
+        Integer[] b = {4,102,6,12,-32,92,8,-8,5,-7,29,15,105};
+        Assert.assertEquals(b,test.sortArrayIntoEvensThenOdds(a));
+    }
 }