使用hashmap比较两个数组

我在codewar上遇到了一个编码问题。指令是这样的给定两个数组a和b，编写一个函数comp(a, b)(或compsame (a, b))，检查两个数组是否具有"相同"。元素，具有相同的多样性。"Same"这里的意思是，b中的元素是a中的元素的平方，与顺序无关。

的例子有效的数组A = [121,144,19,161,19,144,19,11]
b = [121,14641, 20736, 361, 25921, 361, 20736,361]Comp (a, b)返回true，因为在b中121是11的平方，14641是121的平方，20736是144的平方，361是19的平方，25921是161的平方，以此类推。如果我们用平方表示b的元素，这就很明显了:

a = [121, 144, 19, 161, 19, 144, 19, 11]b = [11121121, 14414419日19日16116119日19日144144, 19日19)无效的数组例如，如果将第一个数字更改为其他数字，则comp可能不再返回true:

a = [121,144,19,161,19,144,19,11]
b = [132,14641, 20736, 361, 25921, 361, 20736,361]Comp (a,b)返回false，因为在b中132不是a的任何数的平方。

a = [121,144,19,161,19,144,19,11]
b = [121,14641, 20736, 36100,25921, 361, 20736,361]Comp (a,b)返回false，因为在b中36100不是a的任何数的平方。

的评论a或b可能是[](除了R和Shell之外的所有语言)。a或b可能是nil或null或None或无(除了c++， Elixir, Haskell, PureScript, Pascal, R, Rust, Shell)。如果a或b为nil(或null或None)，则问题没有意义，因此返回false。">

这是我的解决方案

import java.util.HashMap;

类main {

public static int BiggestElement(int [] arr) {
int result = 0;
result = arr[0];
for(int i=0;i<arr.length;i++) {
if(arr[i]>= result) {
result = arr[i];
}
}

return result;
}
public static boolean comp(int[] a, int []b) {
int size = a.length;
if(a.length != b.length) {
System.out.println("They don't have the same size");
return false;
}
else {
//First we need to check which one has the biggest element
int biggestA = 0;
int biggestB = 0;
System.out.println(biggestA = BiggestElement(a));
System.out.println(biggestB = BiggestElement(b));

//creating two maps 
HashMap<Integer, Integer> map1 = new HashMap<Integer,Integer>();
HashMap<Integer, Integer> map2 = new HashMap<Integer,Integer>();
//now we put every value of b inside the map
for(int i = 0; i<a.length;i++) {
map1.put(a[i], i);
map2.put(b[i], i);
}

//now we do the actual comparision
if(biggestA>biggestB) {
for(int  i=0;i<size;i++) {
if(!map1.containsKey(b[i]*b[i])) {
return false;
}
}
} else {
for(int  i=0;i<size;i++) {
if(!map2.containsKey(a[i]*a[i])) {
System.out.println("map 1 doesn't contain " + (b[i]*b[i]));
return false;
}
}
}

}
return true;
}
public static void main(String[] args) {
int[] a = new int[]{121, 144, 19, 161, 19, 144, 19, 11};
int[] b = new int[]{121, 14641, 20736, 361, 25921, 361, 20736, 361};

System.out.println(comp(a,b));
}

}

我提交了我的代码，他们做了13次测试，但我失败了3次。谁有什么建议或解决方案给我，以便我可以改进它。

关于上面的方法，您依赖于映射键来跟踪数组值。但是，映射不能有重复的键，因此每当您为给定键向映射添加值时，旧的键将被替换。

所以下面的数组将相等地比较(它们不是——b中的一个4s应该是16。

int[] a = {1,2,2,3,4,4}; 
int[] b = {1,4,4,9,16,4};

这是一种方法。我很确定还有其他更有效的方法。主要的一点是，它记录了该值每次出现的次数，并将该计数用作比较过程的一部分。

首先，检查确保数组是非空的，并且长度与任何例程可能做的相同。
计算n每平方出现的次数。
然后对于每个值n，从值计数中减去1。
如果该值变为负值，立即返回false，因为一对一映射不存在。
否则，遍历值，如果有非零值，则返回false。

public static boolean comp(int[] a, int[] b) {
if (a == null || b == null ||
(a.length != b.length)) {
return false;
}
int maxVal = Integer.MIN_VALUE;
int maxSquare = Integer.MIN_VALUE;
for(int i = 0; i < vals.length; i++) {
maxVal = Math.max(vals[i], maxVal);
maxSquare = Math.max(squares[i], maxSquare);
}
// swap them if required
if (maxVal > maxSquare) {
int[] temp = squares;
squares = vals;
vals = temp;
}
Map<Integer, Integer> mapA = new HashMap<>();
for (int el : a) {
mapA.compute(el * el, (k, v) -> v == null ? 1 : v + 1);
}

for (int el : b) {
if (mapA.computeIfPresent(el, (k, v) -> v - 1) < 0) {
return false;
}
}

for (int i : mapA.values()) {
if (i != 0) {
return false;
}
}
return true;

}

代码如下:

public static boolean comp(int[] a, int []b) {
if(a.length != b.length) {
System.out.println("They don't have the same size");
return false;
}
Set<Integer> set = new HashSet<Integer>();
for(int i: a) {
set.add(i);
set.add(i * i);
}
for(int i: b)
{
if(!set.contains(i) && !set.contains(i * i))
return false;
}
return true;
}

相关内容

最新更新

热门标签：