JavaScript中的Codibility Leader算法

我正在尝试JavaScript中的“领导者”问题

问题如下:

给出了由

N

整数组成的数组

A

。数组

A

的支配者是

A

中超过一半的元素中出现的值

例如，考虑数组<代码> A<代码>，以使

A[0] = 3    A[1] = 4    A[2] =  3
A[3] = 2    A[4] = 3    A[5] = -1
A[6] = 3    A[7] = 3

A[0] = 3    A[1] = 4    A[2] =  3
A[3] = 2    A[4] = 3    A[5] = -1
A[6] = 3    A[7] = 3

A

的主要成分是3，因为它出现在

A

的8个元素中的5个元素中（即在索引为0、2、4、6和7的

中），而5是8的一半以上

编写函数

函数解（a）

给定由

N

整数组成的数组

A

，返回数组

A

中出现

A

支配符的任何元素的索引。函数应该返回−1如果数组

A

没有支配符

例如，给定数组

A

，使

A[0] = 3    A[1] = 4    A[2] =  3
A[3] = 2    A[4] = 3    A[5] = -1
A[6] = 3    A[7] = 3

A[0] = 3    A[1] = 4    A[2] =  3
A[3] = 2    A[4] = 3    A[5] = -1
A[6] = 3    A[7] = 3

如上所述，该函数可能返回0、2、4、6或7

为以下假设编写有效的算法：

N

是范围

[0..100000]内的整数
数组
A
的每个元素都是范围
[−2147483648..2147483647]

我的答覆如下：

function solution(A) {
    const length = A.length
    if (length > 100000) return -1
    const counters = new Array(length).fill(0)
    const negativeCounters = new Array(length).fill(0)
    for (i=0; i < length; i++){
        if (A[i] < -2147483648 || A[i] > 2147483647) return -1
        if (A[i] > -1){
            counters[A[i]] = counters[A[i]] + 1
            if (counters[A[i]] > (length / 2)) return i
        } else {
            negativeCounters[A[i] * -1]  =  negativeCounters[A[i] * -1] + 1
            if (negativeCounters[A[i] * -1] > (length / 2)) return i
        }
    }
    return -1
}

函数解决方案（A）{
常数长度=A.length
如果（长度>100000）返回-1
常量计数器=新数组（长度）。填充（0）
const negativeCounters=新数组（长度）.fill（0）
对于（i=0；i2147483647）返回-1
if（A[i]>-1）{
计数器[A[i]]=计数器[A[i]]+1
if（计数器[A[i]]>（长度/2））返回i
}否则{
负计数器[A[i]*-1]=负计数器[A[i]*-1]+1
if（negativeCounters[A[i]*-1]>（length/2））返回i
}
}
返回-1
}

尽管我已经尝试了各种输入，但这并没有通过正确性测试。Codibility评估没有列出测试输入，因此我无法找到破坏算法的输入

有人能发现问题吗？
您不应该使用具有如此大范围值的数组（正值的数组需要2147483648的长度）。你应该使用地图，或者在js中你可以使用对象。我把一些东西拼凑在一起，不是很优雅，但它通过了所有测试：

function solution(A) {
    const map = {}
    for (let i = 0; i < A.length; i++) {
        const key = '' + A[i]
        map[key] = key in map ? map[key] + 1 : 1
        if (map[key] > A.length / 2)
            return i
    }
    return -1
}

函数解决方案（A）{
常量映射={}
for（设i=0；iA.length/2）
返回i
}
返回-1
}
您不应该使用具有如此大范围值的数组（正值数组的长度需要2147483648）。你应该使用地图，或者在js中你可以使用对象。我把一些东西拼凑在一起，不是很优雅，但它通过了所有测试：

function solution(A) {
    const map = {}
    for (let i = 0; i < A.length; i++) {
        const key = '' + A[i]
        map[key] = key in map ? map[key] + 1 : 1
        if (map[key] > A.length / 2)
            return i
    }
    return -1
}

函数解决方案（A）{
常量映射={}
for（设i=0；iA.length/2）
返回i
}
返回-1
}
与一些注释和一个答案相反，事实上，在JavaScript中使用计数器数组可以很好地工作。这是因为JavaScript中的数组是关联对象。代码的一个问题是，它无法初始化为键/索引大于初始计数器数组长度的零计数器

以下是所有Codibility度量值均为100%的代码：

function solution(A) {
    const arr = []
    for (let i=0; i<A.length; i++){
      if (!arr[A[i]])
        arr[A[i]] = 1
      else
        arr[A[i]]++
      if (arr[A[i]] > A.length/2)
        return i
    }
    return -1
}

函数解决方案（A）{
常数arr=[]
for（设i=0；i A.长度/2）
返回i
}
返回-1
}
与一些注释和一个答案相反，事实上，在JavaScript中使用计数器数组可以很好地工作。这是因为JavaScript中的数组是关联对象。代码的一个问题是，它无法初始化为键/索引大于初始计数器数组长度的零计数器

以下是所有Codibility度量值均为100%的代码：

function solution(A) {
    const arr = []
    for (let i=0; i<A.length; i++){
      if (!arr[A[i]])
        arr[A[i]] = 1
      else
        arr[A[i]]++
      if (arr[A[i]] > A.length/2)
        return i
    }
    return -1
}

函数解决方案（A）{
常数arr=[]
for（设i=0；i A.长度/2）
返回i
}
返回-1
}
问题：如果数组类似于
[0..1]
，则最大长度为2。如果数组类似于
[0..100000]，最大长度不应该是100001吗？您在第一个案例中限制了该案例，如果失败的案例有任何输出吗？可能是内存不足，分配了两个大小为100K的数组each@Gonzalo.-哈哈，我也在担心同样的事情，我想不是因为这个问题指定了0到100000个成员，所以100001会导致返回。@sinanspd这里有一些输出：在小型测试中。。回答错误，得到-1，但支配者存在，例如在位置8，在小的非分母上。。得到-1，但支配者存在，例如，在位置0上，在中_随机（支配者随机测试，N=10000）。。得到-1，但支配者存在，例如在位置9上。这是问题的症结所在，我的输出不是很好helpful@NicoSchertler这在JavaScript中运行良好：
a=newarray（3）；a[2147483647]=4；log（a.length，a[2147483647]）
因为数组在JS中是关联的。但是，尝试将未初始化为零的值递增可能不太好。问题：如果数组类似于
[0..1]
，则最大长度为2。如果数组类似于
[0..100000]，最大长度不应该是100001吗？您在第一个案例中限制了该案例，如果失败的案例有任何输出吗？可能是内存不足，分配了两个大小为100K的数组each@Gonzalo.-哈哈，我也在担心同样的事情，我想不是因为这个问题指定了0到100000个成员，所以100001会导致返回。@sinanspd这里有一些输出：在小型测试中。。回答错误，得到-1，