using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Text;

​

/*

A sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each word consists of lowercase and uppercase English letters.

A sentence can be shuffled by appending the 1-indexed word position to each word then rearranging the words in the sentence.

For example, the sentence "This is a sentence" can be shuffled as "sentence4 a3 is2 This1" or "is2 sentence4 This1 a3".

Given a shuffled sentence s containing no more than 9 words, reconstruct and return the original sentence.

​

Constraints:

    2 <= s.length <= 200

    s consists of lowercase and uppercase English letters, spaces, and digits from 1 to 9.

    The number of words in s is between 1 and 9.

    The words in s are separated by a single space.

    s contains no leading or trailing spaces.

*/

​

public class Solution 

{

    public string SortSentenceLinq(string s) 

    {

        return

            string.Join(

                " ", 

                s

                    .Split()

                    .Select(x => new { Key = (int)(x.Last() - '0'), Word = x.Substring(0, x.Length - 1) })

                    .OrderBy(x => x.Key)

                    .Select(x => x.Word)

            );

    }

    public string SortSentence(string s) 

    {

        string[] buffer = new string[10];

        int start = 0;

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

        {

            if (s[i] <= 0x39)

            {

                buffer[s[i] - '0'] = s.Substring(start, i - start);

                start = i + 2;

                i = start;

            }

        }

        return string.Join(" ", buffer).Trim();

    }

}

​

public class Program

{

    public static void Main()

    {

        var solution = new Solution();

        Case.SetResultGenerator(solution.SortSentenceLinq);

        Case

            .CreateCase(

                "is2 sentence4 This1 a3",

                "This is a sentence")

            .Run()

            .PrintResult();

        Case

            .CreateCase(

                "Myself2 Me1 I4 and3",

                "Me Myself and I")

            .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 void Print(this object obj)

    {

        Console.WriteLine(obj.TryGetObjectString());

    }

    public static string TryGetObjectString(this object input)

    {

        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<TResult, 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<TResult, TResult, bool> ResultChecker { 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>((a, e) => a.Equals(e));

    }

    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(ActualResult, ExpectedResult);

    }

    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;

    }

}