We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Algorithms
  3. Greedy
  4. Maximum Perimeter Triangle
  5. Discussions

Maximum Perimeter Triangle

Sort by

recency

|

320 Discussions

|

  • sreekishore55
     + 0 comments

    Passed 13/13 testcase

    def check1(e):
    return e[3]
def check2(p,d,flag,count):
    for i in p:
        if d==i[3]:
            count+=1
    if count==1:
        return True
    elif count>1:
        return False
p=[]
n=int(input())
data=input().split(" ")
data=[int(i) for i in data]
for i in range(n-2):
    j,k=i+1,i+2
    if data[i]+data[j]>data[k] and data[i]+data[k]>data[j] and data[j]+data[k]>data[i]:
        p.append([data[i],data[j],data[k],data[i]+data[j]+data[k]])
if len(p)<=1:
    if len(p)==0:
        print(-1)
    else:
        print(f'{p[0][0]} {p[0][1]} {p[0][2]}')
else:
    p.sort(reverse=True,key=check1)
    flag=check2(p,p[0][3],True,0)
    if flag==True:
        print(f'{p[0][0]} {p[0][1]} {p[0][2]}')
    else:
        count=0
        flag=check2(p,p[-1][3],True,0)
        if flag==True or flag==False:
            print(f'{p[-1][0]} {p[-1][1]} {p[-1][2]}')

  • pub_ashishk28
     + 0 comments

    python3

    def triangulate(x):
    
    a,b,c = x
    if a + b > c:
        if a + c > b:
            if b + c > a:
                return True
    
    return False

def maximumPerimeterTriangle(sticks):
    # Write your code here
    
    sides = list(combinations(sticks, 3))
    sides = sorted(sides, key=sum, reverse=True)
    sides = list(filter(triangulate, sides))
    
    if not sides:
        return [-1]
        
    valid = list({x for x in sides if sum(x) == sum(sides[0])})
    
    if len(valid) == 1:
        return sorted(valid[0])
        
    valid = sorted(valid, key=max, reverse=True)
    valid =list(filter(lambda x: max(x) == max(valid[0]), valid))
    
    if len(valid) == 1:
        return sorted(valid[0])
        
    valid = sorted(valid, key=min, reverse=True)
    valid = list(filter(lambda x: min(x) == min(valid[0]), valid))
    
    return sorted(valid[0])

  • dorirgob
     + 0 comments

    Java:

    public static List<Integer> maximumPerimeterTriangle(List<Integer> sticks) {
  Collections.sort(sticks);
  int n = sticks.size();
  for (int i = n - 1; i >= 2; i--) {
    int a = sticks.get(i - 2);
    int b = sticks.get(i - 1);
    int c = sticks.get(i);
    if (c < a + b) {
      return Arrays.asList(a, b, c);
    }
  }
  return Arrays.asList(-1);
}

  • alban_tyrex
     + 0 comments

    Here is my c++ solution, you can watch the explanation here : https://youtu.be/cP4PLTgC1OE

    vector<int> maximumPerimeterTriangle(vector<int> sticks) {
    sort(sticks.begin(), sticks.end());
    for(int i = sticks.size() - 1; i >= 2; i--){
        if(sticks[i] < sticks[i - 1] + sticks[i - 2]) return {sticks[i - 2], sticks[i -1], sticks[i] };
    }
    return {-1};
}

  • ishwardharme320
     + 0 comments

    Java

    public static List maximumPerimeterTriangle(List sticks) {

    // The sum of the lengths of any two sides of a triangle must be greater than the 
//length of the third side.
 int[] arr=new int[3];
 List<Integer> list=new ArrayList<>();
         Collections.sort(sticks);
         for(int i=sticks.size()-1;i>=2;i--){
            arr[0]=sticks.get(i);
            arr[1]=sticks.get(i-1);
            arr[2]=sticks.get(i-2);

            if(arr[0]+arr[1]>arr[2] && arr[1]+arr[2]>arr[0] && arr[2]+arr[0]>arr[1] ){
                list.add(arr[0]);
                list.add(arr[1]);
                list.add(arr[2]);
                break;
            }else{
                continue;
            }
         }

         if(list.size()==0){
            list.add(-1);
           return list;
         }else{
                 Collections.sort(list); 
                 return list;
         }

}