Question

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

Codility测试：

PermCheck

检查数组A是否为排列。

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

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

例如，数组A[0] = 4 A[1] = 1 A[2] = 3 A[3] = 2使得：

是一个排列，但数组A[0] = 4 A[1] = 1 A[2] = 3是这样的：

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

目标是检查数组class Solution { public int solution(int[] A); }是否为排列。

写一个函数：

给定零索引数组returns 1，如果数组A是排列，则0，如果不是，则为A[0] = 4 A[1] = 1 A[2] = 3 A[3] = 2。

例如，给定数组A使得：

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

该函数应返回1.

给定数组A：

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

该函数应返回0.

假设：

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

复杂度：

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

100％得分解决方案（从互联网上找到）：

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;

}

我的解决方案：

{{1}}

Answer 1

使用import tkinter from tkinter import * from tkinter import ttk from tkinter.ttk import * encryption_code = 'LFWOAYUISVKMNXPBDCRJTQEGHZ' window = tkinter.Tk() window.title("Encryption/Decryption") change_frame = tkinter.Frame(window) changed_frame = tkinter.Frame(window) encrypt_entry = tkinter.Entry(change_frame) def code_change(): global changed_frame global encrypt_entry print(len(encrypt_entry.get())) if encrypt_entry.get() == 'LFWOAYUISVKMNXPBDCRJTQEGHZ' or 'ABCDEFGHIJKLMNOPQRSTUVWXYZ': encrypt_entry.delete(0, tkinter.END) changed_incorrect.configure(background=window.cget('bg')) changed_incorrect.config(text="Please enter a different code", foreground='red') changed_incorrect.pack() changed_frame.pack() if len(encrypt_entry.get()) == 26: encryption_code = encrypt_entry.get() encrypt_entry.delete(0, tkinter.END) changed_label.configure(background=window.cget('bg')) changed_label.config(text="You have successfully changed the encryption code!") change_header.config(text=str(encryption_code)) changed_incorrect.pack_forget() changed_label.pack() changed_frame.pack() elif len(encrypt_entry.get()) < 26 or len(encrypt_entry.get()) > 26: changed_incorrect.configure(background=window.cget('bg')) changed_incorrect.config(text="Please enter only 26 characters", foreground='red') changed_label.pack_forget() changed_incorrect.pack() changed_frame.pack() change_label = tkinter.Label(change_frame, text="Please enter your own encryption code in block capitals", font=('Helvetica', 12)) change_header = tkinter.Label(change_frame, text="Make sure it is all 26 letters and do not repeat a letter to prevent errors", font=('Helvetica', 12)) change_confirm = ttk.Button(change_frame, text="Confirm", width=20, command=code_change) changed_label = tkinter.Label(changed_frame, text="You have successfully changed the encryption code!", font=('Helvetica', 14)) changed_incorrect = tkinter.Label(changed_frame, text="Please enter your code again", font=('Helvetica', 14)) change_label.pack() change_header.pack() encrypt_entry.pack() change_confirm.pack() change_frame.pack() window.mainloop()是一种原创，但我不会这样做。

要评论您的代码，可能因为以下原因而无效：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;

}

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

Java - 帮助理解密码性代码

3 个答案: