findSmallestAnd2ndSmallest

arraz/.idea/compiler.xml

       </profile>
     </annotationProcessing>
     <bytecodeTargetLevel>
-      <module name="arraz" target="1.5" />
+      <module name="arraz" target="8" />
     </bytecodeTargetLevel>
   </component>
 </project>

arraz/arraz.iml

 <?xml version="1.0" encoding="UTF-8"?>
 <module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_5">
+  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_8">
     <output url="file://$MODULE_DIR$/target/classes" />
     <output-test url="file://$MODULE_DIR$/target/test-classes" />
     <content url="file://$MODULE_DIR$">

arraz/pom.xml

     <groupId>rocks.zipcode.arraysgonewild</groupId>
     <artifactId>arraz</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
     <dependencies>
         <dependency>
             <groupId>junit</groupId>

arraz/src/main/java/Arraz.java

 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.TreeMap;
 
 public class Arraz {
 
         return true;
     }
 
+    public double averageArrayWithoutMaxMin(int[] arr){
+        MaxMin maxMin = findMaxMinOfArray(arr);
+        double sum;
+        boolean haveMax = false;
+        boolean haveMin = false;
 
+        ArrayList<Integer> arrayList = new ArrayList<Integer>();
+
+        for (int i: arr) {
+            if (i == maxMin.max && haveMax == false ){
+                haveMax = true;
+            }
+            else if (i == maxMin.min && haveMin == false){
+                haveMin = true;
+            }
+            else {
+                arrayList.add(i);
+            }
+        }
+        sum = arrayList.stream().mapToDouble(Integer::doubleValue).sum();
+        return sum / arrayList.size();
+    }
+
+    public boolean arrayHas65and77(int[] arr){
+        boolean has65 = false;
+        boolean has77 = false;
+
+        for (int i:arr) {
+            if (i == 65){
+                has65 = true;
+            }
+            if (i == 77){
+                has77 = true;
+            }
+        }
+        return has65 && has77;
+    }
+
+    public boolean theTotalofTensIs30(int[] arr) {
+        int sum = 0;
+
+        for (int i:arr) {
+            if (i == 10){
+                sum += i;
+            }
+        }
+        return sum == 30;
+    }
+
+    public int[] findSmallestAnd2ndSmallest(int[] arr){
+        int minValue = Integer.MAX_VALUE;
+
+        for (int d:arr) {
+            if (d < minValue){
+                minValue = d;
+            }
+        }
+
+        int secondMin = find2ndSmallestValueFromArray(arr, minValue);
+        int[] retArr = {minValue, secondMin};
+
+        return retArr;
+    }
+
+    private int find2ndSmallestValueFromArray(int[] arr, int minValue){
+        int secondMin = Integer.MAX_VALUE;
+
+        for (int d:arr) {
+            if (d > minValue && d < secondMin){
+                secondMin = d;
+            }
+        }
+        return secondMin;
+    }
 }

arraz/src/test/java/ArrazTest.java

         //THEN
         Assert.assertEquals(expected, actual);
     }
+
+    @Test
+    public void test1averageArrayWithoutMaxMin() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        //WHEN
+        double expected = 3;
+
+        double actual = arraz.averageArrayWithoutMaxMin(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2averageArrayWithoutMaxMin() {
+        //GIVEN
+        int[] arr = {1, 4, 3, 4, 5, 5};
+        //WHEN
+        double expected = 4;
+
+        double actual = arraz.averageArrayWithoutMaxMin(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test1arrayHas65and77() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        //WHEN
+        boolean expected = false;
+
+        boolean actual = arraz.arrayHas65and77(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2arrayHas65and77() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 65, 5};
+        //WHEN
+        boolean expected = false;
+
+        boolean actual = arraz.arrayHas65and77(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test3arrayHas65and77() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 77, 5};
+        //WHEN
+        boolean expected = false;
+
+        boolean actual = arraz.arrayHas65and77(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+    @Test
+    public void test4arrayHas65and77() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 77, 65};
+        //WHEN
+        boolean expected = true;
+
+        boolean actual = arraz.arrayHas65and77(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testTheTotalofTensIs30(){
+        //GIVEN
+        int[] arr = {10, 2, 10, 77, 10};
+        //WHEN
+        boolean expected = true;
+
+        boolean actual = arraz.theTotalofTensIs30(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test2TheTotalofTensIs30(){
+        //GIVEN
+        int[] arr = {10, 2, 0, 77, 10};
+        //WHEN
+        boolean expected = false;
+
+        boolean actual = arraz.theTotalofTensIs30(arr);
+        //THEN
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void test1FindSmallestAnd2ndSmallest() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5};
+        //WHEN
+        int expectedSmallest = 1;
+        int expected2ndSmallest = 2;
+
+        int[] retArr = arraz.findSmallestAnd2ndSmallest(arr);
+        int actualSmallest = retArr[0];
+        int actual2ndSmallest = retArr[1];
+        //THEN
+        Assert.assertEquals(expectedSmallest, actualSmallest);
+        Assert.assertEquals(expected2ndSmallest, actual2ndSmallest);
+    }
+
+    @Test
+    public void test2FindSmallestAnd2ndSmallest() {
+        //GIVEN
+        int[] arr = {1, 2, 3, 4, 5, -3, -1000, 13, 13, 44444};
+        //WHEN
+        int expectedSmallest = -1000;
+        int expected2ndSmallest = -3;
+
+        int[] retArr = arraz.findSmallestAnd2ndSmallest(arr);
+        int actualSmallest = retArr[0];
+        int actual2ndSmallest = retArr[1];
+        //THEN
+        Assert.assertEquals(expectedSmallest, actualSmallest);
+        Assert.assertEquals(expected2ndSmallest, actual2ndSmallest);
+    }
 }