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