first commit

.gitignore

@@ -0,0 +1,49 @@
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff:
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/dictionaries
+
+# Sensitive or high-churn files:
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+
+# Gradle:
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# CMake
+cmake-build-debug/
+cmake-build-release/
+
+# Mongo Explorer plugin:
+.idea/**/mongoSettings.xml
+
+## File-based project format:
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties

README.md

@@ -0,0 +1 @@
+# FundamentalDrills-Part1

pom.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>io.zipcoder</groupId>
+    <artifactId>FundamentalDrills-Part1</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+</project>

src/main/java/io/zipcoder/ArrayDrills.java

@@ -0,0 +1,76 @@
+package io.zipcoder;
+
+public class ArrayDrills {
+
+
+    /**
+     * Given an array of ints, return true if value appears as either the first or last element in the array.
+     * The array will be length 1 or more.
+     * example : firstLast(6, [1,2,6); // Should return true
+     *           firstLast(6, [1,2,3]); // Should return false
+     */
+    public Boolean firstLast(Integer value, Integer[] input){
+        return null;
+    }
+
+    /**
+     * Given an array of ints, return true if the array is length 1 or more, and the first element and the last element are equal.
+     * example : sameFirstLast([1,2,3]); // Should return false
+     *           sameFirstLast([1,2,1]); // Should return true
+     */
+    public Boolean sameFirstLast(Integer[] input){
+        return null;
+    }
+
+
+    /**
+     * Given 2 arrays of ints, a and b, return true if they have the same first element or they have the same last element.
+     * Both arrays will be length 1 or more.
+     * example : commonEnd([1, 2, 3], [7, 3]); // Should return true
+     *           commonEnd([1, 2, 3], [7, 3, 2]); // Should return false
+     */
+    public Boolean commonEnd(Integer[] input1, Integer[] input2){
+        return null;
+    }
+
+    /**
+     * Given an array of ints, return an array with the elements "rotated left" so {1, 2, 3} yields {2, 3, 1}.
+     * example : rotateLeft([1, 2, 3]); // Should return [2,3,1]
+     *           rotateLeft([5, 11, 9]); // Should return [11,9,5]
+     */
+    public Integer[] rotateLeft(Integer[] input){
+        return null;
+    }
+
+
+    /**
+     * Given an array of ints, figure out which is element in the array is largest,
+     * and set all the other elements to be that value. Return the changed array.
+     * example : maxValue([1, 2, 3]); // Should return [3,3,3]
+     *           maxValue([5, 11, 9]); // Should return [11,11,11]
+     */
+    public Integer[] maxValue(Integer[] input){
+        return null;
+    }
+
+
+    /**
+     * Given 2 int arrays, a and b, return a new array length 2 containing their middle elements, if length is odd.
+     * If the array length is even the sum of the middle 2 elements in the array.
+     * example : middleWay([1, 2, 3], [4,5,6,2]); // Should return [2,11]
+     *           middleWay([5, 1, 2, 9], [3, 4, 5, 5]); // Should return [3, 9]
+     */
+    public Integer[] middleWay(Integer[] input1, Integer[] input2){
+        return null;
+    }
+
+
+    /**
+     * Start with 2 int arrays, a and b, each length 2.
+     * Consider the sum of the values in each array.
+     * Return the array which has the largest sum. In event of a tie, return a.
+     */
+    public Integer[] biggerTwo(Integer[] a, Integer[] b){
+        return null;
+    }
+}

src/test/java/io/zipcoder/ArrayDrillsTest.java

@@ -0,0 +1,185 @@
+package io.zipcoder;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ArrayDrillsTest {
+    private ArrayDrills arrayDrills;
+
+    @Before
+    public void setup(){
+        this.arrayDrills = new ArrayDrills();
+    }
+
+    @Test
+    public void firstLastTest1(){
+        Integer inputValue = 6;
+        Integer[] inputArray = {6,1,2,3};
+        Boolean actual = arrayDrills.firstLast(inputValue, inputArray);
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void firstLastTest2(){
+        Integer inputValue = 6;
+        Integer[] inputArray = {1,2,6};
+        Boolean actual = arrayDrills.firstLast(inputValue, inputArray);
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void firstLastTest3(){
+        Integer inputValue = 8;
+        Integer[] inputArray = {6,1,2,2};
+        Boolean actual = arrayDrills.firstLast(inputValue, inputArray);
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void sameFirstLastTest1(){
+        Integer[] inputArray = {6,1,2,2};
+        Boolean actual = arrayDrills.sameFirstLast(inputArray);
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void sameFirstLastTest2(){
+        Integer[] inputArray = {6,1,2,6};
+        Boolean actual = arrayDrills.sameFirstLast(inputArray);
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void sameFirstLastTest3(){
+        Integer[] inputArray = {1,1};
+        Boolean actual = arrayDrills.sameFirstLast(inputArray);
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void commonEndTest1(){
+        Integer[] inputArray1 = {1,2,3};
+        Integer[] inputArray2 = {7,3};
+        Boolean actual = arrayDrills.commonEnd(inputArray1, inputArray2);
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void commonEndTest2(){
+        Integer[] inputArray1 = {1,2,3};
+        Integer[] inputArray2 = {7,3,2};
+        Boolean actual = arrayDrills.commonEnd(inputArray1, inputArray2);
+        Assert.assertFalse(actual);
+    }
+
+    @Test
+    public void commonEndTest3(){
+        Integer[] inputArray1 = {1,2,3};
+        Integer[] inputArray2 = {1,3};
+        Boolean actual = arrayDrills.commonEnd(inputArray1, inputArray2);
+        Assert.assertTrue(actual);
+    }
+
+    @Test
+    public void rotateLeftTest1(){
+        Integer[] inputArray = {1,2,3};
+        Integer[] expected = {2,3,1};
+        Integer[] actual = arrayDrills.rotateLeft(inputArray);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void rotateLeftTest2(){
+        Integer[] inputArray = {5,11,9};
+        Integer[] expected = {11,9,5};
+        Integer[] actual = arrayDrills.rotateLeft(inputArray);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void rotateLeftTest3(){
+        Integer[] inputArray = {7,0,0};
+        Integer[] expected = {0,0,7};
+        Integer[] actual = arrayDrills.rotateLeft(inputArray);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void maxValueTest1(){
+        Integer[] inputArray = {1,2,3};
+        Integer[] expected = {3,3,3};
+        Integer[] actual = arrayDrills.maxValue(inputArray);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void maxValueTest2(){
+        Integer[] inputArray = {5,11,9,34,2};
+        Integer[] expected = {34,34,34,34,34};
+        Integer[] actual = arrayDrills.maxValue(inputArray);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void maxValueTest3(){
+        Integer[] inputArray = {2,11,3};
+        Integer[] expected = {11,11,11};
+        Integer[] actual = arrayDrills.maxValue(inputArray);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void middleWayTest1(){
+        Integer[] inputArray1 = {1,2,3};
+        Integer[] inputArray2 = {4,5,6,2};
+        Integer[] expected = {2,11};
+        Integer[] actual = arrayDrills.middleWay(inputArray1, inputArray2);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void middleWayTest2(){
+        Integer[] inputArray1 = {5,1,2,9};
+        Integer[] inputArray2 = {3,4,5,5};
+        Integer[] expected = {3,9};
+        Integer[] actual = arrayDrills.middleWay(inputArray1, inputArray2);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void middleWayTest3(){
+        Integer[] inputArray1 = {5,6,7,4,5};
+        Integer[] inputArray2 = {2,33,4,5,5};
+        Integer[] expected = {7,4};
+        Integer[] actual = arrayDrills.middleWay(inputArray1, inputArray2);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void biggerTwo1(){
+        Integer[] inputArray1 = {5,6};
+        Integer[] inputArray2 = {2,33};
+        Integer[] expected = {2,33};
+        Integer[] actual = arrayDrills.biggerTwo(inputArray1, inputArray2);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void biggerTwo2(){
+        Integer[] inputArray1 = {12, 12};
+        Integer[] inputArray2 = {12,12};
+        Integer[] expected = {12,12};
+        Integer[] actual = arrayDrills.biggerTwo(inputArray1, inputArray2);
+        Assert.assertArrayEquals(expected, actual);
+    }
+
+    @Test
+    public void biggerTwo3(){
+        Integer[] inputArray1 = {-1 ,20};
+        Integer[] inputArray2 = {2, 15};
+        Integer[] expected = {1,20};
+        Integer[] actual = arrayDrills.biggerTwo(inputArray1, inputArray2);
+        Assert.assertArrayEquals(expected, actual);
+    }
+}