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

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

}

Haskell

module Main where

import Data.List (find, sortBy)
import Data.Maybe (fromMaybe)

overlapping :: Int -> [a] -> [[a]]
overlapping k xs
    | length xs < k = []
    | otherwise = take k xs : overlapping k (tail xs)

solve :: [Int] -> [Int]
solve xs = case firstValid of
    Just [x, y, z] -> [z, y, x]
    Nothing -> [-1]
  where
    xs' = sortBy (flip compare) $ filter (> 0) xs
    tripples = overlapping 3 xs'
    firstValid = find (\[x, y, z] -> x < y + z) tripples

main :: IO ()
main = do
    _ <- getLine
    xs <- map read . words <$> getLine :: IO [Int]
    putStrLn  $ unwords $ map show $ solve xs

include

using namespace std;

string ltrim(const string &); string rtrim(const string &); vector split(const string &);

/* * Complete the 'maximumPerimeterTriangle' function below. * * The function is expected to return an INTEGER_ARRAY. * The function accepts INTEGER_ARRAY sticks as parameter. */

vector maximumPerimeterTriangle(vector sticks) { int a=-1,b=-1,c=-1; sort(sticks.begin(),sticks.end(),greater()); int n=sticks.size(); for(int i=0;i

   for(int j=i+1;j<n-1;j++){
       for(int k=j+1;k<n;k++){
           int sum=sticks[j]+sticks[k];
           if(sum>sticks[i]){
               int peri=a+b+c;
               if(peri==-3)  a=sticks[i],b=sticks[j],c=sticks[k];
               int nperi=sum+sticks[i];
               if(nperi>peri){
                   a=sticks[i],b=sticks[j],c=sticks[k];
               }
               else if(nperi==peri){
                   if(a<sticks[i]){
                       a=sticks[i],b=sticks[j],c=sticks[k];
                   }
                   else if(a==sticks[i]){
                       if(c<sticks[k]){
                            a=sticks[i],b=sticks[j],c=sticks[k];
                       }
                   }
               }

           }
       }
   }

} if(a!=-1) return {c,b,a}; return {-1}; }

int main() { ofstream fout(getenv("OUTPUT_PATH"));

string n_temp;
getline(cin, n_temp);

int n = stoi(ltrim(rtrim(n_temp)));

string sticks_temp_temp;
getline(cin, sticks_temp_temp);

vector<string> sticks_temp = split(rtrim(sticks_temp_temp));

vector<int> sticks(n);

for (int i = 0; i < n; i++) {
    int sticks_item = stoi(sticks_temp[i]);

    sticks[i] = sticks_item;
}

vector<int> result = maximumPerimeterTriangle(sticks);

for (size_t i = 0; i < result.size(); i++) {
    fout << result[i];

    if (i != result.size() - 1) {
        fout << " ";
    }
}

fout << "\n";

fout.close();

return 0;

}

string ltrim(const string &str) { string s(str);

s.erase(
    s.begin(),
    find_if(s.begin(), s.end(), not1(ptr_fun<int, int>(isspace)))
);

return s;

}

string rtrim(const string &str) { string s(str);

s.erase(
    find_if(s.rbegin(), s.rend(), not1(ptr_fun<int, int>(isspace))).base(),
    s.end()
);

return s;

}

vector split(const string &str) { vector tokens;

string::size_type start = 0;
string::size_type end = 0;

while ((end = str.find(" ", start)) != string::npos) {
    tokens.push_back(str.substr(start, end - start));

    start = end + 1;
}

tokens.push_back(str.substr(start));

return tokens;

}