Math 三角形：确定是否可以从给定的一组边构建三角形

我在网上找到了一个解决编码问题的方法，如下所示：

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

    A[P] + A[Q] > A[R],
    A[Q] + A[R] > A[P],
    A[R] + A[P] > A[Q].

例如，考虑数组A这样：

A[0]=10A[1]=2A[2]=5 A[3]=1A[4]=8A[5]=20

三元组（0，2，4）是三角形的

编写一个函数：

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

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

解决方案如下：

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

排序 对于（int i=0；i0；i++） { 如果（A[i]+A[i+1]>A[i+2]） 返回1； } 但是当我们对数组进行排序时，原始索引不再有效，i位置的项可以移动到j位置，j>i或j 解决方案假设验证断言（三角形）的值在排序数组中自动相邻

在示例数组中，如果我们这样更改：

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

A[0]=10 A[1]=6（替换2）A[2]=5 A[3]=1A[4]=8A[5]=20 这里我们有两辆新火车10 6 5和6 5 8。（及1058）

我们排序：1 5 6 8 10 20-->在这里，原始解（10,5,8）值不是相邻的（没有traingle），而是（5,6,8）和（6 8 10）。然后算法返回1。

---

如果三角形存在，那么至少有一个三角形的值是相邻的，但我没有找到任何证据。

让A表示原始数组，让B表示排序数组（以避免混淆）

---

设p，q，r为三角形。假设0b[k]>=B[i+2]。因此，如果你有一个三角形，算法将返回true

这真的很简单，我相信vib是对的，但我会尝试用一种更简单的方式来表达

假设有三个三角形元素，它们的值分别为u、v、w，那么它们至少有一个最大值。让我们把它看作是<代码> w <代码>，所以<代码> u= u+v> w < /代码>，因此，通过我们对三角形的新定义，我们有另一个三角形。 因此，数组中三角形的存在证明排序后的数组中至少存在一个相邻的三角形，它们不一定是相同的

---

---

*对于正数来说，这完全是微不足道的，因为

w

是最大值。这里有一个一般性的演示，它不仅假设正整数。我们的假设是>V

下面是C++中的“三角问题”的解决方案。

#include <algorithm>

bool isTriangular(int p2, int q2, int r2) {
    long p, q, r;

    p = (long)p2;
    q = (long)q2;
    r = (long)r2;

    if (p + q > r &&
        q + r > p &&
        r + p > q) {
        return true;
    }
    return false;
}

int solution(vector<int> &A) {

    int size = A.size();
    if (size < 3) {
        return 0;
    }

    vector<int>&S(A);
    sort(S.begin(), S.end());

    int q = size/2;
    int p = q-1;
    int r = q+1;

    if (isTriangular(S[p],S[q],S[r])) {
        return 1;
    }

    while (true) {        
        if (p == 0 && r == size-1) {
            break;
        }

        if (p != 0) {
            --p;

            if (isTriangular(S[p],S[q],S[r])) {
                return 1;
            }
        }

        if (r != size-1) {
            ++r;

            if (isTriangular(S[p],S[q],S[r])) {
                return 1;
            }
        }
    }

    return 0;
}

#包括
布尔三角形（整数p2，整数q2，整数r2）{
长p，q，r；
p=（长）p2；
q=（长）q2；
r=（长）r2；
如果（p+q>r&&
q+r>p&&
r+p>q）{
返回true；
}
返回false；
}
整数解（向量&A）{
int size=A.size（）；
如果（尺寸<3）{
返回0；
}
向量&S（A）；
排序（S.begin（），S.end（））；
int q=大小/2；
int p=q-1；
int r=q+1；
if（三角（S[p]，S[q]，S[r]））{
返回1；
}
虽然（正确）{
如果（p==0&&r==size-1）{
打破
}
如果（p！=0）{
--p；
if（三角（S[p]，S[q]，S[r]））{
返回1；
}
}
如果（r！=尺寸-1）{
++r；
if（三角（S[p]，S[q]，S[r]））{
返回1；
}
}
}
返回0；
}

我的Java解决方案是这样的。它起作用并解决了问题，但当对可变性进行测试时，我得到了0%，可能是因为时间复杂性。如果您对如何改进评论中的欢迎程度有任何想法，我可以编辑答案以供大家查看：

import java.util.Arrays;

public class Triangular {
    public static int solution(int[] A) {
        // Sort the array and nullify values which won't count. 
        Arrays.sort(A);
        for(int i=0;i<A.length;i++){
            if(A[i]>A.length){
                A[i]=0;
            }
        }

        //Increment the counter, if a triangle exists then this works.
        int count = 1;
        for(int i=1;i<A.length-1;i++){
            if(A[i-1]+A[i+1]>A[i]){
                count++;
            }
        }

        switch(count){
            case 3:
                return 1;
            default:
                return 0;
        }

    }

导入java.util.array；
公共类三角形{
公共静态int解决方案（int[]A）{
//对数组进行排序并使不计数的值为空。
数组。排序（A）；
用于（int i=0；iA.长度）{
A[i]=0；
}
}
//递增计数器，如果存在三角形，则此操作有效。
整数计数=1；
对于（int i=1；iA[i]）{
计数++；
}
}
开关（计数）{
案例3：
返回1；
违约：
返回0；
}
}

我第一次尝试得到了%93，它有溢出异常，在一个测试用例中失败。然后我需要先把这些值转换成long，然后进行数学计算。下面是代码

public static int solution(int[] A) {

    if (A.length < 3)
        return 0;

    Arrays.sort(A);

    for (int i = 0; i < A.length - 2; i++) {
        long p = A[i];
        long q = A[i + 1];
        long r = A[i + 2];

        if ((p + q > r) && (q + r > p) && (r + p > q))
            return 1;

    }

    return 0;

}

公共静态int解决方案（int[]A）{
如果（A.长度<3）
返回0；
数组。排序（A）；
对于（int i=0；ir）和&（q+r>p）和&（r+p>q））
返回1；
}
返回0；
}
<代码> > P>这里是一个C++解决方案，它给出93%个测试失败，因为它使用了不绑定的数字，需要将数字转换为长，以获得100%。我很懒，很高兴有93:）

#包括
#包括
使用名称空间std；
整数解（向量&A）{
如果（A.尺寸（）<3）{
返回0；
}
排序（A.begin（），A.end（））；
for（无符号整数i=0；iA[i+2]&A[i]+A[i+2]>A[i+1]）{
返回1；
}
}
返回0；
}
这是我在Java中的解决方案。给我100%编码结果

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

        for (int i = 2; i < A.length; i++) {
            long p = A[i - 2]; 
            long q = A[i - 1]; 
            long r = A[i];

            if (p + q <= r) {
                continue;
            } 
            if (r + p <= q) {
                continue;
            } 
            if (q + r <= p) {
                continue;
            } 
            return 1;
        }

        return 0;
    }
}

类解决方案{
公共int解决方案（int[]A）{
数组。排序（A）；
for（int i=2；i如果（p+q我的溶液给出100%

其他解决方案的测试比必要的要多，因为在对数组A[Q]+A[R]>A[p]和A[R]+A[p]>A[Q]进行排序后，A[R]始终为真，因此我们不需要测试它：A[R]大于A[Q]和A[p]

可以避免溢出问题
import java.util.*;

class Solution {
    public int solution(int[] A) {
        if (A.length < 3) {
            return 0;
        }
        Arrays.sort(A);
        for (int i = 2; i < A.length; ++i) {
            if (A[i - 2] > A[i] - A[i - 1]) {
              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;
    }

def solution(A):
    sorted_a = sorted(A, reverse=True)
    list_len = len(sorted_a) - 2
    for i in range(list_len):
        if sorted_a[i] < sorted_a[i+1] + sorted_a[i+2]:
            return 1
    return 0