Maximum Perimeter Triangle

Sort by

recency

|

320 Discussions

|

  • + 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]}')
    
  • + 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])
    
  • + 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);
    }
    
  • + 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};
    }
    
  • + 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;
             }
    
    }