Question

我对C很陌生并且通过Codility训练来学习它。

对于三重问题，但我只得到11％我不知道这里有什么问题。问题是：给出了由N个整数组成的非空零索引数组A.三重态（P，Q，R）的乘积等于A [P] * A [Q] * A [R]（0≤P

您的目标是找到任何三联产品的最大产品。

写一个函数：

int solution(int A[], int N);

，给定非空零索引数组A，返回任何三元组的最大乘积的值。例如，给定数组A使得：

A[0] = -3
A[1] = 1
A[2] = 2
A[3] = -2
A[4] = 5
A[5] = 6

函数应该返回60，因为三元组（2,4,5）的乘积是最大的。

假设： •N是[3..100,000]范围内的整数; •数组A的每个元素都是[-1,000..1,000]范围内的整数。

复杂性： •预期的最坏情况时间复杂度为O（N * log（N））; •预期的最坏情况空间复杂度为O（1），超出输入存储（不计入输入参数所需的存储空间）。

我的代码给了我11％，我想知道我在这个代码中出错的地方。我首先对矩阵进行排序，然后比较三个最大的正数和最大的两个负数以及最大的正数：

int solution(int A[], int N) {
    int i,j,PQR_pos,PQR_neg, temp;

    for (i=0; i<N; i++) { 
        for (j=0; j<N-i; j++) 
            if (A[j+1] < A[j]) { /* compare the two neighbours */ 
                temp = A[j]; /* swap a[j] and a[j+1] */ 
                A[j] = A[j+1]; 
                A[j+1] = temp; 
            } 
    }

    PQR_pos = A[N] * A[N-1] * A[N-2];
    PQR_neg = A[N] * A[1] * A[0];

    if (PQR_pos>PQR_neg) return PQR_pos;
    else return PQR_neg;

}

Answer 1

你根本不需要排序。

首先对输入数组执行线性扫描并存储3个biggest和2个lowests（且小于零），然后结果为：
biggest * max（2nd_biggest * { {1}}，3rd_biggest * lowest）

使用所有数字都在[-1000..1000]的事实，您甚至不需要编码。只需计入数组并存储最大和最低索引，扫描输入数组后只扫描计数数组即可找到所有需要的5个数字。

Answer 2

Codility中的测验属于“排序”类别，因此故意要求使用排序。排序数组使测验变得微不足道。这是满足性能约束O（N * LogN）时间和O（1）空间的答案。

int solution(vector<int> &A) {
    if(A.size() < 3) return 0;
    if(A.size() == 3) return A[0]*A[1]*A[2];
    size_t last = A.size()-1;
    sort(A.begin(), A.end());
    return max(A[0]*A[1]*A[last], A[last]*A[last-1]*A[last-2]);
}

Answer 3

因为你正在学习，我认为你不想要一个完整的答案。所以我有两个提示。

Paul R指出了第一个：

你认为A [N]有效吗？

另一个是，这个部分的最坏情况时间复杂度是多少（它不是O（N * log（N）））：

for (i=0; i<N; i++) { 
    for (j=0; j<N-i; j++) 
        if (A[j+1] < A[j]) { /* compare the two neighbours */ 
            temp = A[j]; /* swap a[j] and a[j+1] */ 
            A[j] = A[j+1]; 
            A[j+1] = temp; 
        } 
}

关于复杂性

你基本上必须计算完成两个元素之间的比较的时间。

你有2个循环：

外层人员将执行内部人员N次
内部执行比较N-i次。

因此，在外循环的第一次运行中，您将进行N-0比较，然后N-1，然后N-2，[...]，最后{{1比较。

因此，它将进行N - (N-1) = 1比较。这是N + (N-1) + (N-2) + ... + 1的{{3}}。

所以复杂度为N(N+1)/2，等于O(N(N+1)/2)（known summation）

关于排序算法

我建议您选择更快的排序算法，例如合并排序或快速排序。在我看来，合并排序更容易理解。

Answer 4

Ruby Code，在代码上获得100/100

def solution(a)
  a.sort!
  if a[a.length - 1] >= 0
    a[a.length - 1] * ([a[0] * a[1] ,a[a.length - 2] * a[a.length - 3]].max) 
  else
    a[a.length - 1] * a[a.length - 2] * a[a.length - 3]
  end    
end

Answer 5

好的家伙到目前为止非常感谢你的帮助......我仍然想知道如何在这个函数中实现合并排序（虽然不需要）....所以我得到了100％，这是我的代码：< / p>

int solution(int A[], int N) {
int i,N1,N2,N3,NEG1,NEG2,PQR_neg,PQR_pos;

N1=-1000;
N2=-1000;
N3=-1000;

NEG1=0;
NEG2=0;

for (i = 0; i <= (N-1); i++) 
{
    if (A[i] < NEG1 ) {
        NEG2=NEG1;
        NEG1=A[i];
    }
    else if (A[i] < NEG2) {
        NEG2=A[i];
    }
    if (A[i] > N1) {
        N3=N2; 
        N2=N1; 
        N1=A[i];
    }
    else if (A[i] > N2) {
        N3=N2;
        N2=A[i];
    }
    else if (A[i] > N3) {
        N3=A[i];
    }
}


PQR_neg = N1*NEG1*NEG2;
PQR_pos = N1*N2*N3;

if (PQR_pos>PQR_neg) return PQR_pos;
else return PQR_neg;

}

Answer 6

int solution(int A[]) {
        int k = 0;
        int d = 0;
        /*
         * int p = 0; int q = 0;
         */
        int p = 0;
        int q = 1;
        int r = -1;
        int finalValue = -1;

        for (int i = 1; i < A.length - 2; i++) {

            if (A[q] < A[p]) {
                if (k != 1) {
                    p = i - 1;
                    q = i;
                }
                if (A[i + 1] > A[i]) {

                    r = i + 1;
                    k = 0;
                    if (i + 2 < A.length - 1 && A[i + 2] > A[i + 1]) {
                        r = -1;
                        k = 1;
                    }

                } else {
                    if (A[i + 1] < A[i]) {

                        q = i + 1;
                        r = -1;
                        k = 1;
                    }
                }
            } else {
                p = i;
                q = i + 1;
            }
            if (p != -1 && q != -1 && r != -1) {
                finalValue = Math.max(finalValue, Math.min(A[p] - A[q], A[r]
                        - A[q]));
                p = 0;
                q = 1;
                r = -1;
            }
            // if (finalValue > finalWalaValue)
            // finalWalaValue = finalValue;
        }

        return finalValue;

    }

Answer 7

我知道这与问题无关，但对某些人可能有用。

我在 Java 中使用 100％的解决方案如下：


class Solution {
    public int solution(int[] A) {
        Arrays.sort(A);
        int n = A.length;

        int maxWithNegativeNumbers = A[0] * A[1] * A[n - 1];
        int maxWithPositiveNumbers = A[n - 3] * A[n - 2] * A[n - 1];

        return Math.max(maxWithNegativeNumbers, maxWithPositiveNumbers);
    }
}

您还需要添加以下导入：

 import java.util.*;

Answer 8

工作100％，并在不同的情况下进行了测试。

// Function to remove the element 
    public int[] removeTheElement(int[] arr, int index) 
    { 
        // Create another array of size one less 
        int[] anotherArray = new int[arr.length - 1]; 

        // Copy the elements except the index 
        // from original array to the other array 
        for (int i = 0, k = 0; i < arr.length; i++) { 

            // if the index is 
            // the removal element index 
            if (i == index) { 
                continue; 
            } 

            // if the index is not 
            // the removal element index 
            anotherArray[k++] = arr[i]; 
        } 

        //Java >8
        //IntStream.range(0, arr.length).filter(i -> i != index).map(i -> arr[i]).toArray();

        return anotherArray;
    }

    //MaxProductOfThree
    //A[P] * A[Q] * A[R] (0 <= P < Q < R < N).
    public String maxProductOfThreeSolution(int[] A) {
        long prod = 0;
        String arryVal = "";
        for(int i=0; i<A.length; i++) {
            int[] B = removeTheElement(A, i);
            for(int j=0; j<B.length; j++) {
                int[] C = removeTheElement(B, j);
                for(int k=0; k<C.length; k++) {
                    System.out.println(A[i] +":" +B[j]+":" +C[k] +"---->"+ (A[i] * B[j] * C[k]));
                    long sum = A[i] * B[j] * C[k];
                    if(sum >= prod) {
                        prod = sum;
                        arryVal = "Array index "+i+":"+j+":"+k+", Array index value "+A[i] +":" +B[j]+":" +C[k]+"";
                    }
                }
            }
        }

        return prod +": "+arryVal;
    }

int[] g = {-3,1,2,-2,5,6};
        System.out.println("Max Product Of Three : "+obj.maxProductOfThreeSolution(g));

输出

最大乘积三：60：数组索引5：4：2，数组索引值6：5：2

Answer 9

另一个关于python解决方案O（N * log（N））100/100

def solution(A):
# write your code in Python 3.6
    if len(A) < 3:
        return 0
    elif len(A) == 3:
        return A[0]*A[1]*A[2]

    A.sort()
    max_negative_d = A[0] * A[1]
    max_negative_t = A[-1] * A[-2] * A[-3]
    return max(A[-1] * max(A[-2] * A[-3], max_negative_d), max_negative_t) 
    pass

C中的三胞胎Codility - 仅获得11％（训练）

9 个答案:

关于复杂性

关于排序算法