C++ 三角形：确定数组是否包含三角形三元组（Codibility）

这是Codibility的三角形问题：

给出了一个由N个整数组成的零索引数组。
如果0，则三元组（P，Q，R）是三角形的≤ P A[p]+A[Q]>A[R]，
A[Q]+A[R]>A[P]，
A[R]+A[P]>A[Q]

编写一个函数：

int solution(vector<int> &A);  

int解决方案（向量&A）；

给定一个由N个整数组成的零索引数组，返回1 如果此数组存在三角形三元组并返回0 否则

例如，给定一个数组：
[0]=10，A[1]=2，A[2]=5，A[3]=1，A[4]=8，A[5]=20 三元组（0，2，4）是三角形的，函数应该返回1

给定的数组如下：
[0]=10，A[1]=50，A[2]=5，A[3]=1
函数应返回0

假设：

N是[0..100000]范围内的整数
数组A的每个元素都是范围内的整数 [−2147483648..2147483647]

这是我的C++解决方案：

int solution(vector<int> &A) {
    if(A.size()<3) return 0;

    sort(A.begin(), A.end());

    for(int i=0; i<A.size()-2; i++){
        //if(A[i] = A[i+1] = A[i+2]) return 1;
        if(A[i]+A[i+1]>A[i+2] && A[i+1]+A[i+2]>A[i] && A[i+2]+A[i]>A[i+1]){
            return 1;
        }
    }
    return 0;
}

int解决方案（向量&A）{
如果（A.size（）A[i]&&A[i+2]+A[i]>A[i+1]）{
返回1；
}
}
返回0；
}

我查看了那里的评论，所有的解决方案似乎都与我的类似。
然而，当其他人声称得到了100%的分数时，我只得到了93%的分数。
我所有的测试用例都是正确的，除了一个：

极端溢流量1
溢出测试，3个最大值

我假设这个案例有如下输入：
[2147483647、2147483647、2147483647]

因此，我将其添加到定制测试用例中，当答案显然应该是1时，结果是0。
我也试过[1900000000，1900000000，1900000000]，结果还是0。
然而，[1000000000，1000000000，1000000000]是正确的，答案是1

有人能告诉我为什么会出现这种结果吗？
非常感谢。

这是因为

试试这个：

int a1 = 1900000000;
int a2 = 1900000000;
int sum = a1+a2;  // sum will be -494967296

编辑：使用长整型

long long int sum01 = A[i] + A[i+1];
long long int sum12 = A[i+1] + A[i+2];
long lont int sum02 = A[i] + A[i+2];

if (sum01 > A[i+2] && sum12 > A[i] && sum02 > A[i+1])
    return 1;

Java 100%：

public int solution(int[] A){
        Arrays.sort(A);

        for(int i=0;i<A.length-2;i++){
            if(  
                 ((long)A[i] + (long)A[i+1] > A[i+2]) &&  
                 ((long)A[i+1] + (long)A[i+2] > A[i]) &&
                 ((long)A[i] + (long)A[i+2] > A[i+1]) 
               )
            return 1;   
        }
        return 0;
    }

public int解决方案（int[]A）{
数组。排序（A）；
对于（int i=0；i A[i+2]）&
（（长）A[i+1]+（长）A[i+2]>A[i]）&&
（（长）A[i]+（长）A[i+2]>A[i+1]）
)
返回1；
}
返回0；
}

这里有几个问题

三角形的边不能为0，因为它是一个长度。你必须加上那张支票，否则你会失败的。i、 e.不会得到100%

由于可以有一个包含所有INT_MAX或LONG_MAX的输入数组（请参阅），因此需要将总和存储在double或LONG-LONG中

您不必在此处检查所有三个条件，即

A[p]+A[Q]>A[R]， A[Q]+A[R]>A[P]， A[R]+A[P]>A[Q]

如果已对数组进行排序，则

A[Q]+A[R]>A[p]&&
A[R]+A[P]>A[Q]

始终为真，因为0≤ PA[P]+A[Q]>A[R]

您已经对a.size（）<3进行了检查，这样就可以了。 我在中添加了一个C实现。

---

您可以将其与解决方案进行比较

我对这个问题的解决方案，用Swift写成

public func Triangle(_ A : inout [Int]) -> Int {

    A.sort()

    for i in 1..<A.count-1 {
        if(A[i] + A[i-1] > A[i+1]) {
            print("Triangle has edges: \(A[i-1]), \(A[i]), \(A[i+1])")
            return 1
        }
    }
    return 0
}

A = [10,2,5,1,8,20]
print("Triangle: ", Triangle(&A))

public func三角形（A:inout[Int]）->Int{
A.排序（）
对于1..A中的i[i+1]）{
打印（“三角形有边：\（A[i-1]），\（A[i]），\（A[i+1]））
返回1
}
}
返回0
}
A=[10,2,5,1,8,20]
打印（“三角形：”、三角形（&A））

或者您可以更改if子句，如下所示

if(A[i]>A[i+2]-A[i+1] && A[i+1]>A[i]-A[i+2] && A[i+2]>A[i+1]-A[i])

---

使用减法而不是加法。

我的Java解决方案是100/100，时间复杂度为O（N*log（N））

用评论来解释逻辑

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");
import java.util.Arrays;

class Solution {

    public int solution(int[] A) {

    int N = A.length;
    if (N < 3) return 0;
    Arrays.sort(A);

    for (int i = 0; i < N - 2; i++) {

        /**
         * Since the array is sorted A[i + 2] is always greater or equal to previous values
         * So A[i + 2] + A[i] > A[i + 1] ALWAYS
         * As well ass A[i + 2] + A[i + 1] > A[i] ALWAYS
         * Therefore no need to check those. We only need to check if A[i] + A[i + 1] > A[i + 2]?
         * Since in case of A[i] + A[i + 1] > MAXINT the code would strike an overflow (ie the result will be greater than allowed integer limit)
         * We'll modify the formula to an equivalent A[i] > A[i + 2] - A[i + 1]
         * And inspect it there
         */
        if (A[i] >= 0 && A[i] > A[i + 2] - A[i + 1]) {

            return 1;
        }
    }

    return 0;
}

//您也可以使用导入，例如：
//导入java.util.*；
//您可以出于调试目的写入stdout，例如。
//System.out.println（“这是一条调试消息”）；
导入java.util.array；
类解决方案{
公共int解决方案（int[]A）{
int N=A.长度；
如果（N<3）返回0；
数组。排序（A）；
对于（int i=0；iA[i+1]总是
*以及A[i+2]+A[i+1]>A[i]始终
*因此不需要检查这些，我们只需要检查A[i]+A[i+1]>A[i+2]？
*因为在[i]+A[i+1]>MAXINT的情况下，代码会溢出（即结果将大于允许的整数限制）
*我们将把公式修改为等价的A[i]>A[i+2]-A[i+1]
*然后在那里检查
*/
如果（A[i]>=0&&A[i]>A[i+2]-A[i+1]）{
返回1；
}
}
返回0；
}

基本上，当您检查

X+Y

整数的值时，如果大于整数限制，则代码将在溢出时失败。因此，我们不必检查

X+Y>Z

，而只需检查

X>Z-Y

（简单的数学不是吗？）。或者，您也可以始终使用

long

，但在内存方面，这将是一个更糟糕的解决方案

另外，请确保跳过负片，因为三角形的边值不能为负数

---

干杯

我在这里使用了3 for循环（不排序数组）来解决这个问题

public static int solution(int[] A) {

    for (int p = 0; p < A.length; p++) {
        for (int q = p + 1; q < A.length; q++) {
            for (int r = q + 1; r < A.length; r++) {

                if ((A[p] + A[q] > A[r]) && (A[q] + A[r] > A[p]) && (A[r] + A[p] > A[q])) {
                    System.out.println(A[p] + "  " + A[q] + " " + A[r]);
                    return 1;
                }
            }
        }
    }
    return 0;
}

//Triangle
    /**
     * A[P] + A[Q] > A[R],
       A[Q] + A[R] > A[P],
       A[R] + A[P] > A[Q]
     */
    public int triangleSolution(int[] A) {
    int status = 0;
    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++) {
                if((A[i] + B[j] > C[k]) &&
                   (B[j] + C[k] > A[i]) &&
                   (C[k] + A[i] > B[j])) {
                    return 1;
                }
            }
        }
    }
    return status;
}

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

公共静态int解决方案（int[]A）{
for（int p=0；pA[r]）&&（A[q]+A[r]>A[p]）&&（A[r]+A[p]>A[q]））{
System.out.println（A[p]+“”+A[q]+“”+A[r]）；
返回1；
}
}
}
}
返回0；
}

这是我用Python编写的干净解决方案。我的可编译性达到了100%。 此逻辑可适用于任何其他编程l

//Triangle
    /**
     * A[P] + A[Q] > A[R],
       A[Q] + A[R] > A[P],
       A[R] + A[P] > A[Q]
     */
    public int triangleSolution(int[] A) {
    int status = 0;
    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++) {
                if((A[i] + B[j] > C[k]) &&
                   (B[j] + C[k] > A[i]) &&
                   (C[k] + A[i] > B[j])) {
                    return 1;
                }
            }
        }
    }
    return status;
}

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

//My solution in C++ it avoid overflow

inline int Triangle(vector<int> &A) {

    if(A.size() < 3) return 0;
    sort(A.begin(), A.end());
    for(int i = 0; i < (int)A.size() - 2; ++i){
        int P = A[i], Q = A[i + 1], R =A[i + 2];
        if(( R - P - Q < 0) && ( P - Q - R < 0) && (Q - R - P < 0))
           return 1;
    }
    return 0;
}

def solution(a)
  arr = a.select{|x| x >=0 }.sort
  arr.each_with_index do |p, pi|
    arr[(pi+1)..-1].each_with_index do |q, qi|
      arr[(qi+pi+2)..-1].each do |r|
        break if p+q <=r
        break if p+r <=q
        break if r+q <=p
        return 1
      end
    end
  end
  0
end

public int solution(int[] A) {
       int n = A.length;
       if(n<3){
           return 0;
       }
       Arrays.sort(A);
       for(int i=2; i<n; i++){
           if(A[i]<(long)A[i-1]+(long)A[i-2])
           return 1;
       }
       return 0;
    }

 public static int solution(int[] A) {
    int isATriangle = 0;
    Arrays.sort(A);
    if (A.length >= 3) {
        for (int i = 0; i < A.length - 2; i++) {
            if (A[i] > A[i + 2] - A[i + 1]
                    && A[i + 2] > A[i] - A[i + 1]
                    && A[i + 2] > A[i + 1] - A[i])
                isATriangle = 1;
        }
    }
    return isATriangle;
}

    using System;
    
    class Solution {
        public int solution(int[] A) {
            // write your code in C# 6.0 with .NET 4.5 (Mono)
            if(A.Length) <3)
               return 0;

            Array.Sort(A);
            int p,q,r;
            for(int i=A.Length-1;i>1; i--){
                p = A[i];
                q = A[i-1];
                r = A[i-2];
                if(p+q>r && q+r > p && r+p > q)
                    return 1;
            }
            return 0;
        }
    }

function solution(A) {
    if(A.length<3) return 0;

    A.sort((a,b)=>b - a);

    for(let i = 0,j = i+1;j < A.length-1;j++){
        let p = A[j],q = A[j+1],r = A[i]

        if(r - p > q) i++;
        else if(r - p < q) return 1;
    }

    return 0;
}

 public static int solution(int[] unfilteredArray) {
    int[] array = filterLessThanOneElements(unfilteredArray);

    for(int i = 0; i <= (array.length - 3) ; i++) {
        long p = array[i];
        for(int j = i+1; j <= (array.length - 2); j++) {
            long q = array[j];
            for(int k = j+1; k <= (array.length - 1); k++) {
                long r = array[k];
                if((p + q > r) && (q + r > p) && (r + p > q)) {
                    return 1;
                }
            }
        }
    }

    return 0;
}

// The mose efficient way to remove duplicates
// TIME COMPLEXITY : O(N)
private static int[] filterLessThanOneElements(int[] unfilteredArray) {
    int k = 0;
    for(int i = 0; i < unfilteredArray.length; i++) {
        if(unfilteredArray[i] > 0) {
            unfilteredArray[k++] = unfilteredArray[i];
        }
    }
    return Arrays.copyOfRange(unfilteredArray, 0, k);
}