---
# System prepended metadata

title: 只出现一次的数字
tags: [LeeCode]

---

# 只出现一次的数字
---

```javascript=
给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1

示例 2:

输入: [4,1,2,1,2]
输出: 4
```

:::success
```go=
// map特性， key唯一
func singleNumber(nums []int) int {
	maps := make(map[int]int, 0)
	resp := -1
	count := 1

	for i := 0; i < len(nums); i++ {
		_, ok := maps[nums[i]]
		if !ok {
			maps[nums[i]] = count
		} else {
			maps[nums[i]] = count + 1
		}
	}

	for key, value := range maps {
		if value == 1 {
			resp = key
			break
		}
	}

	return resp
}

// 自身对自身的异或等于0
// 自身对0的异或等于自身
func singleNumber(nums []int) int {
	var result int
	for _, value := range nums {
		result ^= value
	}
	return result
}

package main

import (
	"fmt"
)


/*
	1. [2,2,2,3] -> [2, 3] 数组去重
	2. [2, 3] * 3 -> [2, 2, 2, 3, 3, 3]
	3. sum([2, 2, 2, 3, 3, 3]) - sum([2,2,2,3]) = 6
	4. 6 / 2 = 3
 */
 
// 数学公式

func singleNumber(nums []int) int {
	newArr := removeRepeatedElement(nums)
	a , b := sumArray(newArr, 0), sumArray(nums, 0)
	return math(a, b)
}

func math(a, b int) int {
	return a * 2 - b
}

func sumArray(arr []int, sum int) int {
	for _, val := range arr {
		sum += val
	}

	return sum
}

func removeRepeatedElement(arr []int) []int{
	result := make([]int, 0)

	for i := 0; i < len(arr); i++ {
		flag := false
		for j := i + 1; j < len(arr); j++ {
			if arr[i] == arr[j] {
				flag = true
				break
			}
		}
		if !flag {
			result = append(result, arr[i])
		}
	}

	return result
}

```
:::

###### tags: `LeeCode`