Java-帮助理解代码

对于PermCheck Codibility测试，我编写了一个解决方案（请参见下文），但它只真正解决了Codibility测试中给出的示例，因为数组中只有少数值和较小的值。我还在下面添加了代码，分数为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;

}

PermCheck

检查数组A是否为置换

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

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

例如，数组

A

，以便：

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

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

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

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

是一种排列，但数组

是一种

，因此：

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

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

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

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

不是置换，因为缺少值2

目标是检查数组

A

是否为排列

编写一个函数：

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

即，给定一个零索引数组

a

，

如果数组
a
是排列，则返回1

，如果数组

a

不是排列，则返回0

例如，给定一个数组，使得：

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

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

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

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

函数应该返回1

给定一个数组，以便：

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

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

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

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

函数应返回0

假设：

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

复杂性：

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;

}

• 预期最坏情况时间复杂度为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;

}

public static final int NOT_PERMUTATION=0；
公共静态最终整数置换=1；
// (4,1,3,2) = 1
// (4,1,3) = 0
// (1) = 1
// () = 1
// (2) = 0
公共int PermSolution（int[]A）{
//用JavaSE8编写代码
整数[]标记=新整数[A.长度+1]；
int计数器=0；
对于（int i=0；i=标记长度）{
返回不_排列；
}
如果（标记[值]==0）{
标记[值]=1；
++计数器；
}否则{
返回不_排列；
}
}
返回计数器==A.length？置换：非置换；
}

我的解决方案：

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;

}

public int PermSolution（int[]A）
{
int perm=1；
数组。排序（A）；
如果（A[0]！=1）返回0；
for（int i=0；i

使用

数组。sort（）

有点原始，但我不会这样做

要注释您的代码，它可能因为以下原因不起作用：

return perm

假设这个数组不是排列：

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

如果执行数组排序（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

，则执行

返回perm1

实际上，只要数组包含

1

和

2

，此函数将始终

返回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）
{
int perm=1；
数组。排序（A）；
如果（A[0]！=1）返回0；
for（int i=0；i

为了进一步优化它，这也应该起作用：

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;

    }

public int PermSolution（int[]A）
{
数组。排序（A）；
for（int i=0；i

为什么我们不避免数组。排序（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;
}

公共静态int PermSolution（int[]A）
{
int len=A.长度；
如果（len==1）
返回A[0]==1？1:0；
位集=新位集（len+2）；
对于（int i=0；ilen | | set.get（A[i]））
返回0；
set.set（A[i]）；
}
返回集.nextClearBit（1）=（len+1）？1:0；
}

以下是我开发的一些解决方案。不确定约束，如果有人可以帮助测试它们。谢谢大家

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

私有静态int解决方案（int[]arr）{
int perm=1；
布尔b=假；
数组。排序（arr）；
int i=0；
while（iHint:Arrays.sort的复杂性是什么

？这不是课程作业/家庭作业。这是我在自己的时间里做的事情。我不明白stackoverflow的意义是什么，如果它不用于从其他编码人员那里获得帮助的话？任务很简单，除非代码太难让其他人也理解？@user2886115不要担心一个粗鲁的评论，如果你感觉到的话，请标记它。实际上，哟你的问题结构合理，但不清楚。你的解决方案有效吗？？？，如果没有…你被困在哪里了？如果是的，你必须把这个问题放在Codibility上。Codibility不仅仅是为学生们准备的。来源：我已经在面试中接受了Codibility测试。OP似乎在寻求优化建议，因为他的代码只适用于较小的样本。Jordi Castilla，我的同事解决方案有效，但得分很低，因为它只在几秒钟内有效