Question

尝试解决实践和处理this的衔接课程。

用Java编写我的代码并在广泛的输入上测试代码，但是代码测试结果中的extreme_min_max，single和double的代码都失败了。

假设：

N是[1..100,000]范围内的整数数组A的每个元素都是[1..1,000,000,000]范围内的整数。

我的代码说明：
1.对给定的数组进行排序 2.迭代数组中的每个元素以找出每个连续对之间的差异。如果差值不是1，那么它不是烫发因此返回0.如果数组中只有一个元素，则返回1.

有人可以帮我查一下我的代码中的错误吗？

我的代码：

public int solution(int[] A)
{
    if(A.length == 1)
        return 1;

    Arrays.sort(A);
    for (int i = 0; i < A.length-1; i++)
    {
        long diff = Math.abs(A[i] - A[i+1]);
        if(diff!=1)
            return 0;
    }
    return 1;
}

Answer 1

这是一个简单而且更好的实现，它以O(N)时间复杂度运行，占用O(N)空间复杂度。

public int solution(int[] A)
{ 
    int size = A.length;
    int hashArray[] = new int[size+1];

    for (int i = 0; i < size; i++)
    {
        if(A[i]>size)
            return 0;
        else
            hashArray[A[i]]+=1;
    }
    for(int i=1;i<=size;i++)
    if(hashArray[i]!=1)
    return 0;

    return 1;
}

Answer 2

非常简单：

您的代码没有检查这种情况：

排列是一个序列，包含每个元素从1 到N一次，只有一次。

确保排序后的第一个元素为1，一切都应该有效。

Answer 3

我对Java语法不是很了解，但你想要做的是：

创建temp的数组A - 初始化为0。
转到A并执行temp[A[i]]++。
转到temp，如果数组中的任何位置不是1，则返回false。

Answer 4

如果存在重复 - 返回0我已实现100％传递 https://codility.com/demo/results/trainingWX2E92-ASF/

public static int permCheck(int A[]){

Set<Integer> bucket = new HashSet<Integer>();
int max = 0;
int sum=0;
for(int counter=0; counter<A.length; counter++){
    if(max<A[counter]) max=A[counter];
    if(bucket.add(A[counter])){
        sum=sum+A[counter];
    }
    else{
        return 0;
    }
}
System.out.println(max+"->"+sum);
int expectedSum = (max*(max+1))/2;
if(expectedSum==sum)return 1;

return 0;

}

Answer 5

这是我的第一个100％代码。我不能说它是否最快，但看起来都是正确的 - 请注意双OR（||）条件。

import java.util.Arrays;

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

      int i = 0;
      int size = A.length;

      if ( size > 0 && size < 100001)
      {
          // Sort the array ascending:
          Arrays.sort(A);

          // Check each element:
          for(i = 0; i < size; i++)
             if ( A[i] > size || A[i] != (i + 1) )
                return 0;
          return 1;
      }
      return 0;
   }
}

修改实际上，我们不必担心有效的第一个元素数据（即A [i]> 0），因为在排序之后，有效的perm数组必须具有A [0] = 1并且这已经被条件A [i]覆盖= i + 1。数组条目的上限（> 1,000,000,000）受到数组大小本身限制（100,000）的限制，我们必须在这里检查是否符合，因为会有一个Codility测试。所以我删除了数组条目的下限条件。

Answer 6

在C＃中尝试（得分100％）：

using System;
using System.Linq;

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

     if (A.Any(x => x == 0)) { return 0; }
         var orderSelect = A.OrderBy(x => x).GroupBy(x => x);
         if (orderSelect.Any(x => x.Count() > 1)) { return 0; }
         var res = Enumerable.Range(1, A.Length).Except(A);
         return res.Any() ? 0 : 1;           
    }
  }

Answer 7

下面的代码运行并给了我 100%，时间复杂度是 O(n)：

    private static int solution(int[] A) {
    int isPermutation = 1; // all permutations start at 1
    int n = A.length;
    Arrays.sort(A);

    if (n == 0) return 0; // takes care of edge case where an empty array is passed

    for (int i = 0; i < n; i++) {
        if (A[i] != isPermutation) { //if current array item is not equals to permutation, return 0;
            return 0;
        }
        isPermutation++;
    }
    return 1;
}

Codility PermCheck解决方案并不是在处理一些数据集

7 个答案: