我试图找到在数组中出现奇数次的所有元素。我计算了一点，但是如果只有一个数字出现奇数次，我的代码只返回正确的答案。如果有两个或更多奇数发生的数字比我无法处理它。我理解的是，如果我们对元素进行逐位XOR，而不是得到一个奇数出现的元素。如何针对多个数字进行改进？
以下是我的代码：
public class OddOccur {
public int oddoccurence(int[] arr, int size) {
int res = 0;
int[] fin = new int[size];
for (int i = 0; i < size; i++) {
res = res ^ arr[i];
}
return res;
}
public static void main(String args[]) {
int[] arr = { 2, 5, 5, 2, 2, 3, 3, 3 };
int n = arr.length;
OddOccur obj = new OddOccur();
System.out.println("odd occuring element is:"
+ obj.oddoccurence(arr, n));
}
}
需要帮助来解决这个问题！
答案 0 :(得分：5)
public int oddoccurence(int[] arr, int size);
首先，可能有多个数字出现奇数次。如果只返回一个int，则无法编写此函数并使其正常工作。你需要一个可以返回多个数字的函数。
public int[] oddOccurrences(int[] array);
其次，不要试图聪明。使用XOR是“聪明的”。您不会找到使用XOR的简单解决方案。这将是一些令人费解，复杂的混乱。保持简单：
伪代码示例：
// Map from numbers to counts. Assume the counts start at 0.
Map<Integer, Integer> counts;
for (number in array) {
counts[number] += 1
}
// List of numbers that occur an odd number of items.
List<Integer> oddNumbers;
for (number, count in counts) {
if (count % 2 != 0) {
oddNumbers.add(number);
}
}
答案 1 :(得分：0)
也许是一篇旧帖...但是我的回答。
在我看来，没有必要计算一个数字的出现来确定它是否奇怪。让我们使用像Set这样的数据结构，如果仍然没有预设，只需添加项目，如果已经存在则将其删除。
这样的事情：
public int solution(int[] A){
Set<Integer> unpaired = new HashSet<Integer>();
for (int i = 0; i<A.length; i++){
if (unpaired.contains(A[i])){
unpaired.remove(new Integer(A[i]));
}else{
unpaired.add(A[i]);
}
}
// all printed out values are odd
for (Integer res : unpaired){
System.out.println(res);
}
}
答案 2 :(得分：0)
你真的不需要跟踪你看过每个整数的次数，只知道你是否看过很多次。因此，从您的数据结构（映射，哈希表，字典，等等）为空开始，这正确地反映了您看到没有数字奇数次的状态。现在，对于数组中的每个数字x，如果x在地图中，则将其删除（现在您已经看过它偶数次），否则添加它
答案 3 :(得分：0)
以下是我使用HashMap的解决方案：
public int solution(int[] A) {
HashMap<Integer, Integer> map = new HashMap<>();
HashSet<Integer> val = new HashSet<>();
for (int i=0; i<A.length; i++){
if (map.get(A[i]) == null) {
map.put(A[i], 1);
} else map.put(A[i], map.get(A[i])+1);
if (map.get(A[i])%2 == 1)
val.add(A[i]);
else val.remove(A[i]);
}
Iterator<Integer> itr = val.iterator();
return itr.next();
}
答案 4 :(得分：0)
此解决方案的可编码性得分为100％。我们要做的只是简单地初始化一个HashMap。 HashMap的查找时间为O（1）恒定时间，请参见here for more info。由于我们只循环遍历整个数组一次，所以我们以O（N）时间结束，其中N是数组的长度。
如果HashMap中已经存在一个元素，则可以将其删除，因为我们已经找到了它的对应对。到此为止，我们应该以只有一对对的HashMap结尾。只需输出此数字即可完成。
import java.util.*;
class Solution {
public int solution(int[] A) {
int key;
Map<Integer, Integer> unpaired = new HashMap<Integer, Integer>();
for (int i = 0; i < A.length; i++){
key = A[i];
Integer value = unpaired.get(key);
if (value != null){
unpaired.remove(key); // Remove by key
}
else{
unpaired.put(key,0);
}
}
for (Map.Entry<Integer, Integer> entry : unpaired.entrySet())
{
key = entry.getKey();
}
return key;
}
}
答案 5 :(得分：0)
我认为使用Map存储出现次数是解决此问题的正确方法，但是如果不同的次数太多，则需要更多的内存，使用BitMap也可以实现并需要更少的内存。
public static List<Integer> oddNumbers(int[] array, int size) {
BitSet bitSet = new BitSet();
for (int i = 0; i < size; i++) {
bitSet.flip(array[i]);
}
List<Integer> resp = new ArrayList<>();
for (int i = 0; i < bitSet.length(); i++) {
if (bitSet.get(i)) {
resp.add(i);
}
}
return resp;
}
测试用例是：
@Test
public void test_oddNumbers() throws Exception {
int[] arr = {2, 5, 5, 2, 2, 3, 3, 3, 1, 7, 8, 9, 9, 9};
List<Integer> resp = oddNumbers(arr, arr.length);
assertTrue(resp.size() == 6);
assertTrue(resp.containsAll(Arrays.asList(1, 2, 3, 7, 8, 9)));
}
答案 6 :(得分：0)
//此解决方案的可编码性得分为100％。
import java.util.Arrays;
类解决方案{
public int solution(int[] A) {
// write your code in Java SE 8
Arrays.sort(A);
int length = A.length;
for (int i = 0, j = 1; i < length; i++) {
if (j < length && A[i] == A[j]) {
i++;
j = j + 2;
} else {
return A[i];
}
}
return 0;
}
}
答案 7 :(得分：0)
问题很简单，只需对数组的所有元素使用按位异或。原因是只有一个元素未配对。
答案 8 :(得分：0)
private static int Odd(int[] a) {
int unpaired;
unpaired = a[0];
for(int i = 1; i< a.length; i++){
unpaired = unpaired ^ a[i]; // xor
}
return unpaired;
}
答案 9 :(得分：0)
使用 Set 对象并简单地添加 if !exist 或删除 if exists 的 Codility 得分为 100%。
public int solution(int[] A)
{
Set<Integer> oddSet = new HashSet<>();
for(int i = 0; i < A.length; i++)
{
if(!oddSet.contains(A[i]))
{
oddSet.add(A[i]);
}
else
{
oddSet.remove(A[i]);
}
}
/* Based on the pre-conditions, we are sure that only one
remains here that is unique. So we just return that. */
return oddSet.iterator().next();
}
答案 10 :(得分：0)
这个分数 100%。
get()答案 11 :(得分：-2)
public class GetOddOccurenceInArray {
public static ArrayList<Integer> getOddOccurence(int arr[]){
int count = 0;
ArrayList<Integer> result = new ArrayList<>();
HashMap<Integer, Integer> hmap = new HashMap();
for(int num : arr){
if(hmap.get(num) == null){
hmap.put(num, count+1);
}
else
hmap.put(num, hmap.get(num)+1);
}
for (Entry<Integer,Integer> entry : hmap.entrySet()) {
if(entry.getValue()%2==1){
//System.out.println("number is "+entry.getKey());
result.add(entry.getKey());
}
}
return result;
}
public static void main(String[] args){
int arr[] = {1,2,2,2,3,3,3,3,4,5,6,6,7,8};
ArrayList<Integer> occurred = getOddOccurence(arr);
System.out.println("numbers occurred odd times : "+ occurred.toString());
}
}