JAVA Array

Array_Reverse

package array_tasks; import java.util.Arrays; public class Array_Reverse { /* write a function that can reverse an array */ public static int[] reverse(int[] arr){ int[] result = new int[arr.length]; for(int i = arr.length-1, j=0; i >= 0 ; i--, j++){ result[j] = arr[i]; } return result; } }

Array_FindMaximum

package array_tasks; public class Array_FindMaximum { /* Write a function that can find the maximum number from an int Array */ public static int maxValue(int[] n) { int max = Integer.MIN_VALUE; for (int each : n) { if (each > max) { max = each; } } return max; } }

Array_MergeTwoArrays

package array_tasks; import java.util.Arrays; public class Array_MergeTwoArrays { /* Write a return method that can concat two arrays */ public static int[] concatTwoArrays(int[] arr1, int[] arr2) { int[] result = new int[arr1.length + arr2.length]; int i = 0; for (int each : arr1) { result[i++] = each; } for (int each : arr2) { result[i++] = each; } return result; } }

Array_FindMinimum

package array_tasks; public class Array_FindMinimum { /* Write a function that can find the maximum number from an int Array */ public static int maxValue(int[] n) { int min = Integer.MAX_VALUE; for (int each : n) { if (each < min) { min = each; } } return min; } }

Array_FrequencyOfEachElement

package array_tasks; import java.util.*; public class Array_FrequencyOfEachElement { /* Given the array return the output testArray = {"Apple","Banana","Apple","Cherry"} Output Example Apple = 2 Banana = 1 Cherry = 1 */ public static void main(String[] args) { String[] testArray = {"Apple","Banana","Apple","Cherry"}; //solution 1: Map<String, Integer> map = new LinkedHashMap<>(); for (String each : testArray) { int frequency = 0; for (String s : testArray) { if(each.equals(s)){ frequency++; } } map.put(each, frequency); } for (Map.Entry<String, Integer> entry : map.entrySet()) { System.out.println(entry); } System.out.println("--------------------------------------"); //Solution 2: List<String> temp = Arrays.asList(testArray); for (String s : new LinkedHashSet<>(temp)) { System.out.println(s +"="+ Collections.frequency(temp, s) ); } System.out.println("--------------------------------------"); //Solution 3: Arrays.stream(testArray).distinct().forEach( e -> System.out.println(e+"="+Arrays.stream(testArray).filter( p -> p.equals(e)).count() )); } }

Array_RemoveDuplicates

package array_tasks; import java.util.ArrayList; import java.util.Arrays; public class Array_RemoveDuplicates { /* Write a function that can remove the duplicates from an array of integers */ // solution 1 public static int[] removeDuplicates(int[] array){ return Arrays.stream(array).distinct().toArray(); } //solution 2 public static int[] removeDuplicates2(int[] array){ ArrayList<Integer> list = new ArrayList<>(); for(int each: array){ if(!list.contains(each)){ list.add(each); } } array = new int[list.size()]; for (int i = 0; i < list.size(); i++) { array[i] = list.get(i); } return array; } }

Array_WordBreakProblem

package array_tasks; import java.util.ArrayList; import java.util.Arrays; public class Array_WordBreakProblem { /* Word Break Problem Given an input string and a dictionary of words, find out if the input string can be segmented into a space-separated sequence of dictionary words. See following examples for more details. This is a famous Google interview question, also being asked by many other companies now a days. Consider the following dictionary { i, like, sam, sung, samsung, mobile, ice, cream, icecream, man, go, mango} Input: ilike Output: Yes The string can be segmented as "i like". Input: ilikesamsung Output: Yes The string can be segmented as "i like samsung" or "i like sam sung". */ public static void main(String[] args) { String[] dictionary = {"i", "like", "sam", "sung", "samsung", "mobile", "ice", "cream", "icecream", "man", "go", "mango"}; String input = "ilikesamsung"; ArrayList<String> words = new ArrayList<>(); for (int i = 0; i < input.length(); i++) { for (int j = i; j < input.length(); j++) { String temp = input.substring(i, j+1); if(Arrays.asList(dictionary).contains(temp) ){ if(!words.contains(temp)) { words.add(temp); } } } } String result = (words.size() > 0) ? "YES" : "NO"; } }

Array_Permutation

package array_tasks; import java.util.Arrays; import java.util.LinkedHashSet; import java.util.Set; public class Array_Permutation { /* Given an array of 3 characters print all permutation combinations from the given characters */ public static void printPermutation(char[] ch) { for (String s : permutation(ch)) { System.out.println(Arrays.toString(s.toCharArray())); } } public static Set<String> permutation(char[] ch) { String str = Arrays.toString(ch).replace(", ", "").replace("[", "").replace("]", ""); Set<String> set = new LinkedHashSet<>(); if (str.length() == 1) { set.add(str); } else { for (int i = 0; i < str.length(); i++) { String a3 = str.substring(0, i) + str.substring(i + 1); char[] ch2 = a3.toCharArray(); for (String permutation : permutation(ch2)) { set.add(str.charAt(i) + permutation); } } } return set; } }

Array_CountFrequencies

package array_tasks; import java.util.Arrays; public class Array_CountFrequencies { /* Example 1: Input: chars = ["a","a", "b","b","c","c","c"] Output: Return 6, and the first 6 characters of the input array should be: ["a", "2", "b","2","c","3"] Explanation: The groups are "aa", "bb", and "ccc". This compresses to "a2b2c3". Example 2: Input: chars = ["a"] Output: Return 1, and the first character of the input array should be: ["a"] Explanation: The only group is "a", which remains uncompressed since it's a single character. Example 3: Input: chars = ["a","b","b","b","b","b","b","b","b","b","b","b","b"] Output: Return 4, and the first 4 characters of the input array should be: ["a","b","1","2"]. Explanation: The groups are "a" and "bbbbbbbbbbbb". This compresses to "ab12". */ public static void countFreq(String[] arr) { String str = ""; for (String each : arr) { if (!str.contains(each)) { int count = 0; for (String element : arr) { if (each.equals(element)) { count++; } } if (count == 1) { str += each; continue; } else { str += each + count; } } } System.out.println("str = " + Arrays.toString(str.split(""))); System.out.println(str.split("").length); } }

Array_SecondLargestNumber

package array_tasks; import java.util.Arrays; public class Array_SecondLargestNumber { //solution1 public static int secondLargestNumber(int[] arr){ return Arrays.stream(arr).filter( p -> p != Arrays.stream(arr).max().getAsInt()).max().getAsInt(); } //solution2 public static int secondLargestNumber2(int[] arr){ int max1 = arr[0]; int max2 = arr[0]; for (int num : arr) { if (num > max1) { max2 = max1; max1 = num; } else if (num > max2) { max2 = num; } } return max2; } //solution3: }

Array_SortInAscendingOrder

package array_tasks; import java.util.Arrays; public class Array_SortInAscendingOrder { /* Write a method that can sort an int array in Ascending order without using the sort method */ public static int[] sortingArrayAsc(int[] arr) { int[] result = Arrays.copyOfRange(arr, 0, arr.length); for (int i = 0; i < result.length; i++) { for (int j = 0; j < result.length; j++) { if (result[i] < result[j]) { Integer temp = result[i]; result[i] = result[j]; result[j] = temp; } } } return result; } }

Array_SortInDescendingOrder

package array_tasks; import java.util.Arrays; public class Array_SortInDescendingOrder { /* Write a return method that can sort an int array in descending order without using the sort method */ public static int[] sortingArrayAsc(int[] arr) { int[] result = Arrays.copyOfRange(arr, 0, arr.length); for (int i = 0; i < result.length; i++) { for (int j = 0; j < result.length; j++) { if (result[i] > result[j]) { Integer temp = result[i]; result[i] = result[j]; result[j] = temp; } } } return result; } }

Array_AddUpToSum

package array_tasks; import java.util.HashMap; import java.util.Map; public class Array_AddUpToSum { /* given an int[] 'arr' and another int 'sum', Write a function which can find a pair of ints in 'arr' that add up to 'sum'. Example: arr = [8, 7, 2, 5, 3, 1] sum = 10 Output: {8=2, 7=3} */ public static void main(String[] args) { int[] arr = {8, 7, 2, 5, 3, 1}; int sum = 10; int num1 = 0; int num2 = 0; Map<Integer, Integer> pairs = new HashMap<>(); for (int i = 0; i < arr.length; i++) { for (int j = i+1; j < arr.length; j++) { if(arr[i] + arr[j] == sum){ pairs.put(arr[i], arr[j]); } } } System.out.println(pairs); } }

Array_FrequencyOfEachElement_WithWord

package array_tasks; import java.util.LinkedHashMap; import java.util.Map; public class Array_FrequencyOfEachElement_WithWord { /* int[]arr = {1,2,3,4,3,2,1,3,2,2,2,4}; write a program that should count each number and prints a sentence to say how many times a number is repeated example: 1 is two, 3 is three, 4 is two. 2 is five */ public static void main(String[] args) { int[] arr = {1,2,3,4,3,2,1,3,2,2,2,4}; String[] words = {"zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "more than ten"}; //solution1: Map<Integer, String> map = new LinkedHashMap<>(); for (int each : arr) { int count = 0; for (int n : arr) { if(each == n){ count++; } } if(count > 10){ map.put(each, words[11]); }else{ map.put(each, words[count]); } } map.forEach( (k,v) -> System.out.println(k+" is "+v)); } }

Array_FirstDuplicatedElement

package array_tasks; public class Array_FirstDuplicatedElement { /* write a program that can find the first duplicated element from the array */ public static int firstDuplicatedElement(int[] array) { int firstDuplicated = 0; for (int each : array) { int frequency = 0; for (int each2 : array) { if (each == each2) frequency++; } if (frequency > 1) { firstDuplicated = each; break; } } return firstDuplicated; } }

Array_LargestRectangularArea

package array_tasks; public class Array_LargestRectangularArea { /* Largest Rectangular Area in a Histogram Find the largest rectangular area possible in a given histogram where the largest rectangle can be made of a number of contiguous bars. For simplicity, assume that all bars have same width and the width is 1 unit. For example, consider the following histogram with 7 bars of heights {6, 2, 5, 4, 5, 1, 6}. The largest possible rectangle possible is 12 */ public static void main(String[] args) { int[] arr = {6, 2, 5, 4, 5, 1, 6}; int[][] temp = new int[arr.length][arr.length]; int max = arr[0]; for(int w = 1; w <= arr.length; w++){ for(int l = 0; (l+w) -1 < arr.length; l++){ int r = l + w - 1; //adjustment if(w == 1){ // 10 * 1 ===> 10 temp[l][l] = arr[l]; max = Math.max(max, temp[l][l]); } else { temp[l][r] = Math.min(temp[l][r-1], arr[r]); max = Math.max(max, temp[l][r] * w); } } } System.out.println(max); } }

Array_LargestSumContiguousSubarray

package array_tasks; public class Array_LargestSumContiguousSubarray { /* Largest Sum Contiguous Subarray Write a program to find the sum of contiguous subarray within a one-dimensional array of numbers that has the largest sum. Input: nums = [-2,1,-3,4,-1,2,1,-5,4] Output: 6 Explanation: [4,-1,2,1] has the largest sum = 6. */ public static int maxSum(int[] arr) { int max = 0, temp = 0; for (int each: arr) { temp = temp + each; temp = Integer.max(temp, 0); max = Integer.max(max, temp); } return max; } }

Array_MaximumProfit

package array_tasks; public class Array_MaximumProfit { /* We are given an array of prices for a given stock. ith element of this array represents the price of the stock on day i. We are only permitted to complete only one transaction(buy one or sell one share of the stock) per day. Write a Java function to find the maximum profit. Note that a stock can't be sold before buying. Example: Input: [8,3,3,1,4,9,12,11] Output: 11 Explanation: Buy on day 4 (price = 1) and sell on day 7 (price = 12), profit = 12-1 = 11. Not 8-1 = 7, as the selling price needs to be larger than buying price. */ public static void main(String[] args) { int[] arr = { 1, 9, 3, 3, 3, 4, 9, 12, 11}; int min = arr[0]; int max = Integer.MIN_VALUE; for (int i = 0; i < arr.length; i++) { int profit = 0; if (arr[i] > min) { profit = arr[i] - min; if (profit > max) { max = profit; } }else{ min = arr[i]; } } /* int maxProfit = 0; int temp = 0; for (int i = 1; i < arr.length; i++) { if (arr[i - 1] > arr[i]) temp = i; if (arr[i - 1] <= arr[i] ) if(i + 1 == arr.length || arr[i] > arr[i + 1]) maxProfit += (arr[i] - arr[temp]); } */ System.out.println("Maximum profit: "+max); int buy =0, sell =0; for (int i = 0; i < arr.length; i++) { for (int j = i+1; j < arr.length; j++) { if(arr[j] - arr[i] == max){ buy = i+1; sell = j+1; } } } System.out.println("Buy on day "+buy+" sell on day "+sell); } }

Array_MoveAllZerosToTheEnd

package array_tasks; public class Array_MoveAllZerosToTheEnd { /* write a program that can move all the zeros to the end of an array */ public static int[] moveZerosToTheEnd(int[] array) { int[] result = new int[array.length]; int count = 0; for (int each : array) { if (each != 0) result[count++] = each; } return result; } }

Array_SumOfElementCloseTo0

package array_tasks; public class Array_SumOfElementCloseTo0 { /* return the sum of the two elements closest to zero */ public static int getSumOfTwoClosestToZeroElements(int[] a) { /* If there are two elements equally close to zero like -2 and 2, consider the positive element to be "closer" to zero than the negative one. */ int b[] = new int[2]; int z = 0; for (int i = 0; i < a.length; i++) for (int j = i + 1; j < a.length; j++) { int sum = a[i] + a[j]; if (z == 0) z = sum; if (Math.abs(sum) > 0 && Math.abs(sum) < Math.abs(z)) { z = sum; b[0] = a[i]; b[1] = a[j]; } } return z; } }

Array_SumOfLeftEqualToRight

package array_tasks; public class Array_SumOfLeftEqualToRight { /* Given an array of integers, write a function to return the item in the array, where the sum of all items on its left is equal to the sum of the ones on the right. For example : Given [4, 9, 1, 3, 6, 4] your function should give item 1, because 4+9 = 3+6+4 */ // solution 1: (If there is only one such an item) public static int equilibrium1(int[] array) { int result = 0; for (int i = 1; i < array.length; i++) { int sumOfLeft = 0; int sumOfRight = 0; for (int j = 0; j < i; j++) { sumOfLeft += array[j]; } for (int k = i + 1; k < array.length; k++) { sumOfRight += array[k]; } if (sumOfLeft == sumOfRight) { result = array[i]; } } return result; } // solution 2: (if there are more than one such items, and asking you to print all of them) public void equilibrium2(int[] array) { for (int i = 1; i < array.length; i++) { int sumOfLeft = 0; int sumOfRight = 0; for (int j = 0; j < i; j++) { sumOfLeft += array[j]; } for (int k = i + 1; k < array.length; k++) { sumOfRight += array[k]; } if (sumOfLeft == sumOfRight) { System.out.println(array[i]); } } } }

Array_SumUpTo0

package array_tasks; public class Array_SumUpTo0 { /* Write a function: that, given an integer N (1 < N < 100), returns an array containing N unique integers that sum up to 0. The function can return any such array. For example, given N = 4, the function could return [1,0, -3,2] or [-2,1, -4,5]. The answer [1, -1,1,3] would be incorrect (because value 1 occurs twice). For N = 3 one of the possible answers is [-1,0,1] (but there are many more correct answers). */ public static int[] solution(int N) { int[] result = new int[N]; int sum = 0; for (int i = 0; i < N - 1; i++) { result[i] = i; sum += i; } result[N - 1] = -sum; return result; } }

Array_Triples

package array_tasks; public class Array_Triples { /* Given an array of ints, we'll say that a triple is a value appearing 3 times in a row in the array. Return true if the array does not contain any triples. noTriples([1, 1, 2, 2, 1]) → true noTriples([1, 1, 2, 2, 2, 1]) → false noTriples([1, 1, 1, 2, 2, 2, 1]) → false */ public static boolean noTriples(int[] numbers){ for (int i = 0; i < numbers.length-2; i++) { if(numbers[i] == numbers[i+1] && numbers[i] == numbers [i+2]){ return false; } } return true; } }