Question

我正在努力解决Largest Number At Least Twice of Others - LeetCode

其他人最少两次的最大人数


在给定的整数数组nums中，总是有一个最大的元素。

查找数组中最大的元素是否至少是数组中其他每个数字的两倍。

如果是，则返回最大元素的索引，否则返回-1。

示例1：
Input: nums = [3, 6, 1, 0]
Output: 1
Explanation: 6 is the largest integer, and for every other number in the array x,
6 is more than twice as big as x.  The index of value 6 is 1, so we return 1.
示例2：
Input: nums = [1, 2, 3, 4]
Output: -1
Explanation: 4 isn't at least as big as twice the value of 3, so we return -1.
注意：


nums的长度在[1, 50]范围内。

每个nums[i]将是[0, 99]范围内的整数。

条件nums的长度在[1, 50]范围内，无需检查len(nums) ==1和nums == None

我的解决方案

class Solution:
    def dominantIndex(self, nums: List[int]) -> int:
        """
        #solution 1
        #1S#############
        G:List[int], 
        F:index
        RQ: largest and at least twice the second         
        #2S#############
        CP:
        RU: largetst >= second * 2 
        #3S##############
        """
        #base case
        if len(nums) == 1: return -1
        lookup = {nums[i]:i for i in range(len(nums))}
        nums.sort()
        first = nums[-1]
        second = nums[-2]
        if first >= second * 2:
            return lookup[first]
        else:
            return -1 #failure 
        #4C########################
        # nums = [1] output = 0

运行TestCase：

nums = [1]
my output is : -1 #do not exist  such a laregest number 
 #but the expected  is 
0

如何理解这个测试用例？

我的理解是，如果仅存在一个元素，就没有其他元素，而其他都不是，那么条件是：

查找数组中最大的元素是否至少是数组中其他每个数字的两倍。

不满意。

Answer 1

我将完全修改您的代码，使其更具可读性。保证is_twice函数返回一个True或False，这取决于列表中的最大元素是否至少比其他所有元素大两倍。

nums = [1]

def is_twice(lst, max_no):
    return all(max_no >= (2*x) for x in lst if x != max_no)

max_no = max(nums)    
if is_twice(nums, max_no):
    print(nums.index(max_no))  # if you can guarantee there's only one max element else go with below commented code.
    # print([i for i, x in enumerate(nums) if x == max_no])
else:
    print(-1)

# 0

Answer 2

您的问题更多是关于逻辑问题，而不是编程问题。问题要求您给出一个结果，如果最大的结果大于列表中的“其他所有数字”，但是在该测试中没有其他数字。

在逻辑上，如果要测试的项目集为空，则“每个”语句被认为是正确的。您可以使用all函数在Python中看到类似的内容，如果其可迭代参数中的“每个”值都是真实的，通常会返回True。如果您运行all([])，则会得到True，因为空列表中没有虚假值。

Answer 3

问题可能意味着数组中最大的元素被假定为数组中其他数字的至少两倍。直到，否则数组中的一个元素证明了这一点。由于数组中没有其他元素可以证明这一点，因此1仍然满足条件，因此输出是其索引而不是-1。

Answer 4

我认为您的理解是正确的。您可以参考此讨论，他们对此也感到困惑：
https://leetcode.com/problems/largest-number-at-least-twice-of-others/discuss/176102/Wrong-return-with-1

我想说的是，您的解决方案效率不高。您的意图是在nums中找到最大的两个数字，但是sort在这里浪费了，因为您只需要最大的两个数字。所以我认为这里的堆或两个变量更好：

heapq.nlargest(2, nums)
# or find max1, max2 in nums

Answer 5

也许是这样，前if和后if有所变化：

class Solution:
    def dominantIndex(self, nums) -> int:
        """
        #solution 1
        #1S#############
        G:List[int], 
        F:index
        RQ: largest and at least twice the second         
        #2S#############
        CP:
        RU: largetst >= second * 2 
        #3S##############
        """
        #base case
        if len(nums) == 1: return 0
        lookup = {nums[i]:i for i in range(len(nums))}
        nums.sort()
        first = nums[-1]
        second = nums[-2]
        if first >= second * 2:
            return lookup[first]
        else:
            return -1 #failure 
        #4C########################
        # nums = [1] output = 0

测试用例：

a = Solution()
print(a.dominantIndex([1, 2, 3, 6]))

输出：

人数最少的两倍的最大案例

5 个答案: