14

我一直在尝试解决 Codility 网页上的 Java 练习。

以下是上述练习的链接和我的解决方案。

https://codility.com/demo/results/demoH5GMV3-PV8

谁能告诉我可以在我的代码中纠正什么以提高分数?

以防万一这里是任务描述:

一只小青蛙想去河的另一边。青蛙当前位于位置 0,并想到达位置 X。树叶从树上掉到河面上。

给定一个非空的零索引数组 A,由 N 个表示落叶的整数组成。A[K] 表示在时间 K 时一片叶子落下的位置,以分钟为单位。

目标是找到青蛙可以跳到河对岸的最早时间。只有当树叶出现在从 1 到 X 过河的每个位置时,青蛙才能过河。

例如,给定整数 X = 5 和数组 A,这样:

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

在第 6 分钟,一片叶子落入位置 5。这是最早出现叶子出现在河对岸的每个位置的时间。

写一个函数:

class Solution { public int solution(int X, int[] A); } 

即,给定一个由 N 个整数和整数 X 组成的非空零索引数组 A,返回青蛙可以跳到河对岸的最早时间。

如果青蛙永远不能跳到河的另一边,函数应该返回-1。

例如,给定 X = 5 和数组 A 使得:

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

如上所述,该函数应返回 6。假使,假设:

N and X are integers within the range [1..100,000];
each element of array A is an integer within the range [1..X].

复杂:

expected worst-case time complexity is O(N);
expected worst-case space complexity is O(X), beyond input storage (not counting the storage required for input arguments).

可以修改输入数组的元素。

这是我的解决方案:

import java.util.ArrayList;
import java.util.List;

class Solution {

    public int solution(int X, int[] A) {
        int list[] = A;
        int sum = 0;
        int searchedValue = X;

        List<Integer> arrayList = new ArrayList<Integer>();

        for (int iii = 0; iii < list.length; iii++) {

            if (list[iii] <= searchedValue && !arrayList.contains(list[iii])) {
                sum += list[iii];
                arrayList.add(list[iii]);
            }
            if (list[iii] == searchedValue) {
                if (sum == searchedValue * (searchedValue + 1) / 2) {
                    return iii;
                }
            }
        }
        return -1;
    }
}
4

43 回答 43

44

arrayList.contains在循环中使用,这将不必要地遍历整个列表。

这是我的解决方案(我前段时间写过,但我相信它的得分为 100/100):

    public int frog(int X, int[] A) {
        int steps = X;
        boolean[] bitmap = new boolean[steps+1];
        for(int i = 0; i < A.length; i++){
            if(!bitmap[A[i]]){
                bitmap[A[i]] = true;
                steps--;
                if(steps == 0) return i;
            }

        }
        return -1;
    }
于 2013-10-18T23:28:56.890 回答
18

这是我的解决方案。它给了我 100/100:

public int solution(int X, int[] A)
{
     int[] B = A.Distinct().ToArray();
     return (B.Length != X) ? -1 : Array.IndexOf<int>(A, B[B.Length - 1]);
}
于 2014-09-16T04:33:17.197 回答
7

100/100

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

    int[]counter = new int[X+1];
    int ans = -1;
    int x = 0;

    for (int i=0; i<A.length; i++){
        if (counter[A[i]] == 0){
            counter[A[i]] = A[i];
            x += 1;
            if (x == X){
                return i;
            }
        } 
    }

    return ans;
}
于 2015-02-13T08:46:59.333 回答
7

使用 Sets (Collections Framework) 的 Java 解决方案获得 100%

import java.util.Set;
import java.util.TreeSet;
public class Froggy {
    public static int solution(int X, int[] A){
    int steps=-1;
    Set<Integer> values = new TreeSet<Integer>();
    for(int i=0; i<A.length;i++){
        if(A[i]<=X){
            values.add(A[i]);
        }
        if(values.size()==X){
            steps=i;
            break;
        }
    }
        return steps;
    }
于 2016-01-23T06:00:56.690 回答
5

更好的方法是使用Set,因为它只会将唯一值添加到列表中。每次添加新值时只需将值添加到Set并减量,(如果添加值则返回,否则返回);看一看,XSet#add()truefalse

public static int solution(int X, int[] A) {
    Set<Integer> values = new HashSet<Integer>();
    for (int i = 0; i < A.length; i++) {
        if (values.add(A[i])) X--; 
        if (X == 0) return i;
    }
    return -1;
}

不要忘记导入,

import java.util.HashSet;
import java.util.Set;
于 2015-02-02T11:39:07.857 回答
4

这是我的解决方案,得分为 100/100:

import java.util.HashSet;

class Solution {
    public int solution(int X, int[] A) {
        HashSet<Integer> hset = new HashSet<Integer>();

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

        return -1;
    }
}
于 2015-07-25T15:59:50.003 回答
4

简单的解决方案 100%

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

Set<Integer> emptyPosition = new HashSet<Integer>();

for (int i = 1; i <= X; i++) {
  emptyPosition.add(i);
}
// Once all the numbers are covered for position, that would be the
// moment when the frog will jump
for (int i = 0; i < A.length; i++) {
  emptyPosition.remove(A[i]);
  if (emptyPosition.size() == 0) {
    return i;
  }
}
return -1;
}
于 2017-08-04T09:47:40.700 回答
2

这是我的解决方案。它并不完美,但足以得分 100/100。(我认为它不应该通过一个大A和小X的测试)

counter无论如何,它会用每个落下的叶子填充一个新数组

counter 的大小为 X,因为我不关心落得比 X 更远的叶子,因此是 try-catch 块。

在 X 片叶子掉落后(因为它是最少的叶子),我开始检查我是否有完整的方法 - 我正在检查 count 中的每个 int 是否大于 0。如果是,我返回 i,否则我会中断并重试.

public static int solution(int X, int[] A){
    int[] count = new int[X];
    for (int i = 0; i < A.length; i++){
        try{
            count[A[i]-1]++;
        } catch (ArrayIndexOutOfBoundsException e){ }
        if (i >= X - 1){
            for (int j = 0; j< count.length; j++){
                if (count[j] == 0){
                    break;
                }
                if (j == count.length - 1){
                    return i;
                }
            }
        }
    }
    return -1;
}
于 2013-12-16T05:51:38.223 回答
2

这是我的 100 / 100 解决方案。

public int solution(int X, int[] A) {
    int len = A.length;
    if (X > len) {
        return -1;
    }
    int[] isFilled = new int[X];
    int jumped = 0;
    Arrays.fill(isFilled, 0);
    for (int i = 0; i < len; i++) {
        int x = A[i];
        if (x <= X) {
            if (isFilled[x - 1] == 0) {
                isFilled[x - 1] = 1;
                jumped += 1;
                if (jumped == X) {
                    return i;
                }
            }
        }
    }

    return -1;
}
于 2015-05-20T13:32:15.657 回答
2

这是我在 C# 中的内容。它可能仍然可以重构。我们丢弃大于 X 的数字,这是我们想要停止的地方,然后我们将尚未添加的数字添加到数组中。当列表的计数达到预期的数字 X 时,返回结果。100%

        var tempArray = new int[X+1];
        var totalNumbers = 0;
        for (int i = 0; i < A.Length; i++)
        {
            if (A[i] > X || tempArray.ElementAt(A[i]) != 0)
                continue;
            tempArray[A[i]] = A[i];
            totalNumbers++;

            if (totalNumbers == X)
                return i;
        }

        return -1;
于 2015-11-23T18:31:49.487 回答
2

下面是我的解决方案。我基本上创建了一个只允许唯一的集合,然后遍历数组并添加每个元素来设置并保留一个计数器来获得集合的总和,然后使用连续数字的总和公式然后我得到 100% 。注意:如果您使用 java 8 流 api 将集合相加,则解决方案将变为二次方,您会得到 %56 。

public static int solution2(int X, int[] A) {

    long sum = X * (X + 1) / 2;
    Set<Integer> set = new HashSet<Integer>();
    int setSum = 0;

    for (int i = 0; i < A.length; i++) {
        if (set.add(A[i]))
            setSum += A[i];

        if (setSum == sum) {
            return i;
        }

    }

    return -1;
}
于 2017-10-30T07:50:15.623 回答
2

我的 JavaScript 解决方案获得了 100 分。由于假定数字在河流宽度范围内,因此只需将布尔值存储在一个临时数组中,以便检查重复项即可。然后,一旦你积累了与 X 一样多的数字,你就知道你已经拥有了所有必要的叶子。

function solution(X, A) {
    covered = 0;
    tempArray = [];
    for (let i = 0; i < A.length; i++) {
        if (!tempArray[A[i]]) {
            tempArray[A[i]] = true;
            covered++
            if(covered === X) return i;
        }
    }
    return -1;
}
于 2019-05-12T00:03:29.683 回答
2

这是我在 Python 中的回答:

def solution(X, A):
    # write your code in Python 3.6
    values = set()
    for i in range (len(A)):
        if A[i]<=X :
            values.add(A[i])
        if len(values)==X:
            return i
    return -1
于 2020-06-08T18:40:09.677 回答
1

刚刚也尝试过这个问题,这是我的解决方案。基本上,我只是声明了一个大小等于位置 X 的数组。然后,我声明了一个计数器来监视必要的叶子是否已经落在特定的位置。当满足这些叶子时,循环退出,如果没有,则按照指示返回 -1。

class Solution {
    public int solution(int X, int[] A) {
        int size = A.length;
        int[] check = new int[X];
        int cmp = 0;
        int time = -1;

        for (int x = 0; x < size; x++) {
            int temp = A[x];
            if (temp <= X) {
                if (check[temp-1] > 0) {
                    continue;
                }
                check[temp - 1]++;
                cmp++;
            }

            if ( cmp == X) {
                time = x;
                break;
            }
        }

        return time;
    }
}

它的评价为 100/100,但我不太确定它的性能。在编程方面,我仍然是初学者,所以如果有人可以批评代码,我将不胜感激。

于 2013-12-26T09:11:54.203 回答
1

也许它并不完美,但它直截了当。只需制作一个计数器数组来跟踪所需的“叶子”,并在每次迭代中验证路径是否完整。让我得到 100/100 和 O(N)。

    public static int frogRiver(int X, int[] A)
    {
        int leaves = A.Length;
        int[] counter = new int[X + 1];
        int stepsAvailForTravel = 0;

        for(int i = 0; i < leaves; i++)
        {
            //we won't get to that leaf anyway so we shouldnt count it,
            if (A[i] > X)
            {
                continue;
            } 
            else
            {
                //first hit!, keep a count of the available leaves to jump
                if (counter[A[i]] == 0)
                    stepsAvailForTravel++;

                counter[A[i]]++;

            }
            //We did it!!
            if (stepsAvailForTravel == X)
            {
                return i;
            }
        }

        return -1;

    }
于 2014-06-20T16:31:37.317 回答
1

这是我的解决方案。我认为这很简单。它的可编码性为 100/100。set.contains() 让我消除表格中的重复位置。第一个循环的结果得到我们预期的总和。在第二个循环中,我们得到输入值的总和。

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

        Set<Integer> set = new HashSet<Integer>();
        int sum1 = 0, sum2 = 0;

        for (int i = 0; i <= X; i++){
            sum1 += i;       
        }

        for (int i = 0; i < A.length; i++){
            if (set.contains(A[i])) continue;
            set.add(A[i]);
            sum2 += A[i];
            if (sum1 == sum2) return i;
        }        
        return -1;
    }
}
于 2014-08-27T11:50:57.630 回答
1

您的算法是完美的,除了下面的代码您的代码仅在 list[iii] 与 searchedValue 匹配时才返回值。

该算法必须以这样的方式进行更正,如果 sum == n * ( n + 1) / 2 则返回值。

import java.util.ArrayList;
import java.util.List;
class Solution {
    public int solution(int X, int[] A) {
        int list[] = A;
        int sum = 0;
        int searchedValue = X;
        int sumV = searchedValue * (searchedValue + 1) / 2;   
        List<Integer> arrayList = new ArrayList<Integer>();
        for (int iii = 0; iii < list.length; iii++) {
            if (list[iii] <= searchedValue && !arrayList.contains(list[iii])) {
                sum += list[iii];
                if (sum == sumV) {
                    return iii;
                }
                arrayList.add(list[iii]);
            }
        }
        return -1;
    }
}

我认为您还需要检查性能。我只是确保只输出

于 2016-08-16T07:58:07.340 回答
1

我今天发布的这个解决方案给出了 100% 的可编码性,但分别@rafalio 的回答它需要的内存少 K 倍

public class Solution {

    private static final int ARRAY_SIZE_LOWER = 1;
    private static final int ARRAY_SIZE_UPPER = 100000;
    private static final int NUMBER_LOWER = ARRAY_SIZE_LOWER;
    private static final int NUMBER_UPPER = ARRAY_SIZE_UPPER;

    public static class Set {

        final long[] buckets;

        public Set(int size) {
            this.buckets = new long[(size % 64 == 0 ? (size/64) : (size/64) + 1)];
        }

        /**
         * number should be greater than zero
         * @param number
         */
        public void put(int number) {
            buckets[getBucketindex(number)] |= getFlag(number); 
        }

        public boolean contains(int number) {
            long flag = getFlag(number);
            // check if flag is stored
            return (buckets[getBucketindex(number)] & flag) == flag;
        }

        private int getBucketindex(int number) {
            if (number <= 64) {
                return 0;
            } else if (number <= 128) {
                return 1;
            } else if (number <= 192) {
                return 2;
            } else if (number <= 256) {
                return 3;
            } else if (number <= 320) {
                return 4;
            } else if (number <= 384) {
                return 5;
            } else 
                return (number % 64 == 0 ? (number/64) : (number/64) + 1) - 1;
        }

        private long getFlag(int number) {
            if (number <= 64) {
                return 1L << number;
            } else
                return 1L << (number % 64);
        }
    }

    public static final int solution(final int X, final int[] A) {
        if (A.length < ARRAY_SIZE_LOWER || A.length > ARRAY_SIZE_UPPER) {
            throw new RuntimeException("Array size out of bounds");
        }
        Set set = new Set(X);
        int ai;
        int counter = X;
        final int NUMBER_REAL_UPPER = min(NUMBER_UPPER, X);
        for (int i = 0 ; i < A.length; i++) {
            if ((ai = A[i]) < NUMBER_LOWER || ai > NUMBER_REAL_UPPER) {
                throw new RuntimeException("Number out of bounds");
            } else if (ai <= X && !set.contains(ai)) {
                counter--;
                if (counter == 0) {
                    return i;
                }
                set.put(ai);
            }
        }
        return -1;
    }

    private static int min(int x, int y) {
        return (x < y ? x : y);
    }
}
于 2016-09-29T20:28:30.317 回答
1

这是我的解决方案,它让我得到了 100/100 和 O(N)。

public int solution(int X, int[] A) {
    Map<Integer, Integer> leaves = new HashMap<>();

    for (int i = A.length - 1; i >= 0 ; i--)
    {
        leaves.put(A[i] - 1, i);
    }

    return leaves.size() != X ? -1 : Collections.max(leaves.values());
}
于 2017-06-23T18:13:41.107 回答
1

这是我的解决方案

public func FrogRiverOne(_ X : Int, _ A : inout [Int]) -> Int {

    var B = [Int](repeating: 0, count: X+1)

    for i in 0..<A.count {
        if B[A[i]] == 0 {
            B[A[i]] = i+1
        }
    }

    var time = 0

    for i in 1...X {
        if( B[i] == 0 ) {
            return -1
        } else {
            time = max(time, B[i])
        }
    }

    return time-1
}

A = [1,2,1,4,2,3,5,4]
print("FrogRiverOne: ", FrogRiverOne(5, &A))
于 2018-01-30T21:13:52.240 回答
1

实际上,我在没有看到最后一个答案的情况下重新编写了这个练习,并提出了另一个解决方案 100/100 和 O(N)。

public int solution(int X, int[] A) {
    Set<Integer> leaves = new HashSet<>();

    for(int i=0; i < A.length; i++) {
        leaves.add(A[i]);

        if (leaves.contains(X) && leaves.size() == X)  return i; 
    }

    return -1;
}

我更喜欢这个,因为它更简单。

于 2018-03-22T14:02:13.353 回答
1

这个在 100% 中 100% 的 codality 上效果很好。它与上面的标记数组非常相似,但使用了地图:


  public int solution(int X, int[] A) {
    int index = -1;

    Map<Integer, Integer> map = new HashMap();
    for (int i = 0; i < A.length; i++) {
      if (!map.containsKey(A[i])) {
        map.put(A[i], A[i]);
        X--;
        if (X == 0) {index = i;break;}
      }
    }

    return index;
  }
于 2019-07-23T22:07:30.160 回答
1

%100 与 js

function solution(X, A) {

  let leafSet = new Set();

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

    if(A[i] <= 0) 
        continue;

    if (A[i] <= X )
        leafSet.add(A[i]); 


    if (leafSet.size == X)
      return i;

  }

  return -1;
}
于 2020-01-20T22:56:10.803 回答
1

使用 JavaScript 以下解决方案得到 100/100。

检测到的时间复杂度:O(N)

function solution(X, A) {
    let leaves = new Set();

    for (let i = 0; i < A.length; i++) {
        if (A[i] <= X) {
            leaves.add(A[i])
            if (leaves.size == X) {
                return i;
            }
        }
    }
    return -1;    
}
于 2020-01-29T10:37:04.850 回答
1

使用 Javascript 的 100% 解决方案。

在此处输入图像描述

function solution(X, A) {
    if (A.length === 0) return -1
    if (A.length < X) return -1


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

        if (steps === 0) {
            return i
        }
    }

    return -1
}
于 2020-03-23T21:11:32.873 回答
1

得分为 100% 的 C# 解决方案:

using System;
using System.Collections.Generic;

class Solution {
    public int solution(int X, int[] A) {
        // go through the array
        // fill a hashset, until the size of hashset is X
        var set = new HashSet<int>();
        int i = 0;
        foreach (var a in A)
        {
            if (a <= X)
            {
                set.Add(a);
            }
            if (set.Count == X)
            {
                return i;
            }
            i++;
        }
        return -1;
    }
}
于 2020-06-13T16:44:46.587 回答
1

https://app.codility.com/demo/results/trainingXE7QFJ-TZ7/

我有一个使用 HashSet 的非常简单的解决方案(100% / 100%)。很多人不必要地检查 Value 是否小于或等于 X。这个任务不可能是其他的。

public static int solution(int X, int[] A) {
    Set<Integer> availableFields = new HashSet<>();

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

    return -1;
}
于 2021-03-23T15:41:35.257 回答
0

这是我的解决方案。它使用 3 个循环,但时间恒定,可编码性为 100/100。

class FrogLeap
{
    internal int solution(int X, int[] A)
    {
        int result = -1;
        long max = -1;
        var B = new int[X + 1];

        //initialize all entries in B array with -1
        for (int i = 0; i <= X; i++)
        {
            B[i] = -1;
        }

        //Go through A and update B with the location where that value appeared
        for (int i = 0; i < A.Length; i++)
        {
           if( B[A[i]] ==-1)//only update if still -1
            B[A[i]] = i;
        }

        //start from 1 because 0 is not valid
        for (int i = 1; i <= X; i++)
        {
            if (B[i] == -1)
                return -1;
            //The maxValue here is the earliest time we can jump over
            if (max < B[i])
                max = B[i];
        }

        result = (int)max;
        return result;
    }
}
于 2014-04-26T02:51:37.943 回答
0

简短而甜美的 C++ 代码。获得完美的 100%... 鼓声...在此处输入图像描述

#include <set>
int solution(int X, vector<int> &A) {
    set<int> final;
    for(unsigned int i =0; i< A.size(); i++){
        final.insert(A[i]);
        if(final.size() == X) return i;
    }
    return -1;
}
于 2018-06-04T22:51:29.663 回答
0
import java.util.Set;
import java.util.HashSet;
// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int X, int[] A) {
     Set<Integer> positionsCovered = new HashSet<Integer>(); 
//Set covering the leaves fallen to keep track of the distance to destination   

        if(X == 1)
             return 0 ;
       int position = 0;     
       for(int i = 0; i < A.length -1 ;i++ ) {       
           if(A[i] <= X && A[i] > 1 && positionsCovered.size() < (X-1)) { 
      //X-1 as we start from 1
               positionsCovered.add(A[i]);
           }
           if(positionsCovered.size()== (X-1)) {
               position = i ;
            break;
           }
       }         
        return position != 0 ? position : -1;
    }
}
于 2018-12-19T06:07:37.293 回答
0

这循环数组 A 并将数据插入数组 B (1) 到 A 中的内容指向的每个位置..

如果 A[0] = 4,那么在 B[4-1] = 1 时,这样做直到 var = X。

public static int bestSolution(int X, int[] A) {
        int[] B = new int[X];
        int var = 0;
        for (int i = 0; i < A.length; i++) {
            int content = A[i];
            if (B[content - 1] == 0) {
                B[content - 1] = 1;
                var++;
            }
            if(var == X){
                return i;
            }
        }
        return -1;
    }
于 2019-06-25T12:08:48.487 回答
0

又一个 100% 的 Java 得分:

class Solution {
    public int solution(int X, int[] A) {
        int leafs[] = new int[X];
        int count = X;
        for (int i = 0; i < A.length; i++)
        {   
            if (leafs[A[i]-1] != 1)
            {
                leafs[A[i]-1] = 1;
                count--;
            }
            if (count == 0)
                return i;
        }
        return -1;
    }
}
于 2019-11-21T15:26:13.810 回答
0

Frogt Reiver One Codility 10%

在 python 代码中几乎没有解释 100 %

def solution(X, A):
"""
https://app.codility.com/demo/results/trainingQ28RU6-FFE/
100%
idea is use array item as K_index in covered time array
covered time array set the value to be covered as soon as it finds some value
if position is already covered it checks for all items in array until any of the item in array can be covered
:param X:
:param A:
:return:
"""
# assume all position is covered
covered_time = [-1] * X
for K_index in range(0, len(A)):
    print("Covered position count " + str(X))
    print(X)
    print(covered_time)
    if covered_time[A[K_index] - 1] != -1:
        # A[K] represents the position where one leaf falls at time K
        # position is already covered
        # time is being spent
        continue
    else:
        # This position is to be covered
        # cover this position ie. make array element with marker(array value)
        covered_time[A[K_index] - 1] = K_index
        # reduce position to be cover
        X -= 1
        # as soon as positions are covered return
        if X == 0:
            # now all positions are covered
            return K_index
# if we are here it means time spent but we can not cover all positions
return -1


result = solution(5, [1, 3, 1, 4, 2, 3, 5, 4])
print("Sol " + str(result))
于 2019-12-04T07:48:08.377 回答
0

这是一个独特的解决方案[上面已经没有在 C++ 中使用多映射列出]。这在 codility 上得分 100%,检测到的 big(O) 复杂度是 O(N)。基本上构建一个位置和时间列表的多图[即秒],叶子落在该位置。

int solution(int targetPos, vector<int>& A)
{
  if(!A.size())
    return(-1);

  multimap<int, int> positionMap;
  bool insertStatus=false;
  for(size_t i=0;i<A.size();++i)
  {
    positionMap.insert(pair<int, int>(A[i], i));
    if(targetPos==A[i])
      insertStatus=true;
  }

  if(!insertStatus)
    return(-1);

  int currMax=-1;
  for(int i=1; i<=targetPos;++i)
  {
    auto iter=positionMap.equal_range(i);
    if(!distance(iter.first, iter.second))
      return(-1);

    int currMin=INT_MAX;
    for(auto it=iter.first; it!=iter.second; ++it)
    {
      if(it->second<currMin)
        currMin=it->second;
    }
    if(currMin>currMax)
      currMax=currMin;
  }

  return(currMax);
}
于 2020-08-02T02:06:04.033 回答
0

我认为这个解决方案很容易理解。如需了解详细。请让我知道您想知道哪一部分。

    static int solution(int x, int[]a){

    int currentPosition = 0;//The frog is initially located on one bank of the river (position 0) 
    int[] opositPostion = new int[x+1];//wants to get to the opposite bank (position X+1). 

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

        if (opositPostion[a[i]]== 0){
            opositPostion[i] = a[i];
            currentPosition += 1;
        }
        if (currentPosition == x){//The goal is to find the earliest time when the frog can jump to the other side of the river.
            return i;
        }
    }

    return -1;

}
于 2020-09-20T04:13:19.583 回答
0
HashSet<Integer> _hashset = new HashSet<Integer>();
        int occupiedPositions = 0;

        for (int i = 0; i < A.length; i++)
        {
            if(A[i] <= X && _hashset.add(A[i]))
            {
                occupiedPositions++;
            }

            if (occupiedPositions == X)
                return i;
        }

        return -1;

}
于 2020-09-21T08:54:22.707 回答
0
 public static int solutions(int X, int[] A) {
        Set<Integer> values = new HashSet<Integer>();

        for (int i = 0; i < A.length; i++) {
            if (values.add(A[i])) {
                X--; 
            }
            if (X == 0) {
                return i;
            }
        }
        return -1;
    }
于 2021-06-07T04:38:01.643 回答
0

另一种 C# 方法(类似于 Kamlesh Shewani 使用的方法):

using System;
using System.Collections.Generic;

class Solution {
        public int solution(int X, int[] A)
        {
            var set = new HashSet<int>(A);
            return set.Count != X ? -1 : Array.IndexOf<int>(A, new List<int>(set)[new List<int>(set).Count-1]);
        }
}
于 2021-06-21T16:27:36.370 回答
0

只是另一个在 Java 中使用哈希集的答案,得分为 100/100。

    public int solution(int X, int[] A) {            
        Set<Integer> positions = new HashSet<>();
        for(int i = 0; i < A.length; i++){
            if(A[i] <= X)
                positions.add(A[i]);
            if(positions.size() == X)
                return i;
        }
        return -1;
    }
于 2021-07-27T06:07:25.250 回答
0

Python #

我正在使用集合中的 OrderedDict 和前 n 个数字的总和来检查青蛙是否能够越过。

def solution(X, A):
    from collections import OrderedDict as od
    if sum(set(A))!=(X*(X+1))//2:
        return -1
    k=list(od.fromkeys(A).keys())[-1]
    for x,y in enumerate(A):
        if y==k:
            return x
于 2021-11-13T17:48:15.967 回答
0

在 C# 中

public static int solution(int X, int[] A)
{
    HashSet<int> hash = new HashSet<int>();

    for (int i = 0; i < A.Length; i++)
    {
        if (A[i] <= X)
        {
            hash.Add(A[i]);

            if (hash.Count == X)
                return i;
        }
    }
    return -1;
}
于 2022-02-06T08:34:27.393 回答
-1
 private static int FrogRiverOne(int X, int[] A)
        {
            HashSet<int> occ = new HashSet<int>();
            for (int i = 0; i < A.Length; i++)
            {
                if (A[i] <= X)
                {
                    occ.Add(A[i]);
                }
                if (occ.Count == X)
                    return i;
            }
            return -1;}
于 2018-10-22T21:25:25.957 回答
-1

Javascript 解决方案

function solution(X, A) {
    // write your code in JavaScript (Node.js 8.9.4)
    let minTime = -1;
    
    //initial positions with leafs
    let posFilled = Array(X+1).fill(false);
    let totalFilled = 0;

    for(let i=0; i<A.length; i++){
        let step = A[i];
        
        //if already filled, don't add to total filled
        if(step <= X && !posFilled[step]) {
            posFilled[step] = true;
            
            //increment total filled
            totalFilled += 1;
        }

        //if all have been filled, set min time and break        
        if(totalFilled === X){
            minTime = i;
            
            break;
        }
    }
    
    return minTime;
}
于 2020-06-22T21:24:11.773 回答