Codility - FrogRiverOne

时间:2018-04-23 09:40:19

标签: javascript

我用Google搜索并向人们询问了这个问题,但无法理解。我知道我的解决方案不正确,但我希望它可以提供帮助(它在JS上):



let C = [1, 3, 1, 4, 2, 3, 5, 4],
  Y = 4;

function solution(X, A) {

  var leaves = [];
  var i = 0;
  var result = -1;

  for (i = 0; i < A.length; i++) {
    if (typeof leaves[A[i]] == 'undefined') {
      leaves[A[i]] = i;
    }
  }

  if (leaves.length <= X) {
    return -1;
  }

  for (i = 1; i <= X; i++) {
    if (typeof leaves[i] == 'undefined') {
      return -1;
    } else {
      result = Math.max(result, leaves[i]);
    }
  }

  return result;
}

console.log(solution(Y, C));
&#13;
&#13;
&#13;

我不需要解决任务,我只需要更明确的解释,即我必须做些什么来解决它。

10 个答案:

答案 0 :(得分:1)

好的,我找到了你的问题。您的解决方案实际上几乎是正确的,但您的评估过于复杂。您所要做的就是将计数器变量初始化为0,当您在第一个循环中迭代A时,只要leaves[A[i]]undefined,就递增此计数器。这表明叶子已经落入没有叶子的位置。如果递增计数器后等于X,则表示所有位置现在都有叶子,所以只需返回i。如果你的循环一直到A的末尾,则意味着有未覆盖的位置,所以返回-1。

答案 1 :(得分:0)

使用Set()的简单100%解决方案。作为一个Set只能包含唯一的值,您可以简单地遍历数组A,将这些值添加到Set中,直到Set的大小等于整数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;

} 

答案 2 :(得分:0)

我的 java 解决方案(正确性100%,性能100%)具有:

时间复杂度=> O(N)
空间复杂度=> O(X)

 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;
}

答案 3 :(得分:0)

val first_image : String

first_image = document.data.link

答案 4 :(得分:0)

这是我使用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;

}

答案 5 :(得分:0)

字典比Set更好,更新或获取dic的复杂度为O(1)。

public func solution(_ x : Int, _ array: [Int]) -> Int {
    let count = array.count
    if x > count { return -1 }
    
    var map = [Int: Bool]()
    for i in 0..<count {
        map[array[i]] = true

        if map.count == x {
            return i
        }
    }
    
    return -1
}

答案 6 :(得分:0)

` 函数解(A) {

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;

}

`

答案 7 :(得分:0)

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;
            }

答案 8 :(得分:0)

Javascript 中的解决方案,100%,O(N),它比在性能测试中使用集合要快一些。这个练习中最长的部分是找出问题!无论如何,这是我的解决方案:

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;
}

答案 9 :(得分:0)

这是我的解决方案,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;