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) (orcompSame(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

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Most Popular

Recent Comments