C# 一种较好的蛙式杂交算法

我正在从Codibility解决以下问题：

def solution(X, A):
    N = len(A)
    count = [0] * (X+1)
    steps = 0
    for k in xrange(N):
        if not count[A[k]]:
            count[A[k]] = 1
            steps += 1
            if steps == X:
                return k
    return -1

def solution(x, a)

  check_array = (0..a.length).to_a
  check_array.each { |i| check_array[i]=0 }

  a.each_with_index do |element, i|

      if (check_array[element]==0)
          check_array[element]=1
          x -= 1
      end

      return i if (x==0)
  end

  return -1

end

一只小青蛙想去河的对岸。青蛙目前位于位置0，想要到达位置X。树叶从树上落在河的表面上。 您将获得一个非空的零索引数组，该数组由表示落叶的N个整数组成。A[K]表示一片树叶在时间K落下的位置，以分钟为单位。 目标是找到青蛙能跳到河对岸的最早时间。青蛙只有在从1到X的每一个位置都出现树叶时才能过河

我使用了以下解决方案，但只得到了81分：

代码用C#表示

使用系统；
使用System.Collections.Generic；
类解决方案{
公共int解决方案（int X，int[]A）{
bool[]tiles=新bool[X]；
for（int i=0；i

---

我的算法以O（NX）运行。有什么更好的算法只需要O（N）？

将代码更改为以下内容：

public int solution(int X, int[] A) 
{
    bool[] tiles = new bool[X];
    int todo = X;

    for (int i = 0; i < A.Length; i++)
    {
        int internalIndex = A[i] - 1;
        if (internalIndex < X && !tiles[internalIndex])
        {
            todo--;
            tiles[internalIndex] = true;
        }

        if (todo == 0)
            return i;
    }

    return -1;
}

public int解决方案（int X，int[]A）
{
bool[]tiles=新bool[X]；
inttodo=X；
for（int i=0；i

这个算法只需要

O（A.length）

时间，因为它总是跟踪我们还需要用树叶填充多少“洞”

这是怎么做到的

todo

是构建树叶“桥梁”所需的树叶数量。每当一片叶子落下时，我们首先检查它落下的位置是否有一片叶子。如果没有，我们减少todo，填补漏洞，继续。

---

只要

todo

到达

0

，整个河流就被覆盖了；）

虽然我同意你得到100分，但它并不满足所有测试用例

对于1,3,1,4,2,3,5,4的样本数据

如果你试图找到3，它应该返回5，但是给出的答案抛出了一个异常

修正后的版本为，因为在第四分钟后，位置2处出现故障的叶片完成

    public int solution(int X, int[] A)
    {
                int steps = -1;
        bool[] tiles = new bool[X];

        int todo = X;
        for (int i = 0; i < A.Length; i++)
        {
            steps += 1;
            int internalIndex = A[i] - 1;
            if (internalIndex < tiles.Length)
            {
                if (!tiles[internalIndex])
                {

                    todo--;

                    tiles[internalIndex] = true;

                }
            }
            if (todo == 0)

                return steps;
        }
        return -1;
    }

public int解决方案（int X，int[]A）
{
int步数=-1；
bool[]tiles=新bool[X]；
inttodo=X；
for（int i=0；i

这让我100/100

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

    long combA = ((long) X)*(((long) X) + 1)/2;
    long sumA = 0;

    int[] countA = new int[X];

    for (int i = 0; i < A.Length; i++)
    {
        countA[A[i] - 1] += 1;

        if (countA[A[i] - 1] > 1)
        {
            countA[A[i] - 1] = 1;
        }
        else
        {
            sumA += A[i];
        }


        if (sumA == combA)
        {
            z = i;
            break;
        }

    }

    return z;
}

public int解决方案（int X，int[]A）
{
int z=-1；
长梳=（（长）X）*（（长）X）+1）/2；
长sumA=0；
int[]countA=新的int[X]；
for（int i=0；i1）
{
countA[A[i]-1]=1；
}
其他的
{
sumA+=A[i]；
}
if（sumA==combA）
{
z=i；
打破
}
}
返回z；
}

下面是我提出的一个Python解决方案（Codibility为100/100）：

---

这是一个简单的C++解决方案：

int solution(int X, vector<int> &A)
{
  vector<bool> removed( X );

  for( size_t i = 0; i < A.size(); i++ )
  {
    if( removed[ A[i] - 1 ] == false )
    {
      removed[ A[i] - 1 ] = true; 
      X--;

      if(X == 0)
      {
        return i;
      } 
    }
  }

  return -1; 
}

int解决方案（int X，向量&A）
{
去除向量（X）；
对于（size_t i=0；i100%分数：FrogRiverOne的PHP代码：Ajeet Singh

function solution($X, $A) {
    for ($i = 0; $i < count($A); $i++){        
        if (!isset($position_achieved[$A[$i]])){
            $X--;   // reduce X by one position is achieved
            $position_achieved[$A[$i]] = true;
        }
        if (!$X){
            return $i;
        }
    }
    return -1;    
}

函数解决方案（$X，$A）{
对于（$i=0；$i
Ruby解决方案（100/100可编码）：

我偶然发现这个练习有点晚了。除了
C90
，我看到了很多语言。和许多人一样，我也通过创建辅助阵列找到了解决方案。我使用了典型的
calloc
，然后是
free
。我的第一个解决方案与其他帖子类似：

int solution(int X, int A[], int N)
{
    int *n = calloc(X, sizeof(*A));
    int index;

    for (index = 0; index < N; index++) {
        if (n[A[index] - 1] == 0) {
            n[A[index] - 1] = 1;
            if (--X == 0) {
                free(n);
                return index;
            }
        }
    }

    free(n);
    return -1;
}

我的两种解决方案都通过了所有测试。
这是我的C99解决方案，可能不是最优雅的。但我希望它是可读和可理解的。这是我测试的链接

int解决方案（intx，inta[]，intn）{
如果（X100%，C#

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
使用系统集合；
公共int解决方案（int X，int[]A）
{
//用C#5.0和.NET4.5（Mono）编写代码
int N=A.长度；
int步长=0；
列表k=新列表（）；
对于（int i=0；i=X-1&（k.Contains（0）=false））
{
返回i；
}
}
返回-1；
}
下面是另一种使用字典的方法：


public int解决方案（int X，int[]A）{
int solution(int X, int A[], int N)
{
    int *n = calloc(X, sizeof(*A));
    int index;

    for (index = 0; index < N; index++) {
        if (n[A[index] - 1] == 0) {
            n[A[index] - 1] = 1;
            if (--X == 0) {
                free(n);
                return index;
            }
        }
    }

    free(n);
    return -1;
}

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

    int index;
    int leaftimeidx;

    for (index = 0; index < N; index++) {
        leaftimeidx = abs(A[index]) - 1;

        if (A[leaftimeidx] > 0) {
            A[leaftimeidx] *= -1;

            if (--X == 0)
                return index;
        }
    }
    return -1;
}

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

    if (X <= 1) return 0; //if we only need to go 1 step we are already there
    if (N == 0) return -1;//if we don't have timing we can't predict 

    int B[X+1];

    for (int i=0; i <= X; i++) {
        B[i] = -1; //i set default value to -1 so i can see later if we missed a step. 
    }

    for (int i=0; i < N; i++) {
        if (A[i] <= X && (B[A[i]] == -1 || B[A[i]] > i)) B[A[i]] = i; //prepare my second array here with timing data 
    }

    int max_min = 0; //store the highest timing later on.

    for (int i=1; i <= X; i++) {
        if (B[i] == -1) return -1; //if we have any elements with -1 then we didn't cross the river
        if (max_min < B[i]) max_min = B[i]; //keep setting the highest timing seen the steps.
    }

    return max_min;
}

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Collections;

  public int solution(int X, int[] A)
{
    // write your code in C# 5.0 with .NET 4.5 (Mono)

    int N = A.Length;
    int step = 0;
    List<int> k = new List<int>();


    for (int i = 0; i < X; i++)
    {
        k.Add(0);
    }

    //Inserts an element into the ArrayList at the specified index.
    for (int i = 0; i < N; i++)
    {
        int diff = A[i] - 1;

        k[diff] = A[i];

        if (i >= X-1 && (k.Contains(0) == false))
        {
           return i;

        }

    }


    return -1;

}

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

    public int solution(int X, int[] A) {
            Hashtable spaces = new Hashtable();
            int counter = 0;
            foreach(int i in A)
            {
                //Don't insert duplicate keys OR 
                //keys greater than requested path length
                if (!spaces.ContainsKey(i) && i <= X)
                    spaces.Add(i, i);

                //If Hashtable contents count = requested number of leaves,
                //then we're done
                if (spaces.Count == X)
                    return (counter);

                counter++;
            }

            return -1;
    }


public int solution(int X, int[] A)
{
    SortedSet<int> leaves = new SortedSet<int>();
    for (int i = 0; i < A.Length; i++)
    {
        leaves.Add(A[i]);
        if (leaves.Count() == X) return i;
    }
    return -1;
}