Added array-1 problems

Author: Alfredo Miranda

java/array-1/biggerTwo.java

@@ -0,0 +1,10 @@
+/* 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 int[] biggerTwo(int[] a, int[] b) {
+    if(a[0] + a[1] < b[0] + b[1])
+        return b;
+          
+    return a;
+}

java/array-1/commonEnd.java

@@ -0,0 +1,7 @@
+/* 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.
+ */
+public boolean commonEnd(int[] a, int[] b) {
+    return a[0] == b[0] || a[a.length - 1] == b[b.length - 1];
+}

java/array-1/double23.java

@@ -0,0 +1,17 @@
+/* Given an int array, return true if the array contains 2 twice, or 3 twice. 
+ * The array will be length 0, 1, or 2.
+ */
+public boolean double23(int[] nums) {
+    int count2 = 0;
+    int count3 = 0;
+      
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] == 2)
+            count2++;
+                        
+        if(nums[i] == 3)
+            count3++;
+    }
+                                      
+    return count2 == 2 || count3 == 2;
+}

java/array-1/firstLast6.java

@@ -0,0 +1,6 @@
+/* Given an array of ints, return true if 6 appears as either the first or 
+ * last element in the array. The array will be length 1 or more.
+ */
+public boolean firstLast6(int[] nums) {
+    return nums[0] == 6 || nums[nums.length - 1] == 6;
+}

java/array-1/fix23.java

@@ -0,0 +1,11 @@
+/* Given an int array length 3, if there is a 2 in the array immediately 
+ * followed by a 3, set the 3 element to 0. Return the changed array.
+ */
+public int[] fix23(int[] nums) {
+    for(int i = 0; i < nums.length - 1; i++) {
+        if(nums[i] == 2 && nums[i + 1] == 3)
+            nums[i + 1] = 0;
+    }
+                
+    return nums;
+}

java/array-1/front11.java

@@ -0,0 +1,14 @@
+/* Given 2 int arrays, a and b, of any length, return a new array with the 
+ * first element of each array. If either array is length 0, ignore that array.
+ */
+public int[] front11(int[] a, int[] b) {
+    if(a.length > 0 && b.length > 0) {
+        return new int[] {a[0], b[0]};
+    } else if(a.length > 0) {
+        return new int[] {a[0]};
+    } else if(b.length > 0) {
+        return new int[] {b[0]};
+    }
+                      
+    return new int[0];
+}

java/array-1/frontPiece.java

@@ -0,0 +1,19 @@
+/* Given an int array of any length, return a new array of its first 2 
+ * elements. If the array is smaller than length 2, use whatever elements are 
+ * present.
+ */
+public int[] frontPiece(int[] nums) {
+    int[] arr;
+    if(nums.length < 2)
+        arr = new int[nums.length];
+    else
+        arr = new int[2];
+                  
+    if(nums.length > 0)
+        arr[0] = nums[0];
+                            
+    if(nums.length > 1)
+        arr[1] = nums[1];
+                                    
+    return arr;
+}

java/array-1/has23.java

@@ -0,0 +1,10 @@
+/* Given an int array length 2, return true if it contains a 2 or a 3.
+ */
+public boolean has23(int[] nums) {
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] == 2 || nums[i] == 3)
+            return true;
+    }
+                
+    return false;
+}

java/array-1/make2.java

@@ -0,0 +1,26 @@
+/* Given 2 int arrays, a and b, return a new array length 2 containing, as 
+ * much as will fit, the elements from a followed by the elements from b. The 
+ * arrays may be any length, including 0, but there will be 2 or more 
+ * elements available between the 2 arrays.
+ */
+public int[] make2(int[] a, int[] b) {
+    int[] arr = new int[2];
+    int count = 0;
+    int i;
+        
+    i = 0;
+    while(count < 2 && i < a.length) {
+        arr[count] = a[i];
+        count++;
+        i++;
+    }
+                            
+    i = 0;
+    while(count < 2 && i < b.length) {
+        arr[count] = b[i];
+        count++;
+        i++;
+    }
+                                                
+    return arr;
+}

java/array-1/makeEnds.java

@@ -0,0 +1,7 @@
+/* Given an array of ints, return a new array length 2 containing the first 
+ * and last elements from the original array. The original array will be 
+ * length 1 or more.
+ */
+public int[] makeEnds(int[] nums) {
+    return new int[] {nums[0], nums[nums.length - 1]};
+}