Question

我已经在网上找到了解决方案问题的解决方案：

给出了由N个整数组成的零索引数组A.如果0≤P<1，则三重态（P，Q，R）是三角形。 Q＆lt; R＆lt; N和：

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

例如，考虑数组A：

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

三联体（0,2,4）是三角形。

写一个函数：

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

给定由N个整数组成的零索引数组A，如果该数组存在三角形三元组，则返回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;
  }

但是当我们对数组进行排序时，原始索引不再有效，并且i位置的项目可以移动到j位置，其中j> i或j

solutin假设验证断言的值（Triangle）在排序数组中自动相邻。

在示例数组中，如果我们改变如下：

A [0] = 10 A [1] = 6（替换2）A [2] = 5 A [3] = 1 A [4] = 8 A [5] = 20 在这里，我们得到2个新的traingle 10 6 5和6 5 8.（和10 5 8）

我们排序：1 5 6 8 10 20 - ＆gt;这里，原始解（10,5,8）值不相邻（没有traingle），而是我们有（5,6,8）和（6 8 10）。然后算法返回1。似乎如果存在三角形，那么至少一个三角形的值将相邻，但我没有找到任何证据。

Answer 1

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

设p，q，r使它们形成三角形。假设0 <= A [p]＆lt; = A [q]＆lt; = A [r]。

让我这样B [i + 1] = A [q]。令j为B [j] = A [p]且k为B [k] = A [r]。然后根据定义B [j] + B [i + 1]＆gt; B [k]的。因为B是有序的并且j < （i + 1）＆lt; k我们有B [i] + B [i + 1]＆gt; = B [j] + B [i + 1]＆gt; B [k]> = B [i + 2]。因此，如果你有一个三角形，算法返回true。

Answer 2

这真的很简单，我相信振动是正确的，但我会尝试以更简单的方式。

让我们假设您有三个元素是三角形，值为u, v, w，然后它们（至少）有一个最大值。我们认为这是w，所以u <= w和v <= w

“三角形”的定义相当于u + v > w，因为如果这是真的，则包含w的任何总和将始终大于其他单个值*
如果您在重新排序时跟踪w的新位置，您可以看到它前面的两个元素可以是
- u和v，因此您保持相同的三角形，
- 或者可以使用其他值u'和v'替换它们，这些值大于或等于u和v但小于w，并且那么u' + v' >= u + v > w，所以根据我们对三角形的新定义，我们有另一个三角形。

因此，数组中三角形的存在证明在排序数组中至少存在一个相邻的三角形，不必相同。

*由于w是最大值，因此对于正数而言完全无关紧要。这是一个不仅仅假设正整数的一般演示。我们的假设是v <= w，u <= w和u + v > w。让我们通过矛盾来证明u + w <= v它是不可能的。

假设u + w <= v，我们可以在双方v添加u + v + w <= v + v，并且由于假设u + v严格优于w，我们因此w + w < u + v + w <= v + v w < v，这与我们的假设相矛盾。

Answer 3

下面是C ++中Codility Triangle问题的解决方案。

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

Answer 4

我在Java中的解决方案是这样的。它起作用并解决了这个问题，但是当我在Codility上测试时，我得到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;
        }

    }

Answer 5

我第一次尝试得到了％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;

}

Answer 6

这是一个c ++解决方案，它使93％的一个测试失败，因为它使用了超出数字，你需要将数字转换为long来获得100％。我很懒，很满意93 :)

#include <algorithm>
#include <vector>
using namespace std;
int solution(vector<int> &A) {
    if(A.size() < 3){
        return 0;
    }
    sort(A.begin(), A.end());
    for(unsigned int i = 0 ; i < A.size() - 2 ; i++){
        if(A[i] + A[i+1] > A[i+2] && A[i] + A[i+2] > A[i+1]){
            return 1;
        }
    }
    return 0;
}

Answer 7

这是我在 Java 中的解决方案。给我 100％的Codility结果。

OrcStorage()

Answer 8

我的解决方案给出了100％。

其他解决方案的测试超出了必要，因为对数组A [Q] + A [R]> A [P]进行排序之后，A [R] + A [P]> A [Q]始终为真，因此我们不需要测试：A [R]大于A [Q]和A [P]。

使用A [P]> A [R]-A [Q]代替A [P] + A [Q]> A [R]可以避免溢出问题。

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

Answer 9

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

我认为解决方案未涵盖所有可能性与结合 P，Q，R

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

索引组合

0 + 1> 2，1 + 2> 0，2 + 0> 1

1 + 2> 3，2 + 3> 1，3 + 1> 2

....

这些是解决此问题所需的组合。

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

Answer 10

以下代码在Python上工作正常：

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

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

10 个答案: