Thursday, February 29, 2024
HomeSoftware EngineeringEvaluating Array Multiplicities in Java

# Evaluating Array Multiplicities in Java

## The problem#

Given two arrays `a` and `b` write a perform `comp(a, b)` (or`compSame(a, b)`) that checks whether or not the 2 arrays have the “similar” components, with the identical multiplicities. “Identical” 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 by way of 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` might 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 will not be 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 will not be the sq. of any variety of `a`.

• `a` or `b` is likely to be `[] or {}`.
• `a` or `b` is likely to 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)
}
``````

Choice 2:

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

public class AreSame {
public static boolean comp(closing int[] a, closing 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 instances 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