Question

对于以下的代码性任务，从性能的角度来看，我的解决方案是100％正确的，从正确性的角度来看，80％是正确的。我的解决方案是两个元素失败，但我用不同的值（两个元素）测试它，我得到了所需的输出。请让我知道如何解决这个问题。

Codility任务链接 https://app.codility.com/programmers/lessons/4-counting_elements/perm_check/

我的代码：

 import java.util.*;
class Solution {
    public int solution(int[] A) {
        if(A.length == 1){
                if(A[0] != 1)
                    return 0;
                else
                    return 1;
            }
                Arrays.sort(A);
                for(int i =1; i<A.length; i++){                 
                    if(A[i] - A[i-1] != 1){
                        return 0;
                    }
                }
            return 1;
    }
}

测试用例失败：

double  two elements ✘WRONG ANSWER  got 1 expected 0
1. 0.004 s OK
2. 0.004 s OK
3. 0.004 s WRONG ANSWER,  got 1 expected 0
4. 0.004 s OK

Answer 1

除了你的解决方案不是O（N）之外，你接受任何带有序号的数组，即使序列没有从1开始。用[3,4]或[7,9,8]测试。

使用您当前的解决方案，您需要检查A [i] == i + 1

你需要一种不同的方法来获得O（N）。

Answer 2

问题

给出了一个由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是否为排列。

编写函数：

int解决方案（NSMutableArray * A）; 给定一个数组A，如果数组A是一个排列，则返回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]范围内的整数。

目标C解决方案O（N）

Codility提供的结果

任务得分：100％
正确性：100％
效果：100％

时间复杂度

最差的时间复杂度是O（N）或O（N * log（N））

Xcode Solution Here

+(int)solution:(NSMutableArray*)array {

    /******** Algorithm Explanation  ********/
    // STEP 1
    //       Check for edge cases - when the array is empty [], we should return 0
    // STEP 2
    //      Generate NSSet from the Array in oder to eliminate possible duplicates
    //      NSSet also has better performance on search elements
    // STEP 3
    //      Implement a loop taking in consideration:
    //          So, to be a permutation, in the Array we MUST have N => (1,2,3...n)
    //          they don't need to be necessary ordered, but should conntain all the elemements from 1 to n
    //
    // STEP 4
    //      Look for the current target in the SET
    //      If the target does't exist, that means  is not a permutation
    //      Break the loop.


    // STEP 1
    int isPermutation = 1;
    int n = (int)[array count];
    if (n==0) {
        isPermutation=0;
    }
    else {
        // STEP 2
        NSSet *elements = [NSSet setWithArray:array];
        int  target = 1;
        // STEP 3
        while (target <= n) {
            // STEP 4
            if (![elements containsObject:@(target)]) {
                isPermutation = 0;
                return isPermutation;
            }
            target++;
        }

    }
    return isPermutation;
}

Codility PermCheck我的两种元素的解决方案

2 个答案: