我正在为即将到来的编码面试练习，这是我的一个练习题，也是我离开的程度。
我如何改进计划以及您的建议。
此外，是否有任何城市可以帮助提高我的编码技能。
问题;
A non-empty zero-indexed array A consisting of N integers is given. The array contains an odd number of elements, and each element of the array can be paired with another element that has the same value, except for one element that is left unpaired.
For example, in array A such that:
A[0] = 9 A[1] = 3 A[2] = 9
A[3] = 3 A[4] = 9 A[5] = 7
A[6] = 9
the elements at indexes 0 and 2 have value 9,
the elements at indexes 1 and 3 have value 3,
the elements at indexes 4 and 6 have value 9,
the element at index 5 has value 7 and is unpaired.
Write a function:
class Solution { public int solution(int[] A); }
给定一个由满足上述条件的N个整数组成的数组A，返回未配对元素的值。
For example, given array A such that:
A[0] = 9 A[1] = 3 A[2] = 9
A[3] = 3 A[4] = 9 A[5] = 7
A[6] = 9
the function should return 7, as explained in the example above.
Assume that:
N is an odd integer within the range [1..1,000,000];
each element of array A is an integer within the range [1..1,000,000,000];
all but one of the values in A occur an even number of times.
Complexity:
expected worst-case time complexity is O(N);
expected worst-case space complexity is O(1), beyond input storage (not counting the storage required for input arguments).
Elements of input arrays can be modified.
Solution;
import java.util.*;
public class Solution {
public int solution(int[] A) {
int x;
for(int i = 0; i < 7; i++)
{
//create an integer array containing an odd number of elements of numbers ranging from 1 - 1,000,000
//for(int N = 1; N <= 1,000,000; N++)
int N = 1;
while(N > 1 && N <= 1000000)
{
//check if N is odd then assign to the array
if(N != N/2)
{
A[i] = N;
}
}
//check for any element not paired more than once
if(A[i] != A[i++])
{
x = A[i];
}
else
return 0;
}
//return unpaired elemnent
return x;
}
}
答案 0 :(得分：10)
接受的解决方案违反了要求：
预期的最坏情况时间复杂度为O（N）
因为它具有二次复杂度（两个嵌套循环）。一个明显的快速解决方案是使用HashSet<Integer>来记住尚未配对的数字。但这会违反其他要求：
预期的最坏情况空间复杂度为O（1）
有一个简单的技巧可以满足两者：
public int solution(int[] A) {
int result = 0;
for (int x : A) result ^= x;
return result;
}
这使用了x ^ x == 0 x以及^的相关性这一事实。这意味着任何一对相等的值都会被取消，剩下的是单个不成对的值（如果是多个不成对的值，则结果没有意义;无法检测到这种情况）。
Mikenno接受的解决方案是错误的。对于输入{1, 1, 1}，有一对和一对未配对，因此结果应为1，但它会返回0。
答案 1 :(得分：2)
这是我在 Python 中的解决方案，根据 Codility 测试结果，它具有 O(N) 或 O(N*log(N))。很简单。
def solution(A):
A=sorted(A)
return abs(sum(A[::2])-sum(A[1::2]))
所以，我只是对数组进行排序，然后将数组的所有偶数位置相加，然后从数组中所有奇数位置的总和中减去，这个差就是结果。
答案 2 :(得分：2)
我的尝试：）
public int solution(int[] arr) {
if (arr.length == 1) return arr[0];
Arrays.sort(arr);
int odd = -1;
for (int i = 0; i < arr.length; i++) {
if (i == arr.length-1) {
odd = arr[i];
break;
}
if (arr[i] == arr[i + 1]) {
i++;
continue;
}
odd = arr[i];
}
return odd;
}
答案 3 :(得分：1)
此答案在Codility上进行了测试，其性能和正确性均为100％。
我正在做的是：
对数组进行排序，使两对在一起，因此我可以通过对其进行迭代来检查数组中的每两对。
然后我将两个索引加2以得到下一个对，依此类推。
第一个不匹配意味着两个索引都指向对时，我们已经有了目标。
代码如下：
c=:blues答案 4 :(得分：1)
这样的东西应该可以工作，在这里我以一种方式实现它，我测试它对其余的所有整数，并且只有在有解决方案时才返回（注意必须有一个默认，也许是更好的处理方式） “没有解决方案”。
public class Solution {
public int solution(int[] A) {
boolean possibleSolution = true; // to return and properly break if not possible
for(int i = 0; i < A.length; i++) // run for all ints
{
possibleSolution = true; // set possible true, in case last one failed
for(int j = 0; j < A.length; j++) // take all ints again (to compare to the rest
if(A[i] == A[j] && i != j){ // note i escape comparing to itself
possibleSolution = false; // if there is a math it can't be this one
break; // break to save resources
}
if(possibleSolution) // if it's the solution
return A[i]; // return the current number (from the initial array as that is the reference number and the 2nd is for comparing)
}
return 0; // return default
}
public static void main(String[] args){
Solution solution = new Solution(); // instance
int[] ints = {9,3,9,3,9,7,9}; // new values
System.out.println(solution.solution(ints)); // print the method after it was run
}
}
请注意，此处不包括添加整数，不确定需要哪些类型的值
但只是添加它们然后传递数组，如果可能有多个答案，那么而不是返回添加到List<Integers> results = new ArrayList<>();，并且在运行所有i之后返回results这将是return 0;目前的位置。
答案 5 :(得分：1)
该代码实现了100％的正确性和性能
public int solution(int[] A) {
// write your code in Java SE 8
if (A.length == 0){
return 0;
}
if (A.length == 1) {
return A[0];
}
Arrays.parallelSort(A);
for(int i=0; i<A.length-2; i+=2) {
if(A[i]!=A[i+1])
return A[i];
}
return A[A.length-1];
}
答案 6 :(得分：1)
一种解决方案是使用字典（键，值）。快速解决方案：
let arr:[Int] = [1, 2, 3, 2, 4, 5, 4, 1, 3]
var valuesDict:[Int:Int] = [:]
for num in arr {
if let value = valuesDict[num] {
valuesDict[num]! += 1
} else {
valuesDict[num] = 1
}
}
print(valuesDict)
var unpairedElement:Int?
for (key, value) in valuesDict {
if value == 1 {
unpairedElement = key
break
}
}
print("unpaired element is \(unpairedElement!)")
答案 7 :(得分：0)
我的 PHP 代码结果 100%
// write your code in PHP7.0
if(count($A) == 0){ return 0; }
if(count($A) == 1){ return $A[0]; }
sort($A);
for($i = 0; $i <= count($A); $i = $i+2){
if($i+1 == count($A)){ return $A[$i]; }
if($A[$i] != $A[$i+1]){ return $A[$i]; }
}
答案 8 :(得分：0)
在 Java 中，您显然可以使用 HashSet，它速度快但需要大量空间：
public int solutionOk(int[] A) {
Set<Integer> set = new HashSet<>();
for (int a : A) {
if (!set.remove(a)) {
set.add(a);
}
}
return set.stream().iterator().next();
}
但使用异或运算会更容易、更快：
public int solution(int[] A) {
return Arrays.stream(A).reduce(0, (a, b) -> a ^ b);
}
在 LinkedLists 中节省内存是一个古老的技巧。它用于将内存地址相互异或，以节省 4 个字节的内存。这个技巧也可以用来寻找奇偶校验。我们只是将列表中的每个元素与下一个元素进行异或，而不是存储值。没有一对的，留在最后。
答案 9 :(得分：0)
这是 Python 代码，根据 Codility 测试结果，它有 O(N) 或 O(N*log(N))。 欢迎提问)
def solution(A):
# write your code in Python 3.6
odd = -1
if len(A) == 1:
return A[0]
A.sort()
i = 0
while i<len(A):
if i == len(A) - 1:
odd = A[i]
break
if A[i] == A[i+1]:
i+=2
continue
odd = A[i]
i+=1
return odd
答案 10 :(得分：0)
使用 O(N*logN) 的 Javascript 解决方案，100% 通过所有测试
function solution(A) {
let mapObject={}
for(let i=0;i<A.length;i++){
if(mapObject[A[i]])
{
delete mapObject[A[i]]
}else{
mapObject[A[i]]=A[i];
}
}
return Object.values(mapObject)[0];
}
答案 11 :(得分：0)
所有使用SORT的解决方案都将在O(N log N)时间后运行。
以下是在O(N)时间内以O(N)空间复杂度运行的最佳方式。但是，可以使用按位运算进一步优化空间复杂度。
以下代码使用哈希表并将A []的每个元素的出现都存储为键值对。之后，循环遍历所有键值集，并检查是否出现的不是偶数，即无对。
public int solution(int[] A) {
HashMap<Integer, Integer> hashMap = new HashMap<>();
for(Integer a : A) {
if(hashMap.containsKey(a)) {
hashMap.put(a, hashMap.get(a)+1);
} else {
hashMap.put(a, 1);
}
}
for(Map.Entry<Integer, Integer> entry : hashMap.entrySet()) {
if(entry.getValue() % 2 == 1) {
return entry.getKey();
}
}
return 0;
}
答案 12 :(得分：0)
红宝石100％全部：
def solution(a)
summ = 0
rrr = 1
a.sort.each do |el|
summ = summ + el * rrr
rrr = -rrr
end
summ
end
答案 13 :(得分：0)
解决方案的准确度达到55％
public func solution(_ A : inout [Int]) -> Int? {
let sorted = A.sorted()
var hashmap = [String: Int]()
for value in sorted {
let key = String(describing: value)
if (hashmap[key] != nil) {
hashmap[key]! += 1
} else {
hashmap[key] = 1
}
}
for (key, value) in hashmap {
if value == 1 {
return Int(key) ?? 0
}
}
return nil
}
答案 14 :(得分：0)
Swift 100％通过的解决方案-检测到的时间复杂度：O（N）或O（N * log（N））
import Foundation
import Glibc
// you can write to stdout for debugging purposes, e.g.
// print("this is a debug message")
public func solution(_ A : inout [Int]) -> Int {
// write your code in Swift 4.2.1 (Linux)
var dict = Dictionary<Int, Int>()
if A.count == 1 { return A[0] }
for i in 0..<A.count {
if dict.keys.contains(A[i]) {
dict[A[i]] = nil
}
else {
dict[A[i]] = 1
}
}
for (k,v) in dict
{
if v == 1 {
return k
}
}
return 0;
}
答案 15 :(得分：0)
100％通过：
import java.util.Hashtable;
类解决方案{
public int solution(int[] A) {
if (A.length == 0){
return 0;
}
if (A.length == 1) {
return A[0];
}
Hashtable<Integer, Integer> occurrences = new Hashtable<Integer, Integer>();
for(int i=0; i< A.length; i++)
{
if (occurrences.containsKey(A[i]))
{
occurrences.remove(A[i]);
}
else
{
occurrences.put(A[i], 1);
}
}
// find unpaired element
for(Map.Entry<Integer, Integer> entry: occurrences.entrySet())
{
if(entry.getValue() == 1)
{
return entry.getKey();
}
}
return 0;
}
}
答案 16 :(得分：0)
非常简单，正确和有效的红宝石解决方案
def solution(a)
hash = {}
a.each do |n|
if hash[n]
hash.delete(n)
else
hash[n] = 1
end
end
hash.keys.first
end
答案 17 :(得分：0)
我知道这不是Java，而是PHP，但是登录名可以在任何地方应用，而我在这里没有看到这种解决方案：
function solution($A) {
sort($A); //sort the array
$arrString = implode("-",$A); // make the string
foreach($A as $a):
$str = (string)$a . '-' . (string)$a; // generate the string we will search
if (strpos($arrString, $str) === false) return $a; //if the string dont exist return the number
endforeach;
}
答案 18 :(得分：-1)
嗨，我遇到了这个答案
import java.util.*;
class Solution {
public int solution(int[] A) {
Arrays.sort(A);
int ctr = 1, result = 0;
for (int x = 0; x < A.length - 3; x+= 2){
if(A[x] != A[ctr] && A[ctr] == A[ctr+1] ){
return A[x];
}
ctr +=2;
}
return A[A.length-1];
}
}