Hi Aadesh, I have few suggestions for the code. I agree that the logic is pretty similar but I am afraid the implementation changes things a bit.

This implementation makes the worst case time complexity as opposed to as promised by the logic. The remove operation done at the beginning of the list arr.remove(arr[0]) is itself . This can be easily replaced by operation of updating the index while traversing the list.

Also (though this doesn't matter much), you can directly reverse-sort the list using sorted(my_list, reverse=True) in place of sorted(my_list)[::-1] which first sorts and then reverses. I hope you don't take suggestions otherwise. This post is meant to be just educational, it might help you as well as coders reading it later. Happy Coding !

Same idea, but using for instead of while:

n = int(input())
l = sorted([int(arr_temp) for arr_temp in input().strip().split(' ')])[::-1]
tester = 0
for i in range(len(l) - 2):
    if l[i] < l[i + 1] + l[i + 2]:
        print(l[i + 2],l[i + 1],l[i])
        tester +=1
        break
if tester == 0:
    print(-1)

No buddy, output should be 1 2 2 and not 1 2 4.

Try drawing a triangle with sides 1, 2 and 4 on paper, you won't succeed. That's because, for forming any triangle, sum of two sides should be greater than the third side, which isn't the case here.

Yes, I think you tried it in Python2. It worked in your IDE, perhaps because it has Python3.

You can make the code work in Python2 by replacing input().split() by raw_input().split(). You'll also need to remove parenthesis () from print() for correct result.

In case you are curious, in python3, raw_input() doesn't exist, it has been renamed to input(). Still if you want to simulate the old input() from Python2 in Python3, you can use eval(input()).

Mine is more than 100 LoC too, but only 17 lines of it are the solution (the rest is deliberately going overkill on the parser)

First of all, thanks for the appreciation. In one line : Think Twice, Code Once ;)

Let's keep detailed chit-chat in inbox (check your messages) :)

Since A is first sorted, A[i+2], A[i+1], A[i] are the largest consecutive values which can form triangle. Any other choice won't fulfill the conditions mentioned in the problem statement. I'll prove it by contradiction.

Suppose a, c, r be three non-consecutive values chosen to form the triangle such that a <= c <= r. Here, r is the longest side for the triangle. Now, let the consecutive values keeping r as maximum be p, q, r such that p <= q <= r.

Now, since a, c, r form non-degenerate triangle, a+c > r (by triangle inequality). Also, p+q >= a+c because p, q, r are consecutive. So p+q >= a+c > r, which implies p+q > r. Thus, a non-degenerate triangle can be formed using p, q, r too !

Finally, comparing perimeters : p+q+r >= a+c+r since p+q >= a+c. This contradicts our choice for maximum perimeter. Hence, choose the consecutive values.

I have already answered your first question here.

No, this case won't occur because A(i-1) + A(i+1) + A(i+2) <= A(i) + A(i+1) + A(i+2), which proves that this choice will have smaller or equal perimeter.

No, that's not true. In this case, i will be 0 at the end (not -1). That's because i-- is executed only if sides cannot form the triangle.

Moreover, this extra case is flawed. Because if there's no possible triangle, then the value of i is -1, and hence, program will be accessing arr[-1] i.e. accessing memory outside the bounds of the array, which can give unexpected results anytime.

Anyway, you don't need to add any extra check. Just modify if(i>0) to if(i>=0) and the program will execute correctly !

Because i is the index of array, starting from where 3 sides of the triangle can be chosen. The sides are A[i], A[i+1] and A[i+2]. If we take any higher value of i, the index becomes n or higher (because of A[i+2]) which goes out of range.

Instead of the lambda, why not use:

sort( sticks.rbegin(), sticks.rend() );

1. Given any triangle, if a, b, and c are the lengths of the sides, the following is always true: a + b > c && b + c > a && c + a > b

2. Given a sorted array named 'a', if indices x < y < z then a[x] <= a[y] <= a[z] is alway true, which makes a[y] + a[z] > a[x] and a[z] + a[x] > a[y] always true. So to make a valid triangle on top of that, we only need to make sure that one more condition is met: a[x] + a[y] > a[z] (in which a[x], a[y], a[z] are the three sides and in that order)

3. From the description, we know we want a[z] to be the largest possible, and given that, a[x] to be the largest possible. What that implies is that they are the last three consecutive elements in the sorted assending array which satisfy a[x] + a[y] > a[z]. (why consecutive indexed elements? because if some a[i-3] + a[i-1] > a[i] or a[i-3] + a[i-2] > a[i] we know a[i-2] + a[i-1] > a[i], because the array is sorted and non-decreasing, and the consecutive elements solution will give you the biggest smallest side if exists)

4. So we search from the back of the array, from the biggest to the smallest of groups of the three consecutive elements in the array, and check if they satisfy a[x] + a[y] > a[z], if satisfied then break out of the loop and print them, if even when we reached the last possible iteration (the first and smallest element a[0] as a[x], and the opposite condition a[x]+a[y]<=a[z] still passes the check, which means it will never satisfy a[x] + a[y] > a[z] ever, we much now print -1 and return to end the search.)

Yes, it's true. But I sorted it.

I agree. That sounds like a good idea.

Of course!!

In C++ it is.