# LeetCode Solution, Easy, 1346. Check If N and Its Double Exist

# [1346. Check If N and Its Double Exist](https://leetcode.com/problems/check-if-n-and-its-double-exist/)

## 題目敘述

Given an array `arr` of integers, check if there exists two integers `N` and `M` such that `N` is the double of `M` ( i.e. `N = 2 * M`).

More formally check if there exists two indices `i` and `j` such that :

- `i != j`
- `0 <= i, j < arr.length`
- `arr[i] == 2 * arr[j]`

**Example 1:**

    Input: arr = [10,2,5,3]
    Output: true
    Explanation: N = 10 is the double of M = 5,that is, 10 = 2 * 5.

**Example 2:**

    Input: arr = [7,1,14,11]
    Output: true
    Explanation: N = 14 is the double of M = 7,that is, 14 = 2 * 7.

**Example 3:**

    Input: arr = [3,1,7,11]
    Output: false
    Explanation: In this case does not exist N and M, such that N = 2 * M.

**Constraints:**

- `2 <= arr.length <= 500`
- `-10^3 <= arr[i] <= 10^3`

**Hint 1:**

Loop from `i = 0` to `arr.length`, maintaining in a hashTable the array elements from `[0, i - 1]`.

**Hint 2:**

On each step of the loop check if we have seen the element `2 * arr[i]` so far or `arr[i] / 2` was seen if `arr[i] % 2 == 0`.

### 題目翻譯

## 解法解析

### 解法範例

#### Go

```go
func checkIfExist(arr []int) bool {
	seen := make(map[float64]bool)
	for _, v := range arr {
		V := float64(v)
		if seen[V*2.0] || seen[V/2.0] {
			return true
		}
		seen[V] = true
	}
	return false
}
```

#### JavaScript

```javascript
/**
 * @param {number[]} arr
 * @return {boolean}
 */
var checkIfExist = function (arr) {
    const seen = new Set();
    for (const value of arr) {
        if (seen.has(value * 2) || seen.has(value / 2)) {
            return true;
        }
        seen.add(value);
    }
    return false;
};
```

#### Kotlin

```kotlin
class Solution {
    fun checkIfExist(arr: IntArray): Boolean {
        val seen = hashSetOf<Int>()
        arr.forEach { num ->
            if (seen.contains(num * 2)) return true
            if (num % 2 == 0 && seen.contains(num / 2)) return true
            seen.add(num)
        }
        return false
    }
}
```

#### PHP

```php
class Solution
{

    /**
     * @param Integer[] $arr
     * @return Boolean
     */
    function checkIfExist($arr)
    {
        $map = [];
        foreach ($arr as $val) {
            if (isset($map[$val * 2]) || ($val % 2 == 0 && isset($map[$val / 2]))) {
                return true;
            }
            $map[$val] = true;
        }
        return false;
    }
}
```

#### Python

```python
class Solution:
    def checkIfExist(self, arr: List[int]) -> bool:
        seen = set(arr)
        for value in arr:
            if 2 * value in seen or value / 2 in seen:
                return True
            seen.add(value)
        return False
```

#### Rust

```rust
impl Solution {
    pub fn check_if_exist(arr: Vec<i32>) -> bool {
        let mut nums = std::collections::HashSet::new();

        for num in arr.into_iter() {
            if ((num as f32 / 2 as f32).fract() == 0.0 && nums.contains(&(num / 2))) || nums.contains(&(num * 2)) {
                return true
            }
            nums.insert(num);
        }

        false
    }
}
```

#### Swift

```swift
class Solution {
    func checkIfExist(_ arr: [Int]) -> Bool {
        var seen = Set<Int>()
        for num in arr {
            if seen.contains(num * 2) || (num % 2 == 0 && seen.contains(num / 2)) {
                return true
            }
            seen.insert(num)
        }
        return false
    }
}
```