Added Array-2 problems

Author: Alfredo Miranda

java/array-2/bigDiff.java

@@ -0,0 +1,14 @@
+/* Given an array length 1 or more of ints, return the difference between the 
+ * largest and smallest values in the array.
+ */
+public int bigDiff(int[] nums) {
+    int min = nums[0];
+    int max = nums[0];
+      
+    for(int i = 1; i < nums.length; i++) {
+        min = Math.min(min, nums[i]);
+        max = Math.max(max, nums[i]);
+    }
+                    
+    return max - min;
+}

java/array-2/centeredAverage.java

@@ -0,0 +1,47 @@
+/* Return the "centered" average of an array of ints, which we'll say is the 
+ * mean average of the values, except ignoring the largest and smallest 
+ * values in the array. If there are multiple copies of the smallest value, 
+ * ignore just one copy, and likewise for the largest value. Use int division 
+ * to produce the final average. You may assume that the array is length 3 
+ * or more.
+ */
+public int centeredAverage(int[] nums) {
+    int sum = 0;
+    int count = 0;
+    int min = nums[0];
+    int max = nums[0];
+    boolean foundMin = false;
+    boolean foundMax = false;
+              
+    for(int i = 1; i < nums.length; i++) {
+        min = Math.min(min, nums[i]);
+        max = Math.max(max, nums[i]);
+    }
+                            
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] != min && nums[i] != max) {
+            sum += nums[i];
+            count++;
+        }
+                                                      
+        if(nums[i] == min) {
+            if(foundMin) {
+                sum += nums[i];
+                count++;
+            } else {
+                foundMin = true;
+            }
+        }
+                                                                                                            
+        if(nums[i] == max) {
+            if(foundMax) {
+                sum += nums[i];
+                count++;
+            } else {
+                foundMax = true;
+            }
+        }
+    }
+                                                                                                                                                                  
+    return sum / count;
+}

java/array-2/countEvens.java

@@ -0,0 +1,12 @@
+/* Return the number of even ints in the given array.
+ */
+public int countEvens(int[] nums) {
+    int count = 0;
+    
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] % 2 == 0)
+            count++;
+    }
+                    
+    return count;
+}

java/array-2/either24.java

@@ -0,0 +1,17 @@
+/* Given an array of ints, return true if the array contains a 2 next to 
+ * a 2 or a 4 next to a 4, but not both.
+ */
+public boolean either24(int[] nums) {
+    boolean has22 = false;
+    boolean has44 = false;
+      
+    for(int i = 0; i < nums.length - 1; i++) {
+        if(nums[i] == 2 && nums[i+1] == 2)
+            has22 = true;
+                        
+        if(nums[i] == 4 && nums[i+1] == 4)
+            has44 = true;
+    }
+                                      
+    return has22 != has44;
+}

java/array-2/evenOdd.java

@@ -0,0 +1,22 @@
+/* Return an array that contains the exact same numbers as the given array, 
+ * but rearranged so that all the even numbers come before all the odd 
+ * numbers. Other than that, the numbers can be in any order. You may modify 
+ * and return the given array, or make a new array.
+ */
+public int[] evenOdd(int[] nums) {
+    int i = 0;
+    
+    while(i < nums.length && nums[i] % 2 == 0)
+        i++;
+              
+    for(int j = i + 1; j < nums.length; j++) {
+        if(nums[j] % 2 == 0) {
+            int temp = nums[i];
+            nums[i] = nums[j];
+            nums[j] = temp;
+            i++;
+        }
+    }
+                                                    
+    return nums;
+}

java/array-2/fizzArray.java

@@ -0,0 +1,14 @@
+/* Given a number n, create and return a new int array of length n, 
+ * containing the numbers 0, 1, 2, ... n-1. The given n may be 0, in which 
+ * case just return a length 0 array. You do not need a separate if-statement 
+ * for the length-0 case; the for-loop should naturally execute 0 times in 
+ * that case, so it just works.
+ */
+public int[] fizzArray(int n) {
+    int[] arr = new int[n];
+    
+    for(int i = 0; i < n; i++)
+        arr[i] = i;
+              
+    return arr;
+}

java/array-2/fizzArray2.java

@@ -0,0 +1,12 @@
+/* Given a number n, create and return a new string array of length n, 
+ * containing the strings "0", "1" "2" .. through n-1. N may be 0, in which 
+ * case just return a length 0 array.
+ */
+public String[] fizzArray2(int n) {
+    String[] arr = new String[n];
+    
+    for(int i = 0; i < n; i++)
+        arr[i] = String.valueOf(i);
+              
+    return arr;
+}

java/array-2/fizzArray3.java

@@ -0,0 +1,13 @@
+/* Given start and end numbers, return a new array containing the sequence of 
+ * integers from start up to but not including end, so start=5 and end=10 
+ * yields {5, 6, 7, 8, 9}. The end number will be greater or equal to the 
+ * start number. Note that a length-0 array is valid.
+ */
+public int[] fizzArray3(int start, int end) {
+    int[] arr = new int[end - start];
+    
+    for(int i = start; i < end; i++)
+        arr[i - start] = i;
+              
+    return arr;
+}

java/array-2/fizzBuzz.java

@@ -0,0 +1,30 @@
+/* This is slightly more difficult version of the famous FizzBuzz problem 
+ * which is sometimes given as a first problem for job interviews. Consider 
+ * the series of numbers beginning at start and running up to but not 
+ * including end, so for example start=1 and end=5 gives the series 
+ * 1, 2, 3, 4. Return a new String[] array containing the string form of 
+ * these numbers, except for multiples of 3, use "Fizz" instead of the 
+ * number, for multiples of 5 use "Buzz", and for multiples of both 3 and 5 
+ * use "FizzBuzz". In Java, String.valueOf(xxx) will make the String form of 
+ * an int or other type. This version is a little more complicated than the 
+ * usual version since you have to allocate and index into an array instead 
+ * of just printing, and we vary the start/end instead of just always doing 
+ * 1..100.
+ */
+public String[] fizzBuzz(int start, int end) {
+    String[] arr = new String[end - start];
+    
+    for(int i = start; i < end; i++) {
+        if(i % 15 == 0) {
+            arr[i - start] = "FizzBuzz";
+        } else if(i % 3 == 0) {
+            arr[i - start] = "Fizz";
+        } else if(i % 5 == 0) {
+            arr[i - start] = "Buzz";
+        } else {
+            arr[i - start] = String.valueOf(i);
+        }
+    }
+                                                      
+    return arr;
+}

java/array-2/has12.java

@@ -0,0 +1,16 @@
+/* Given an array of ints, return true if there is a 1 in the array with a 
+ * 2 somewhere later in the array.
+ */
+public boolean has12(int[] nums) {
+    boolean found1 = false;
+    
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] == 1)
+            found1 = true;
+                    
+        if(found1 && nums[i] == 2)
+            return true;
+    }
+                                  
+    return false;  
+}

java/array-2/has22.java

@@ -0,0 +1,11 @@
+/* Given an array of ints, return true if the array contains a 2 next to a 2 
+ * somewhere.
+ */
+public boolean has22(int[] nums) {
+    for(int i = 0; i < nums.length - 1; i++) {
+        if(nums[i] == 2 && nums[i + 1] == 2)
+            return true;
+    }
+                
+    return false;
+}

java/array-2/has77.java

@@ -0,0 +1,15 @@
+/* Given an array of ints, return true if the array contains two 7's next 
+ * to each other, or there are two 7's separated by one element, such as 
+ * with {7, 1, 7}.
+ */
+public boolean has77(int[] nums) {
+    for(int i = 0; i < nums.length - 1; i++) {
+        if(nums[i] == 7 && nums[i+1] == 7)
+            return true;
+                  
+        if(i <= nums.length - 3 && nums[i] == 7 && nums[i+2] == 7)
+            return true;
+    }
+                                
+    return false;
+}

java/array-2/haveThree.java

@@ -0,0 +1,19 @@
+/* Given an array of ints, return true if the value 3 appears in the array 
+ * exactly 3 times, and no 3's are next to each other.
+ */
+public boolean haveThree(int[] nums) {
+    int count = 0;
+    
+    if(nums.length >= 1 && nums[0] == 3)
+        count++;
+
+    for(int i = 1; i < nums.length; i++) {
+        if(nums[i - 1] == 3 && nums[i] == 3)
+            return false;
+                            
+        if(nums[i] == 3)
+            count++;
+    }
+                                          
+    return count == 3;
+}

java/array-2/isEverywhere.java

@@ -0,0 +1,12 @@
+/* We'll say that a value is "everywhere" in an array if for every pair of 
+ * adjacent elements in the array, at least one of the pair is that value. 
+ * Return true if the given value is everywhere in the array.
+ */
+public boolean isEverywhere(int[] nums, int val) {
+    for(int i = 0; i < nums.length - 1; i++) {
+        if(nums[i] != val && nums[i + 1] != val)
+            return false;
+    }
+                
+    return true;
+}

java/array-2/lucky13.java

@@ -0,0 +1,11 @@
+/* Given an array of ints, return true if the array contains no 1's and 
+ * no 3's.
+ */
+public boolean lucky13(int[] nums) {
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] == 1 || nums[i] == 3)
+            return false;
+    }
+                
+    return true;
+}

java/array-2/matchUp.java

@@ -0,0 +1,15 @@
+/* Given arrays nums1 and nums2 of the same length, for every element in 
+ * nums1, consider the corresponding element in nums2 (at the same index). 
+ * Return the count of the number of times that the two elements differ by 2 
+ * or less, but are not equal.
+ */
+public int matchUp(int[] nums1, int[] nums2) {
+    int count = 0;
+    
+    for(int i = 0; i < nums1.length; i++) {
+        if(Math.abs(nums1[i] - nums2[i]) <= 2 && nums1[i] != nums2[i])
+            count++;
+    }
+                    
+    return count;
+}

java/array-2/modThree.java

@@ -0,0 +1,14 @@
+/* Given an array of ints, return true if the array contains either 3 even 
+ * or 3 odd values all next to each other.
+ */
+public boolean modThree(int[] nums) {
+    if(nums.length < 3)
+        return false;
+          
+    for(int i = 0; i <= nums.length - 3; i++) {
+        if(nums[i] % 2 == nums[i+1] % 2 && nums[i] % 2 == nums[i+2] % 2)
+            return true;
+    }
+                          
+    return false;
+}

java/array-2/more14.java

@@ -0,0 +1,17 @@
+/* Given an array of ints, return true if the number of 1's is greater than 
+ * the number of 4's
+ */
+public boolean more14(int[] nums) {
+    int count1 = 0;
+    int count4 = 0;
+      
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] == 1)
+            count1++;
+                        
+        if(nums[i] == 4)
+            count4++;
+    }
+                                      
+    return count1 > count4;
+}

java/array-2/no14.java

@@ -0,0 +1,16 @@
+/* Given an array of ints, return true if it contains no 1's or it contains 
+ * no 4's.
+ */
+public boolean no14(int[] nums) {
+    boolean has1 = false;
+    boolean has4 = false;
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] == 1)
+            has1 = true;
+                      
+        if(nums[i] == 4)
+            has4 = true;
+    }
+                                    
+    return !has1 || !has4;
+}

java/array-2/notAlone.java

@@ -0,0 +1,22 @@
+/* We'll say that an element in an array is "alone" if there are values 
+ * before and after it, and those values are different from it. Return a 
+ * version of the given array where every instance of the given value which 
+ * is alone is replaced by whichever value to its left or right is larger.
+ */
+public int[] notAlone(int[] nums, int val) {
+    int[] arr = new int[nums.length];
+    
+    if(nums.length >= 1) {
+        arr[0] = nums[0];
+        arr[arr.length-1] = nums[nums.length-1];
+    }
+                  
+    for(int i = 1; i <= nums.length - 2; i++) {
+        if(nums[i] == val && nums[i] != nums[i-1] && nums[i] != nums[i+1])
+            arr[i] = Math.max(nums[i-1], nums[i+1]);
+        else
+            arr[i] = nums[i];
+    }
+                                            
+    return arr;
+}

java/array-2/only14.java

@@ -0,0 +1,10 @@
+/* Given an array of ints, return true if every element is a 1 or a 4.
+ */
+public boolean only14(int[] nums) {
+    for(int i = 0; i < nums.length; i++) {
+        if(nums[i] != 1 && nums[i] != 4)
+            return false;
+    }
+                
+    return true;
+}

java/array-2/post4.java

@@ -0,0 +1,18 @@
+/* Given a non-empty array of ints, return a new array containing the 
+ * elements from the original array that come after the last 4 in the 
+ * original array. The original array will contain at least one 4. Note that 
+ * it is valid in java to create an array of length 0.
+ */
+public int[] post4(int[] nums) {
+    int i = nums.length - 1;
+    
+    while(nums[i] != 4)
+        i--;
+              
+    int[] arr = new int[nums.length - i - 1];
+                  
+    for(int j = 0; j < arr.length; j++)
+        arr[j] = nums[i + j + 1];
+                          
+    return arr;
+}