Java - 帮助理解编码代码

Question

对于 PermCheck codility 测试，我编写了一个解决方案（请参见下文），但它仅真正解决了 codility 测试中给出的示例，因为数组中只有几个值且值很小。 我还在下面添加了得分为 100% 的代码，这是我在互联网上找到的代码。 该代码看起来与我的非常不同，我无法弄清楚他/她是如何得到答案的。 有人可以请逐步解释代码以及它是如何产生答案的。

Codility 测试：

永久检查

检查数组 A 是否为排列。

给出了一个由 N 个整数组成的非空零索引数组 A。

置换是包含从 1 到 N 的每个元素一次且仅一次的序列。

例如，数组A使得：

A[0] = 4
A[1] = 1
A[2] = 3
A[3] = 2

是一个排列，但数组A使得：

A[0] = 4
A[1] = 1
A[2] = 3

不是排列，因为缺少值 2。

目标是检查数组A是否是排列。

写一个函数：

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

给定一个零索引数组A ，如果数组A是排列，则returns 1否则returns 1 0 。

例如，给定数组 A 使得：

A[0] = 4
A[1] = 1
A[2] = 3
A[3] = 2

该函数应返回 1。

给定数组 A 使得：

A[0] = 4
A[1] = 1
A[2] = 3

该函数应返回 0。

假使，假设：

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

复杂：

• 预期的最坏情况时间复杂度为 O(N)
• 预期的最坏情况空间复杂度为 O(N)，超出输入存储（不包括输入参数所需的存储）。
• 可以修改输入数组的元素。

100% 分数解决方案（来自互联网）：

public static final int NOT_PERMUTATION = 0;
public static final int PERMUTATION = 1;
// (4,1,3,2) = 1
// (4,1,3) = 0
// (1) = 1
// () = 1
// (2) = 0
public int PermSolution(int[] A) {
    // write your code in Java SE 8
    int[] mark = new int[A.length + 1];
    int counter = 0;

    for (int i = 0; i < A.length; ++i) {
        int value = A[i];
        if(value >= mark.length) {
            return NOT_PERMUTATION;
        }
        if(mark[value] == 0) {
            mark[value]=1;
            ++counter;
        } else {
            return NOT_PERMUTATION;
        }
    }

    return counter == A.length ? PERMUTATION : NOT_PERMUTATION;
}

我的解决方案：

public int PermSolution(int[] A)
{
    int perm = 1;

    Arrays.sort(A);

    if (A[0] != 1) return 0;

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

        if (A[i] + 1 != A[i + 1])
        {
            return 0;
        }
    }

    return perm;

}

Answer 1

使用Arrays.sort()是一种原创，但我不会这样做。

要评论您的代码，它可能无法正常工作，因为： return perm;

假设您有这个不是排列的数组：

A[0] = 4
A[1] = 1
A[2] = 2

你执行Arrays.sort(A) ，你会得到这个：

A[0] = 1
A[1] = 2
A[2] = 4

现在让我们执行你的代码：

if (A[0] != 1) return 0;

A[0]确实等于1接下来，对于i==0我们有：

  if (A[i] + 1 == A[i + 1])
    {
        return perm;
    }

A[i] + 1等于2并且A[i+1]也等于2如果条件为true ，则执行return perm; 因此，您以return 1结束执行。

实际上，只要您的数组包含1和2 ，此函数将始终return 1

要使其正常工作，您必须在实际返回值之前检查所有数组。

这应该工作：

public int PermSolution(int[] A)
{

int perm = 1;
Arrays.sort(A);

if (A[0] != 1) return 0;

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

return perm;

}

为了进一步优化它，这也应该有效：

public int PermSolution(int[] A)
    {

    Arrays.sort(A);

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

    return 1;

    }

Answer 2

我们为什么不避免 Arrays.sort(A) 以通过以下方式获得计算效率：

public static int PermSolution(int[] A)
{
    int len=A.length;
    if(len==1)
        return A[0]==1 ? 1 : 0;

    BitSet set=new BitSet(len+2);

    for (int i = 0; i < len; i++)
    {
        if(A[i]>len || set.get(A[i]))
            return 0;

        set.set(A[i]);
    }
    return set.nextClearBit(1)==(len+1) ? 1 : 0;
}

Answer 3

这是我开发的一些解决方案。 不确定约束，如果有人可以帮助对它们进行测试。 谢谢人们！

private static int solution(int[] arr) {

        int perm=1;
        boolean b=false;
        Arrays.sort(arr);
        int i=0;
        while (i<=arr.length) {
            if(i < arr.length-2)
                b = arr[i+1]-1 == (arr[i]);
            if(b) {
                System.out.println("if " + i);
                i++;
                perm=1;
            }else {
                System.out.println("else " + i);
                perm = 0;
                break;
            }
        }   
        return perm;
    }