在Codility中找到缺少的整数

Question

I need to "Find the minimal positive integer not occurring in a given sequence. "
  A[0] = 1    
  A[1] = 3    
  A[2] = 6
  A[3] = 4    
  A[4] = 1    
  A[5] = 2, the function should return 5.

Assume that:

        N is an integer within the range [1..100,000];
        each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].

我在编码中编写了代码，但在许多情况下它没有用，性能测试给出了0％。请帮帮我，我错了。

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

    if(A.Length ==0) return -1;
    int value = A[0];
    int min = A.Min();
    int max = A.Max();
    for (int j = min+1; j < max; j++)
    {
      if (!A.Contains(j))
      {
          value = j;
          if(value > 0)
          {
             break;
          }
      }
    }

    if(value > 0)
    {
      return value;
    }
    else return 1;
  }
}

除了示例，正面和负面的唯一值之外，该代码会给出所有错误。

Answer 1

修改：添加了详细信息，可以更直接地回答您的实际问题。

  

“请帮助我，我错了。”

就正确性而言：考虑A = {7,2,5,6,3}。给定A的内容，正确的输出是1，但我们的算法将无法检测到这一点，因为A.Min（）将返回2，我们将从{{开始循环1}}向前。在这种情况下，我们会返回3;因为它是下一个缺失值。

类似4之类的东西。此处的最小缺失正整数再次为A = {14,15,13}，并且由于 all 存在13-15的值，因此1变量将保留其初始值{{1} }这将是value。

就效果而言：考虑value=A[0]，14和A.Min()在幕后所做的事情;其中每一个都完整地循环遍历A.Max()，在A.Contains()的情况下，我们重复调用A和我们可以找到的最低正整数之间的每个值。这将使我们远远超出Codility正在寻找的指定Contains性能。

相比之下，这是我能想到的最简单的版本，应该在Codility上获得100％的分数。请注意，我们只会遍历Min()一次，并且我们会利用O(N)来使用A;一种更快的方法，不需要循环遍历整个集合来查找值。

Dictionary

Answer 2

使用C＃得分为100％的简单解决方案

int Solution(int[] A)
    {            
        var A2 = Enumerable.Range(1, A.Length + 1);
        return A2.Except(A).First();
    }

Answer 3

获得满分的最简单的解决方案是：

public int solution(int[] A)
{
    int flag = 1;

    A = A.OrderBy(x => x).ToArray();

    for (int i = 0; i < A.Length; i++)
    {
        if (A[i] <= 0)
            continue;
        else if (A[i] == flag)
        {
            flag++;
        }

    }

    return flag;
}

Answer 4

C中的MissingInteger解决方案

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

   int i=0,r[N];

   memset(r,0,(sizeof(r)));

   for(i=0;i<N;i++)
   {
       if(( A[i] > 0) && (A[i] <= N)) r[A[i]-1]=A[i];
   }

   for(i=0;i<N;i++)
   {
       if( r[i] != (i+1)) return (i+1);
   }

   return (N+1);
}

Answer 5

public class Solution {
    public int solution( int[] A ) {
        return Arrays.stream( A )
                     .filter( n -> n > 0 )
                     .sorted()
                     .reduce( 0, ( a, b ) -> ( ( b - a ) > 1 ) ? a : b ) + 1;
    }
}

似乎最简单的是过滤掉负数。然后对流进行排序。然后减少它得出答案。这是一种实用的方法，但得到100/100的测试分数。

Answer 6

c＃最简单的解决方案是：

int value = 1;

        int min = A.Min();
        int max = A.Max();
        if (A.Length == 0) return value = 1;

        if (min < 0 && max < 0) return value = 1;


        List<int> range = Enumerable.Range(1, max).ToList();
        List<int> current = A.ToList();

        List<int> valid = range.Except(current).ToList();

        if (valid.Count() == 0)
        {
            max++;
           return value = max;
        }
        else
        {
          return  value = valid.Min();
        }

考虑到数组应该从1开始，或者它是否需要从最小值开始，而不是Enumerable.range应该从Min开始

Answer 7

到目前为止[1_000_000 ... 1_000_000]最快的C＃解决方案。

    public int solution(int[] array)
    {
        HashSet<int> found = new HashSet<int>();
        for (int i = 0; i < array.Length; i++)
        {
            if (array[i] > 0)
            {
                found.Add(array[i]);
            }
        }

        int result = 1;
        while (found.Contains(result))
        {
            result++;
        }

        return result;
    }

Answer 8

获得100％-C＃高效解决方案

     public int solution (int [] A){
        int len = A.Length;
        HashSet<int> realSet = new HashSet<int>();
        HashSet<int> perfectSet = new HashSet<int>();

        int i = 0;
        while ( i < len)
        {
            realSet.Add(A[i]);   //convert array to set to get rid of duplicates, order int's
            perfectSet.Add(i + 1);  //create perfect set so can find missing int
            i++;
        }
        perfectSet.Add(i + 1);

        if (realSet.All(item => item < 0))
            return 1;

        int notContains = 
         perfectSet.Except(realSet).Where(item=>item!=0).FirstOrDefault();
        return notContains;
}

Answer 9

的另一个100％A小版本与C＃

using System.Linq;

class Solution
{
    public int solution(int[] A)
    {
        // write your code in C# 6.0 with .NET 4.5 (Mono)
        var i = 0;
        return A.Where(a => a > 0).Distinct().OrderBy(a => a).Any(a => a != (i = i + 1)) ? i : i + 1;
    }
}

Answer 10

class Solution {
    public int solution(int[] A) {
        var sortedList = A.Where(x => x > 0).Distinct().OrderBy(x => x).ToArray();

        var output = 1;
        
        for (int i = 0; i < sortedList.Length; i++)
        {
            if (sortedList[i] != output)
            {
                return output;
            }

            output++;
        }

        return output;
    }
}

Answer 11

使用具有O（n）时间复杂度的哈希表的JavaScript解决方案。

function solution(A) {
  let hashTable = {}
  for (let item of A) {
    hashTable[item] = true
  }

  let answer = 1

  while(true) {
    if(!hashTable[answer]) {
      return answer
    }
    answer++
  }
}

Answer 12

好吧，这是现在的新赢家。至少在C＃和我的笔记本电脑上。与大多数其他解决方案相比，它比以前的冠军要快1.5-2倍，并且要快3-10倍。此解决方案的功能（或错误？）是仅使用基本数据类型。以及100/100的Codility。

public int Solution(int[] A)
{
    bool[] B = new bool[(A.Length + 1)];
    for (int i = 0; i < A.Length; i++)
    {
        if ((A[i] > 0) && (A[i] <= A.Length))
            B[A[i]] = true;
    }

    for (int i = 1; i < B.Length; i++)
    {
        if (!B[i])
            return i;
    }

    return A.Length + 1;
}

Answer 13

这是我在javascript中的解决方案

<button onclick="document.body.innerHTML += (Math.floor(Math.random() * ( 989000000 - 988000000 ) + 987000000 ) + '<br>' );">Gerar Números</button><br>

Answer 14

此解决方案的得分为100％： https://app.codility.com/demo/results/trainingUFKJSB-T8P/

   public int MissingInteger(int[] A)
    {
        A = A.Where(a => a > 0).Distinct().OrderBy(c => c).ToArray();
        if (A.Length== 0)
        {
            return 1;
        }
        for (int i = 0; i < A.Length; i++)
        {
            //Console.WriteLine(i + "=>" + A[i]);
            if (i + 1 != A[i])
            {
                return i + 1;
            }
        }

        return A.Max() + 1;
    }

Answer 15

1. Insert 10 columns to the right, name them "Option 1", "Option 2", "Option 3" ..... "Option 10"
2. In each cell of the first column, if "Option x" exists, split/copy/move to the column named "Option x" (Where x can be 1, 2 .... 10)

Answer 16

我尝试在C＃中使用递归而不是排序，因为我认为这样做会显示出更多的编码技巧，但是在扩展测试中，它在大型性能测试中的表现不佳。假设最好只是简单地做一下。

class Solution {
public int lowest=1;
public int solution(int[] A) {
    // write your code in C# 6.0 with .NET 4.5 (Mono)
    if (A.Length < 1)
        return 1;
     for (int i=0; i < A.Length; i++){
         if (A[i]==lowest){
            lowest++;
            solution(A);
         }
     }

     return lowest;  
    }
}

Answer 17

我的Java解决方案得分为100/100

def process_alert(alert):
    print(alert)
    if alert['Severity'] = 'really serious alert':
        email_support(alert)

for alert in live_alerts:
    process_alert(alert)

最差的时间在“ large_2”测试用例上，为0.292s。

我会说很好。

希望您可以在C＃中找到等效项

干杯。

Answer 18

C＃ - MissingInteger

  

找出1到1000.000之间的最小缺失整数。

     

OP的假设发生

TaskScore / Correctness / Performance：100％

using System;
using System.Linq;

namespace TestConsole
{
    class Program
    {
        static void Main(string[] args)
        {
            var A = new int[] { -122, -5, 1, 2, 3, 4, 5, 6, 7 }; // 8
            var B = new int[] { 1, 3, 6, 4, 1, 2 }; // 5
            var C = new int[] { -1, -3 };  // 1
            var D = new int[] { -3 };  // 1
            var E = new int[] { 1 };  // 2
            var F = new int[] { 1000000 };  // 1


            var x = new int[][] { A, B, C, D, E, F };

            x.ToList().ForEach((arr) =>
            {
                var s = new Solution();
                Console.WriteLine(s.solution(arr));
            });

            Console.ReadLine();
        }
    }

    // ANSWER/SOLUTION
    class Solution
    {
        public int solution(int[] A)
        {
            // clean up array for negatives and duplicates, do sort
            A = A.Where(entry => entry > 0).Distinct().OrderBy(it => it).ToArray();
            int lowest = 1, aLength = A.Length, highestIndex = aLength - 1;

            for (int i = 0; i < aLength; i++)
            {
                var currInt = A[i];
                if (currInt > lowest) return lowest;
                if (i == highestIndex) return ++lowest;
                lowest++;
            }
            return 1;
        }
    }
}

Answer 19

在C＃中，您可以通过使用内置库函数来解决问题。对于非常大的整数，性能如何低

public int solution(int[] A)
{
    var numbers = Enumerable.Range(1, Math.Abs(A.Max())+1).ToArray();
    return numbers.Except(A).ToArray()[0];
}

如果您找到更好的解决方案性能，请告诉我

Answer 20

class Solution {
    public int solution(int[] A) {
    int size=A.length;
    int small,big,temp;
    for (int i=0;i<size;i++){
        for(int j=0;j<size;j++){
            if(A[i]<A[j]){
                temp=A[j];
                A[j]=A[i];
                A[i]=temp;
            }
        }


    }   

    int z=1;
    for(int i=0;i<size;i++){
        if(z==A[i]){
            z++;
        }

        //System.out.println(a[i]);
    }
    return z;       

    }





enter code here

}

Answer 21

我的解决方案：

public static int solution()
    {
        var A = new[] { -1000000, 1000000 }; // You can try with different integers

        A = A.OrderBy(i => i).ToArray(); // We sort the array first

        if (A.Length == 1) // if there is only one item in the array
        {
            if (A[0]<0 || A[0] > 1)
                return 1;
            if (A[0] == 1)
                return 2;
        }
        else // if there are more than one item in the array
        {
            for (var i = 0; i < A.Length - 1; i++)
            {
                if (A[i] >= 1000000) continue; // if it's bigger than 1M
                if (A[i] < 0 || (A[i] + 1) >= (A[i + 1])) continue; //if it's smaller than 0, if the next integer is bigger or equal to next integer in the sequence continue searching.
                if (1 < A[0]) return 1;
                return A[i] + 1;
            }
        }

        if (1 < A[0] || A[A.Length - 1] + 1 == 0 || A[A.Length - 1] + 1 > 1000000)
            return 1;
        return A[A.Length-1] +1;
    }

Answer 22

这是获得100％范围的Java解决方案。

public static int solution(int[] a) {
    int[] temp = new int[a.length];

    for(int i = 0; i < a.length; i++) {
        if (a[i] < 1 || a[i] > a.length) {
            continue;
        }else {
            temp[a[i] - 1] = 1;
        }
    }

    for(int i = 0; i < temp.length; i++)
    {
        if (temp[i] != 1) {
            return i + 1;
        }
    }
    return temp.length + 1;
}

Answer 23

expr

Answer 24

您应该只使用HashSet，因为它的查找时间也是常量，而不是字典。代码更简洁。

public int solution (int [] A){

    int answer = 1;
    var set = new HashSet<int>(A);
    while (set.Contains(answer)){
       answer++;
    }

    return answer;
}

Answer 25

此代码段应正常工作。

Sep  5 12:33:46 servername rsyslogd: message repeated 48 times: [-- MARK --]