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&nbsp;two indices i and j such that :


	i != j
	0 &lt;= i, j &lt; arr.length
	arr[i] == 2 * arr[j]


&nbsp;
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.


&nbsp;
Constraints:


	2 &lt;= arr.length &lt;= 500
	-10^3 &lt;= arr[i] &lt;= 10^3


class Solution(object):
    def checkIfExist(self, arr):
        """
        :type arr: List[int]
        :rtype: bool
        """
        '''
            执行用时：24 ms, 在所有 Python 提交中击败了59.63%的用户
            内存消耗：13 MB, 在所有 Python 提交中击败了58.72%的用户
        '''
        arr = sorted(arr) # 排序
        for i in range(len(arr) - 1): # 只要搜寻 n - 1 个，因为最后一个数不会有倍数出现
            l = 0
            r = len(arr) - 1
            while (l <= r):
                mid = int((l + r) / 2) # 目前位置
                val1 = arr[mid] # 目前位置的数值
                val2 = arr[i] * 2 # 要寻找的目标
                if(val1 == val2 and mid != i): # arr[mid] 必須和 arr[i] * 2 且不同位置
                    return True
                elif(val2 < val1): # 目标在目前位置的左边，所以要往左边找
                    r = mid - 1
                else: # 目标在目前位置的右边，所以要往右边找
                    l = mid + 1
        return False
class Solution {
    public boolean checkIfExist(int[] arr) {
        /*
            执行用时：3 ms, 在所有 Java 提交中击败了29.57%的用户
            内存消耗：41 MB, 在所有 Java 提交中击败了42.27%的用户
            2022年8月3日 14:36
        */
        int l, mid = 0, r;
        int val1, val2;
        Arrays.sort(arr); // 排序
        for(int i=0; i < arr.length - 1; i++){ // 只要搜寻 n - 1 个，因为最后一个数不会有倍数出现
            l = 0;
            r = arr.length - 1;
            while(l <= r){
                mid = (l + r) / 2; // 目前位置
                val1 = arr[mid]; // 目前位置的数值
                val2 = arr[i] * 2; // 要寻找的目标
                if(val1 == val2 && mid != i) // arr[mid] 必須和 arr[i] * 2 且不同位置
                    return true;
                else if(val2 < val1) // 目标在目前位置的左边，所以要往左边找
                    r = mid - 1;
                else // 目标在目前位置的右边，所以要往右边找
                    l = mid + 1;
            }
        }
        return false;
    }
}
class Solution {
public:
    bool checkIfExist(vector<int>& arr) {
        
        sort(arr.begin(), arr.end());
        
        int i =0;
            int j  = 1;
        int n = arr.size();
        while(i<n && j<n)
        {
                
                if(  arr[i]<0 && arr[j]<0 && arr[i]==2*arr[j])return true;
            
                else if(2*arr[i]<arr[j])
                {
                    
                    i++;
                  

                
                }
            else if(2*arr[i]>arr[j])j++;
            else if(i==j && arr[i]==0){
            i++;
                j++;
            }
            
            else return true;
        
        }
        return false;
        
    }
};
/**
 * @param {number[]} arr
 * @return {boolean}
 */
var checkIfExist = function(arr) {
    for(let i=0;i<arr.length;i++){
        for(let j=0;j<arr.length;j++){
            if ( i!==j && arr[i]==2*arr[j]){
                return true;
            }
        }
    }
    return false;
};
Check If N and Its Double Exist