Javascript 可变性-弗格里维酮

我在谷歌上搜索过，问过人们这个问题，但我不明白它的意思。我知道我的解决方案是不正确的，但我希望它能对JS有所帮助：

设C=[1,3,1,4,2,3,5,4]， Y=4； 函数解x，A{ var叶=[]； var i=0； var结果=-1； 对于i=0；i如果leaves.length好的，我为您解决了问题。您的解决方案实际上几乎是正确的，但您使计算过于复杂。您所要做的就是将一个计数器变量初始化为0，当您在第一个循环中迭代a时，每当离开[a[I]]如果未定义，则递增此计数器。这表示某个叶已落在没有叶的位置。如果递增后计数器等于X，则表示所有位置上现在都有叶，因此只需返回i。如果循环一直到a的末尾，则表示有未覆盖的位置，因此返回-1。

Si使用Set实现100%解决方案。作为一个集合，只能包含唯一的值，只需迭代数组a，将值添加到集合中，直到集合的大小等于整数X，此时数组键就是解决方案

function solution(X, A) {

    let holdValues = new Set();
    for(i=0;i<A.length;i++) {
        holdValues.add(A[i]);
        if(holdValues.size == X)return i;
    }

    return -1;

} 

我的java解决方案100%正确，100%性能：

时间复杂度=>ON 空间复杂度=>OX

 public int solution(int X, int[] A) {

    int[] flags = new int[X + 1];
    int sum = 0;

    //Equivalent to all the leafs have fallen. 
    int desiredSum = (X * (X + 1)) / 2; // 1 + 2 + ....n = (n * (n + 1)) / 2

    for (int i = 0; i < A.length; i++) {

        //Verify if the leaf [i] has fallen. 
        if (A[i] <= X && flags[A[i]] == 0) {
            flags[A[i]] = 1;
            sum += A[i];
        }

        //Verify if all the leafs have fallen.
        if (sum == desiredSum) {
            return i;
        }
    }
    return -1;
}

---

以下是我使用javascript的解决方案：

函数解x，A{

let set = new Set();

for(let i = 0; i < A.length; i++){
    if(A[i] <= X){
        set.add(A[i]);
    }
    
    if(set.size === X){
        return i;
    }
}

return -1;

---

}

字典优于Set，更新或获取dic计数的复杂度为O1

公共函数解决方案\ux:Int，u数组：[Int]->Int{ 让count=array.count 如果x>count{return-1} 变量映射=[Int:Bool] 对于0.中的i.` 函数解{

let count = Math.floor(A.length / 2);

let map = new Map();

for (let i = 0; i < A.length; i++)
    map.set(A[i], map.has(A[i]) ? map.get(A[i]) + 1 : 1);

for (const k of map.keys())
    if (map.get(k) > count)
        return A.indexOf(k);

return -1;

}

`C:

    using System.Collections.Generic;
...
    public static int solution(int X, int[] A)
            {
                HashSet<int> numbers = new HashSet<int>();
                for (int i = 0; i < A.Length; i++)
                {
                    numbers.Add(A[i]);
    
                    if (numbers.Count==X)
                    {
                        return i;
                    }
                  }
                  return -1;
            }

---

100%的Javascript解决方案，比在性能测试中使用集合要快一点。本练习最长的部分是解决问题！总之，我的解决方案如下：

function solution(X, A) {
  let newArray = new Array(X + 1);

  for (let i = 0; i < A.length; i++) {
    if (!newArray[A[i]]) {
      newArray[A[i]] = true;
      X--;

      if (!X) {
        return i;
      }
    }
  }
  return -1;
}

---

这是我的解决方案，java分数100：

    HashSet<Integer> set = new HashSet<Integer>();
    int response = -1;
    for (int i = 0; i < A.length; i++){
        set.add(A[i]);
        if (set.size() == X){
            response = i;
            break;
        }

    }
    return response;

---

这段代码应该完成什么？这个输入的预期结果是什么？会发生什么情况？你的变量名完全没有帮助。FrogRiverOne是什么，你的代码应该做什么？我在谷歌上搜索并询问了人们这个问题什么问题？我不理解这个问题，但下面是描述：而且，你可以获取答案。MátéSafranka，我添加了一个计数器，并以这种方式修改了第一个循环：让c=0；fori=0；i1。不要注释掉叶子[a[I]=I；，这就是跟踪哪些位置上有叶子的方式。2.如果c==X，则移动（返回c；）在C++之后的循环中，返回C而不是C。它是如何工作的？不，我不知道为什么这个特殊的任务对我来说是如此难以理解。下面的代码生成错误的答案，-6而不是1函数SOLVESX，{LeeLeave= []，i，c=0；fori=0；i您仍然在过度复杂化它。下面是我想到的：函数solutionX，A{let leaves=[]，i，c=0；fori=0；Ithank为您的答案！您是否可以对您的答案提供一些解释，以便其他人能够更好地理解？代码非常优秀，但最终用于回答问题，而不仅仅是发布解决方案。

    HashSet<Integer> set = new HashSet<Integer>();
    int response = -1;
    for (int i = 0; i < A.length; i++){
        set.add(A[i]);
        if (set.size() == X){
            response = i;
            break;
        }

    }
    return response;