Thursday, March 23, 2023
HomeSoftware EngineeringEvaluating Array Multiplicities in Java

# Evaluating Array Multiplicities in Java

## The problem#

Given two arrays `a` and `b` write a operate `comp(a, b)` (or`compSame(a, b)`) that checks whether or not the 2 arrays have the “similar” components, with the identical multiplicities. “Similar” means, right here, that the weather in `b` are the weather in `a` squared, whatever the order.

Examples

Legitimate arrays

``````a = [121, 144, 19, 161, 19, 144, 19, 11]
b = [121, 14641, 20736, 361, 25921, 361, 20736, 361]
``````

`comp(a, b)` returns true as a result of in `b` 121 is the sq. of 11, 14641 is the sq. of 121, 20736 the sq. of 144, 361 the sq. of 19, 25921 the sq. of 161, and so forth. It will get apparent if we write `b`‘s components when it comes to squares:

``````a = [121, 144, 19, 161, 19, 144, 19, 11]
b = [11*11, 121*121, 144*144, 19*19, 161*161, 19*19, 144*144, 19*19]
``````

Invalid arrays

If, for instance, we alter the primary quantity to one thing else, `comp` could not return true anymore:

``````a = [121, 144, 19, 161, 19, 144, 19, 11]
b = [132, 14641, 20736, 361, 25921, 361, 20736, 361]
``````

`comp(a,b)` returns false as a result of in `b` 132 just isn’t the sq. of any variety of `a`.

``````a = [121, 144, 19, 161, 19, 144, 19, 11]
b = [121, 14641, 20736, 36100, 25921, 361, 20736, 361]
``````

`comp(a,b)` returns false as a result of in `b` 36100 just isn’t the sq. of any variety of `a`.

• `a` or `b` could be `[] or {}`.
• `a` or `b` could be `null`.

If `a` or `b` are `null`, the issue doesn’t make sense so return false.

## The answer in Java code#

Choice 1:

``````import java.util.*;
import java.io.*;
import java.util.Arrays;

public class AreSame {
public static boolean comp(int[] a, int[] b)  (b == null)) return false;
int[] aa = Arrays.stream(a).map(n -> n * n).toArray();
Arrays.kind(aa);
Arrays.kind(b);
return (Arrays.equals(aa, b));

}
``````

Choice 2:

``````import java.util.Arrays;

public class AreSame {
public static boolean comp(ultimate int[] a, ultimate int[] b) {
return a != null && b != null && a.size == b.size &&
Arrays.equals(
Arrays.stream(a).map(i -> i * i).sorted().toArray(),
Arrays.stream(b).sorted().toArray()
);
}
}
``````

Choice 3:

``````public class AreSame {
public static boolean comp(int[] a, int[] b) {
if (a == null || b == null || a.size != b.size) return false;

int sumA = 0;
int sumB = 0;

for (int i = 0; i < a.size; i++) {
sumA += Math.abs(a[i]);
sumB += Math.sqrt(b[i]);
}

return sumA == sumB;
}
}
``````

## Check circumstances to validate our resolution#

``````import static org.junit.Assert.*;
import org.junit.Check;

public class AreSameTest {

@Check
public void test1() {
int[] a = new int[]{121, 144, 19, 161, 19, 144, 19, 11};
int[] b = new int[]{121, 14641, 20736, 361, 25921, 361, 20736, 361};
assertEquals(true, AreSame.comp(a, b));
}
@Check
public void test2() {
int[] a = new int[]{121, 144, 19, 161, 19, 144, 19, 11};
int[] b = new int[]{11 * 11, 121 * 121, 144 * 144, 190 * 190, 161 * 161, 19 * 19, 144 * 144, 19 * 19};
assertEquals(false, AreSame.comp(a, b));
}
@Check
public void test3() {
int[] a = new int[]{};
int[] b = new int[]{1};
assertEquals(false, AreSame.comp(a, b));
}
@Check
public void test4() {
int[] a = new int[]{};
int[] b = new int[]{};
assertEquals(true, AreSame.comp(a, b));
}
@Check
public void test5() {
int[] a = new int[]{};
int[] b = null;
assertEquals(false, AreSame.comp(a, b));
}
@Check
public void test6() {
int[] a = new int[]{121, 144, 19, 161, 19, 144, 19, 11, 1008};
int[] b = {11 * 11, 121 * 121, 144 * 144, 190 * 190, 161 * 161, 19 * 19, 144 * 144, 19 * 19};
assertEquals(false, AreSame.comp(a, b));
}
@Check
public void test7() {
int[] a = new int[]{121, 1440, 191, 161, 19, 144, 195, 11};
int[] b = {11 * 11, 121 * 121, 1440 * 1440, 191 * 191, 161 * 161, 19 * 19, 144 * 144, 195 * 195};
assertEquals(true, AreSame.comp(a, b));
}
@Check
public void test8() {
int[] a = new int[]{0, -14, 191, 161, 19, 144, 195, 1};
int[] b = {1, 0, 14 * 14, 191 * 191, 161 * 161, 19 * 19, 144 * 144, 195 * 195};
assertEquals(true, AreSame.comp(a, b));
}
@Check
public void test9() {
int[] a = new int[]{0, -14, 191, 161, 19, 144, 195, 1, 2};
int[] b = {1, 0, 14 * 14, 191 * 191, 161 * 161, 19 * 19, 144 * 144, 195 * 195, 3};
assertEquals(false, AreSame.comp(a, b));
}
@Check
public void test10() {
int[] a = new int[]{2, 2, 3};
int[] b = {4, 9, 9};
assertEquals(false, AreSame.comp(a, b));
}
@Check
public void test1a() {
int[] a = new int[]{2, 2, 3};
int[] b = {4, 4, 9};
assertEquals(true, AreSame.comp(a, b));
}
@Check
public void test2a() {
int[] a = new int[]{4, 4};
int[] b = {1, 31};
assertEquals(false, AreSame.comp(a, b));
}
@Check
public void test3a() {
int[] a = new int[]{3, 4};
int[] b = {0, 25};
assertEquals(false, AreSame.comp(a, b));
}
}
``````
RELATED ARTICLES