harikrishna553
BAN USERimport java.util.HashSet;
import java.util.Objects;
import java.util.Set;
public class ArrayUtil {
public static Set<Integer> getOddTimesRepeatedNumbers(int arr[]) {
Set<Integer> result = new HashSet<>();
if (Objects.isNull(arr))
return result;
for (int data : arr) {
if (result.contains(data)) {
result.remove(data);
continue;
}
result.add(data);
}
return result;
}
}
We need to consider following cases
what if array has only -ves.
what if array has only +ves.
what if array has 0.
Whats if array has both +ves and -ves
Sort array,
a. If array has more than 1 -ve values, take first 2 negatives and last positive compute product.
b. If array has only 1 -ve value (or) only positive values, compute product of last 3 numbers.
Compare the product with the product you computed in step 1. Return max product.
import java.util.Arrays;
import java.util.Objects;
public class ArrayUtil {
public static int maxProduct(int arr[]) {
if (Objects.isNull(arr)) {
throw new NullPointerException("Array shouldn't be null");
}
if (arr.length < 3) {
throw new IllegalArgumentException(
"Array should have atleast 3 elements");
}
Arrays.sort(arr);
int length = arr.length;
int maxProduct = arr[length - 1] * arr[length - 2] * arr[length - 3];
if (arr[0] < 0 && arr[1] < 0) {
int tmpProduct;
if (arr[length - 1] >= 0) {
tmpProduct = arr[0] * arr[1] * arr[length - 1];
} else {
tmpProduct = arr[length - 1] * arr[length - 2]
* arr[length - 3];
}
if (maxProduct < tmpProduct)
return tmpProduct;
}
return maxProduct;
}
}
- harikrishna553 May 24, 2016import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
public class ArrayUtil {
private static void checkPreConditions(int arr1[], int arr2[]) {
if (Objects.isNull(arr1) || Objects.isNull(arr2)) {
throw new NullPointerException("Arrays Shouldn't be null");
}
if (arr1.length != arr2.length + 1) {
throw new IllegalArgumentException("Illegal Arguments");
}
}
public static int approach1(int arr1[], int arr2[]) {
checkPreConditions(arr1, arr2);
int data = arr1[0];
for (int i = 1; i < arr1.length; i++) {
data ^= arr1[i];
data ^= arr2[i - 1];
}
return data;
}
public static int approach2(int arr1[], int arr2[]) {
checkPreConditions(arr1, arr2);
int sum1 = arr1[0], sum2 = 0;
for (int i = 1; i < arr1.length; i++) {
sum1 = sum1 + arr1[i];
sum2 = sum2 + arr2[i - 1];
}
return sum1 - sum2;
}
public static int approach3(int arr1[], int arr2[]) {
checkPreConditions(arr1, arr2);
Set<Integer> hashSet = new HashSet<>();
for (int i : arr1) {
hashSet.add(i);
}
for (int i : arr2) {
if (hashSet.contains(i))
hashSet.remove(i);
}
for (int missed : hashSet)
return missed;
return -1;
}
}
public class TicTacToe {
public static boolean isWon(char board[][]) {
if (board.length != 3 || board[0].length != 3) {
throw new IllegalArgumentException("Wrong Game");
}
for (int i = 0; i < 3; i++) {
if (checkRow(board, i))
return true;
if (checkColumn(board, i))
return true;
}
if (checkDiagonals(board)) {
return true;
}
return false;
}
private static boolean checkRow(char board[][], int row) {
if (board[row][0] == board[row][1] && board[row][1] == board[row][2])
return true;
return false;
}
private static boolean checkColumn(char board[][], int column) {
if (board[0][column] == board[1][column]
&& board[1][column] == board[2][column])
return true;
return false;
}
private static boolean checkDiagonals(char board[][]) {
if (board[0][0] == board[1][1] && board[1][1] == board[2][2])
return true;
if (board[2][0] == board[1][1] && board[1][1] == board[0][2])
return true;
return false;
}
}
import java.util.Objects;
public class StringUtil {
// Assumed only ASCII character string
private static final int ASCII = 255;
public static String countChars(String str) {
if (Objects.isNull(str)) {
return str;
}
char[] chars = str.toCharArray();
int[] counter = new int[ASCII];
boolean[] isVisited = new boolean[ASCII];
for (char c : chars) {
counter[c]++;
}
StringBuilder builder = new StringBuilder();
for (char c : chars) {
if (isVisited[c]) {
continue;
}
isVisited[c] = true;
builder.append(c).append(counter[c]);
}
return builder.toString();
}
}
import java.util.Objects;
public class ArrayUtil {
public static void reverseArray(int arr[], int k) {
if (Objects.isNull(arr) || arr.length == 1 || k <= 1 || k > arr.length)
return;
int length = arr.length;
int iter = length / k;
int start, stop;
for (int i = 0; i < iter; i++) {
start = i * k;
stop = ((i + 1) * k) - 1;
reverse(arr, start, stop);
}
int rem = length % k;
start = (length - rem);
stop = length - 1;
reverse(arr, start, stop);
}
private static void reverse(int arr[], int start, int stop) {
while (start < stop) {
swap(arr, start, stop);
start++;
stop--;
}
}
private static void swap(int arr[], int start, int stop) {
int temp = arr[start];
arr[start] = arr[stop];
arr[stop] = temp;
}
}
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
public class ArraySum {
public static int[] arraysSum(int arr1[], int arr2[]) {
int empty[] = {};
if (Objects.isNull(arr1) && Objects.isNull(arr2)) {
return empty;
} else if (Objects.isNull(arr1) || arr1.length == 0) {
return arr2;
} else if (Objects.isNull(arr2) || arr2.length == 0) {
return arr1;
}
if (arr1.length > arr2.length)
return getSum(arr1, arr2);
return getSum(arr2, arr1);
}
private static int[] getSum(int arr1[], int arr2[]) {
List<Integer> result = new ArrayList<>();
for (int i = 0; i < arr2.length; i++) {
int sum = arr1[i] + arr2[i];
if (sum > 9) {
String temp = new Integer(sum).toString();
for (int j = 0; j < temp.length(); j++) {
result.add(new Integer("" + temp.charAt(j)));
}
continue;
}
result.add(sum);
}
for (int j = arr2.length; j < arr1.length; j++) {
result.add(arr1[j]);
}
return getArray(result);
}
private static int[] getArray(List<Integer> arr) {
int result[] = new int[arr.size()];
int i = 0;
for (Integer data : arr) {
result[i] = data;
i++;
}
return result;
}
}
- harikrishna553 May 26, 2016