using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Text;

​

/*

Given an integer array nums, return the largest perimeter of a triangle with a non-zero area, formed from three of these lengths. If it is impossible to form any triangle of a non-zero area, return 0.

​

​

Example 1:

    Input: nums = [2,1,2]

    Output: 5

    Explanation: You can form a triangle with three side lengths: 1, 2, and 2.

​

Example 2:

    Input: nums = [1,2,1,10]

    Output: 0

    Explanation: 

    You cannot use the side lengths 1, 1, and 2 to form a triangle.

    You cannot use the side lengths 1, 1, and 10 to form a triangle.

    You cannot use the side lengths 1, 2, and 10 to form a triangle.

    As we cannot use any three side lengths to form a triangle of non-zero area, we return 0.

​

Constraints:

    3 <= nums.length <= 104

    1 <= nums[i] <= 106

*/

​

public class Solution 

{

    public int LargestPerimeter(int[] nums) 

    {

        Array.Sort(nums);

        for (int i = nums.Length - 1; i > 1; i--)

        {

            if (nums[i] < nums[i - 1] + nums[i - 2])

                return nums[i] + nums[i - 1] + nums[i - 2];

        }

        return 0;

    }

}

​

public class Program

{

    public static void Main()

    {

        var solution = new Solution();

        Case.SetResultGenerator(solution.LargestPerimeter);

        Case

            .CreateCase(

                "[2,1,2]".ParseArray<int>(),

                5)

            .Run()

            .PrintResult();

            Case

            .CreateCase(

                "[1,2,1,10]".ParseArray<int>(),

                0)

            .Run()

            .PrintResult();

    }

}

​

public class TreeNode 

{

    public int val;

    public TreeNode left;

    public TreeNode right;

    public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) 

    {

        this.val = val;

        this.left = left;

        this.right = right;

    }

    public override string ToString()

    {

        return Serialize(this);

    }

    public static string Serialize(TreeNode root)

    {

        if (root == null)

            return "null";

        var sb = new StringBuilder();

        sb.Append("[");

        var queue = new Queue<TreeNode>();

        queue.Enqueue(root);

        while (queue.Count != 0)

        {

            var node = queue.Dequeue();

            if (node != null)

            {

                sb.Append(node.val.ToString() + ",");

                queue.Enqueue(node.left);

                queue.Enqueue(node.right);

            }

            else

            {

                sb.Append("null,");

            }

        }

        if (sb[sb.Length - 1] == ',')

        {

            sb.Remove(sb.Length - 1, 1);

        }

        sb.Append("]");

        return sb.ToString();

    }

    public static TreeNode Deserialize(string treeString)

    {

        if (string.IsNullOrEmpty(treeString))

            return null;

        treeString = treeString.Trim(new [] {'[', ']'});

        if (string.IsNullOrEmpty(treeString))

            return null;

        var vals = new Queue<string>(treeString.Split(','));

        if (vals.Count == 0 || vals.Peek() == "null")

            return null;

        var queue = new Queue<TreeNode>();

        var root = new TreeNode(int.Parse(vals.Dequeue()));

        queue.Enqueue(root);

        while (queue.Count != 0 && vals.Count > 1)

        {

            var node = queue.Dequeue();

            var left = vals.Dequeue();

            var right = vals.Dequeue();

            if (left != "null")

            {

                node.left = new TreeNode(int.Parse(left));

                queue.Enqueue(node.left);

            }

            if (right != "null")

            {

                node.right = new TreeNode(int.Parse(right));

                queue.Enqueue(node.right);

            }

        }

        return root;

    }

}

​

public static class TreeNodeExtensions

{

    public static string Serialize(this TreeNode root)

    {

        return TreeNode.Serialize(root);

    }

    public static TreeNode DeserializeTreeNode(this string treeString)

    {

        return TreeNode.Deserialize(treeString);

    }

}

​

public static class Extensions

{

    public static IList<T> ToIList<T>(this IList<T> list)

    {

        return (IList<T>)list;

    }

    public static T[][] ParseMatrix<T>(

        this string matrixString,

        bool addEmpty = true,

        bool ignoreQuotes = true)

    {

        return matrixString.ParseList<T>(addEmpty, ignoreQuotes).Select(x => x.ToArray()).ToArray();

    }

    public static IList<IList<T>> ParseList<T>(

        this string listString,

        bool addEmpty = true, 

        bool ignoreQuotes = true)

    {

        var result = new List<IList<T>>();

        if (listString.StartsWith("[["))

            listString = listString.Substring(1, listString.Length - 1);

        if (listString.EndsWith("]]"))

            listString = listString.Substring(0, listString.Length - 1);

        bool started = false;

        var current = new List<T>();

        var currentItem = string.Empty;

        for (int i = 0; i < listString.Length; i++)

        {

            if (listString[i] == '[')

            {

                current = new List<T>();

                currentItem = string.Empty;

                started = true;

                continue;

            }

            if (listString[i] == ']')

            {

                if (!string.IsNullOrEmpty(currentItem) || addEmpty)

                {

                    current.Add((T)Convert.ChangeType(currentItem, typeof(T)));

                    currentItem = string.Empty;

                }

                started = false;

                result.Add(current);

                continue;

            }

            if (started)

            {

                if (listString[i] == ' ' || (ignoreQuotes && listString[i] == '"'))

                    continue;

                if (listString[i] == ',')

                {

                    if (!string.IsNullOrEmpty(currentItem) || addEmpty)

                    {

                        current.Add((T)Convert.ChangeType(currentItem, typeof(T)));

                        currentItem = string.Empty;

                    }

                }

                else

                {

                    currentItem += listString[i];

                }

            }

        }

        return result;

    }

    public static T[] ParseArray<T>(this string arrayString, char delimiter = ',', bool removeQuotes = true)

    {

        arrayString = removeQuotes ? arrayString.Replace("\"", "") : arrayString;

        arrayString = arrayString.Trim(new [] {'[', ']'});

        var split = arrayString.Split(delimiter);

        return split.Select(x => (T)Convert.ChangeType(x, typeof(T))).ToArray();

    }

    public static void Print(this object obj)

    {

        Console.WriteLine(obj.TryGetObjectString());

    }

    public static string TryGetObjectString(this object input)

    {   

        if (input == null)

            return "null";

        if (input is not IEnumerable someEnumerable || input is string)

        {

            if (!(input.GetType().Name.Contains(nameof(ValueTuple))))

                return input.ToString();

            someEnumerable = input.GetType().GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).Select(x => x.GetValue(input)) as IEnumerable;

        }

        var result = "[";

        var first = true;

        foreach (var item in someEnumerable)

        {

            if (first)

            {

                first = false;

            }

            else

            {

                result += ", ";

            }

            result += TryGetObjectString(item);

        }

        result += "]";

        return result;

    }

    public static T[] SubArray<T>(this T[] data, int index, int length)

    {

        T[] result = new T[length];

        Array.Copy(data, index, result, 0, length);

        return result;

    }

}

​

public class Case

{

    public static Case<TInput, TResult> CreateCase<TInput, TResult>(TInput input, TResult expectedResult)

    {

        return new Case<TInput, TResult>(input, expectedResult);

    }

    public static void SetResultGenerator(Delegate @delegate)

    {

        var returnType = @delegate.Method.ReturnType;

        if (returnType == typeof(void))

            throw new InvalidOperationException("Delegate with return type 'void' is not supported.");

        var parameters = @delegate.Method.GetParameters();

        if (parameters.Count() != 1)

            throw new InvalidOperationException("Only one input parameter can be handeled. Use a tuple and an anonymous func if you need more than one.");

        var inputType = parameters.First().ParameterType;

        var setResultGeneratorMethod = 

            typeof(Case)

                .GetMethods(BindingFlags.Public | BindingFlags.Static)

                .First(m => m.IsGenericMethod && m.Name == nameof(Case.SetResultGenerator));

        var genericSetResultGeneratorMethod = setResultGeneratorMethod.MakeGenericMethod(inputType, returnType);

        var convertedDelegate = 

            typeof(Case)

                .GetMethod(nameof(CastResultGenerator), BindingFlags.NonPublic | BindingFlags.Static)

                .MakeGenericMethod(inputType, returnType)

                .Invoke(null, new object[] { @delegate });

        genericSetResultGeneratorMethod.Invoke(null, new object[] { convertedDelegate });

    }

    public static void SetResultGenerator<TInput, TResult>(Func<TInput, TResult> resultGenerator)

    {

        Case<TInput, TResult>.ResultGenerator = resultGenerator;

    }

    public static void SetResultChecker<TInput, TResult>(Func<Case<TInput, TResult>, bool> resultChecker)

    {

        Case<TInput, TResult>.ResultChecker = resultChecker;

    }

    private static Func<TInput, TResult> CastResultGenerator<TInput, TResult>(Delegate @delegate)

    {

        var castedDelegate = (Func<TInput, TResult>)@delegate;

        return castedDelegate;

    }

    private static Func<TInput, TResult, bool> CastResultChecker<TInput, TResult>(Delegate @delegate)

    {

        var castedDelegate = (Func<TInput, TResult, bool>)@delegate;

        return castedDelegate;

    }

}

​

public class Case<TInput, TResult>

{

    public static Func<TInput, TResult> ResultGenerator { get; set; }

    public static Func<Case<TInput, TResult>, bool> ResultChecker { get; set; }

​

    public string InputString { get; set; }

    public TInput Input { get; set; }

    public TResult ExpectedResult { get; set; }

    public TResult ActualResult { get; set; }

    public bool Passed { get; set; }

    static Case()

    {

        Case.SetResultChecker<TInput, TResult>(c => c.ActualResult.Equals(c.ExpectedResult));

    }

    public Case(TInput input, TResult expectedResult)

    {

        Input = input;

        ExpectedResult = expectedResult;

    }

    public Case<TInput, TResult> GenerateResult()

    {

        ActualResult = ResultGenerator(Input);

        return this;

    }

    public bool ResultAsExpected()

    {

        return ResultChecker(this);

    }

    public Case<TInput, TResult> Run()

    {

        GenerateResult();

        Passed = ResultAsExpected();

        return this;

    }

    public Case<TInput, TResult> PrintResult()

    {

        $"Test {(Passed ? "passed" : "failed" )}.".Print();

        $"Input: {Input.TryGetObjectString()}".Print();

        $"Result: {ActualResult.TryGetObjectString()}".Print();

        $"Expected: {ExpectedResult.TryGetObjectString()}".Print();

        string.Empty.Print();

        return this;

    }

}