我用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;
我不需要解决任务,我只需要更明确的解释,即我必须做些什么来解决它。
答案 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;