在列表中查找频率差元素

Question

实际上我正试图解决这个问题hackerlink缺少数字

请允许我添加一些描述，实际上有两个数字列表，几乎相同，但由于第一个列表中缺少一些数字，所以第二个列表中的所有数字都完好无损，但第一个列表缺少一些数字。

问题陈述

艺术家Numeros有两个列表A和B，因此B是A的排列。Numeros对这些列表感到非常自豪。不幸的是，在将它们从一个展览运送到另一个展览时，A的一些数字被遗漏了。你能找到丢失的号码吗？

票据

如果某个数字在列表中多次出现，则必须确保该数字在两个列表中的频率相同。如果不是这样，那么它也是一个缺失的数字。

你必须按升序打印所有丢失的数字。

将每个丢失的数字打印一次，即使它丢失了多次。

B中的最大数和最小数之间的差值小于或等于100。

输入格式将有四行输入：

n - the size of the first list 
This is followed by n space-separated integers that make up the first list. 
m - the size of the second list 
This is followed by m space-separated integers that make up the second list.

输出格式按升序输出丢失的数字：-

限制

1≤n,m≤1000010 
1≤x≤10000,x∈B 
Xmax−Xmin<101

样本输入

10
203 204 205 206 207 208 203 204 205 206
13
203 204 204 205 206 207 205 208 203 206 205 206 204

样本输出

204 205 206

我写了代码：-

这是：-

import java.io.*;
import java.util.*;
public class Solution {
public static void main(String[] args) {
/* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
Map<Integer, Integer> mA = new HashMap<>(n);
int curr = 0;
while(n--> 0){// Creating the first map having number & its frequency
curr = scan.nextInt();
if(mA.containsKey(curr)){
Integer prev = mA.get(curr);
mA.put(curr, prev + 1);
}else{
mA.put(curr, 1);
}
}
int n1 = scan.nextInt();
Map<Integer, Integer> mB = new HashMap<>(n1);
while(n1--> 0){// Creating the second map having number & its frequency
curr = scan.nextInt();
if(mB.containsKey(curr)){
Integer prev = mB.get(curr);
mB.put(curr, prev + 1);
}else{
mB.put(curr, 1);
}   
}
List<Integer> l = new ArrayList<>();
//Problem I think is this part somewhere I am not doing it correct in this loop
for(Map.Entry<Integer, Integer> entry : mB.entrySet()){
Integer k = entry.getKey();
Integer v = entry.getValue();
if(!mA.containsKey(k)){
l.add(k);
}else if(mA.get(k) != v){
l.add(k);
}
}
Collections.sort(l);
List<Integer> list = new ArrayList<>(new LinkedHashSet<Integer>(l));
for(Integer i : l){
System.out.print(i + " ");
}
}
}

我认为问题是在for循环中，我正在比较两个映射中的条目。我觉得我做得不对因为它打印的数字在两个地图中具有相同的频率计数

Answer 1

问题是

for(Map.Entry<Integer, Integer> entry : mB.entrySet()){
Integer k = entry.getKey();
Integer v = entry.getValue();
if(!mA.containsKey(k)){
l.add(k);
}else if(mA.get(k).intValue() != v.intValue()){//This is the problem
l.add(k);
}
}

因为，之前您比较的是两个Integer对象而不是两个int值(对于较小的Integer值，它都映射到同一个对象，但对于较大的对象，Java在执行自动装箱时会创建新对象)。

这个问题实际上只需要一个Map，如果你使用TreeMap而不是HashMap，你会发现这更方便。

注意Xmax - Xmin < 101，所以我们甚至可以使用数组data[101]来存储数字，以便进一步改进。

Answer 2

尝试使用数组：

int[] a = new int[n];
int[] b = new int[m];
// read into a and b
int[] freqs = new int[10001];
for (int i = 0; i < m; i++)
{
freqs[b[i]]++;
}
for (int i = 0; i < n; i++)
{
freqs[a[i]]--;
}
for (int i = 0; i <= 10000; i++)
{
if (freqs[i] > 0) System.out.println(i + " ");
}

Answer 3

void printmissing(HashMap<Integer, Integer> firstset,HashMap<Integer, Integer> secondset){
Set<Integer> keys=secondset.keySet();
for(Integer k:keys){
secondset.put(k, secondset.get(k)-firstset.get(k));
}
for(Integer k:keys){
if(secondset.get(k)>0)
System.out.print(" "+k);
}

将主方法中LinkedHashMap中的整数值相加，并调用上述方法以按顺序显示缺失的数字

HashMap<Integer, Integer> firstset=new LinkedHashMap<>();
HashMap<Integer, Integer>  secondset=new LinkedHashMap<>();

Answer 4

试试这个

`

public class Abce{
public static void main(String[] args) {
ArrayList<Integer> A = new ArrayList<Integer>();
A.add(1);
A.add(1);
A.add(1);
A.add(2);
A.add(1);
ArrayList<Integer> B = new ArrayList<Integer>();
B.add(1);
B.add(1);
B.add(2);
B.add(1);
//Find and remove
for (Integer integer : B) {
if (A.contains(integer)) {
A.remove(integer);
}
}
//Print the remaining items
for (Integer integer : A) {
System.out.println(integer);
}
}
}`