using System;

using System.Linq;

using System.Text;

​

public class Program

{

    /* GENERAL NOTES:

     * 

     * TL;DR - This code is intentionally a bit ridicuous and in a single file.

     * 

     * This is a skills exercise. A real-world implementation would likely look very different.

     * (I would cringe if I saw this come through a pull request review.) This code demonstrates several

     * core concepts and programming paradigms.

     *  

     * For execution simplicity on your behalf:

     *  - I kept all code in a single file

     *  - No external text framework is used

     *  - This can be executed by pasting the entirety of this file into https://dotNetFiddle.net or any

     *    other online C# EDI.

     *  - Please note this is written for .NET 6 / C# 10.

     *

     *

     *

     *

     * EXERCISE PARAMETERS:

     * Write a function that extracts a substring based on common parlance. E.g. Parser("first half of it", "abc123") returns "abc".

     *

     * 1. Two input parameters:  (string syntax, string[] words)

     * 2. Returns a string array of extractions.

     * 3. Basic syntax is: "[place] [fraction] of it"

     *     - Place includes: first, second, third, fourth, ...ninetyninth, hundredth        HINT: Make this an enum that maps to an INT. Repeat the First/Whole and second/half values!

     *     - Fraction includes "whole, half, third, fourth, ...ninetyninth, hundredth

     * 4. When the string can't be evenly devided, return an error.

     * 5. Misspelled and invalid inputs return an error.

     * 6. BONUS: Chain syntax for smaller portions. For example: "second fourth of first half of it" and "first half of third fourth of second half of it".

     * 7. PERSONAL BONUS: Support the "last" and "none" words!

*/

​

    public static void Main()

    {

        var instance = new Program();

​

        instance.BigStringTest("second thirtyseventh of it", 2, 37, 5);

    }

​

    // Instead of writing a test using the Xunit/NUnit/MSTest library, I created this

    // one that outputs to the console, to avoid compilation and execution complexity

    // on your behalf.

    private void BigStringTest(string syntax, int positionAsInt, int fractionAsInt, int desiredResultStringLength)

    {

        var series = "1234567890";

        var seriesModulus = fractionAsInt % series.Length;

​

        var bigStringBuilder = new StringBuilder();

        for (int i = 0; i < (fractionAsInt - seriesModulus) / series.Length; i++)

        {

            bigStringBuilder.Append(series);

        }

        if (seriesModulus != 0)

        {

            bigStringBuilder.Append(series.Substring(0, seriesModulus));

        }

        var fractionalString = bigStringBuilder.ToString();

        for (int i = 2; i <= desiredResultStringLength; i++)

        {

            bigStringBuilder.Append(fractionalString);

        }

​

        var bigString = bigStringBuilder.ToString();

        var expectedBigStringResult = new string(bigString.Skip(positionAsInt * desiredResultStringLength).Take(desiredResultStringLength).ToArray());

​

        var values = new[] {

            bigString

            , "123456789012"

            , "12" };

​

        Console.WriteLine($"SYNTAX:\t{syntax}");

        Console.WriteLine("\nVALUES:");

        Array.ForEach(values, x => Console.WriteLine($"\t{x}"));

​

​

        var results = GetSubstring(syntax, values);

        Console.WriteLine("\nResults:");

        Array.ForEach(results, x => Console.WriteLine($"\t{x}"));

​

        Console.WriteLine("\n\n");

        Console.WriteLine($"EXPECTED:\t{expectedBigStringResult}");

        Console.WriteLine($"ACTUAL:\t\t{results[0]}");

        Console.WriteLine(results[0] == expectedBigStringResult ? "TEST PASSED" : "TEST FAILED");

​

        Console.WriteLine("\n\n\nExecution complete - press any key to terminate.");

        Console.ReadKey();

    }

​

    private string[] GetSubstring(string syntax, string[] values)

    {

        ValidateParameters(syntax, values);

​

        // Clean up the syntax. We don't need "of it".

        syntax = syntax.Substring(0, syntax.IndexOf(" of it")).Trim();

​

        /*

        // TODO - Implement splitting "of" statements and validating them.

        var args = syntax.Split(" of ", StringSplitOptions.TrimEntries);

        if (args.Length %2 != 0)

        {

            throw new InvalidSyntaxStringException($"The \"{nameof(syntax)}\" parameter is malformed: a place term is missing before an \"of\" or a fraction term is missing after an \"of\".");

        }

        if(args.Any(x => x.Length == 0))

        {

            throw new InvalidSyntaxStringException($"The \"{nameof(syntax)}\" parameter is malformed: the string contains two \"of\" statements with nothing between them.");

        }

        */

​

        // Split the syntax value into "Position" and "Fraction".

        var spaceIndex = syntax.IndexOf(" ");

        var position = syntax.Substring(0, spaceIndex);

        var positionValue = CalculateSyntaxValue(position);

        var fraction = syntax.Substring(spaceIndex + 1);

        var fractionValue = CalculateSyntaxValue(fraction);

        var results = new string[values.Length];

​

        int takeLength, skipCount;

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

        {

            if (values[i].Length == 0 || values[i].Length % fractionValue != 0)

            {

                results[i] = $"ERROR: The string \"{values[i]}\" contains {values[i].Length} characters, which is not divisible into {fractionValue} equal parts.";

            }

            else

            {

                takeLength = values[i].Length / fractionValue;

                skipCount = takeLength * (positionValue);

                results[i] = new string(

                    values[i]

                    .Skip(skipCount)

                    .Take(takeLength)

                    .ToArray());

            }

        }

        return results;

    }

​

    private void ValidateParameters(string syntax, string[] values)

    {

        if (string.IsNullOrWhiteSpace(syntax))

        {

            throw new InvalidSyntaxStringException($"The \"{nameof(syntax)}\" parameter must not be null, empty, or whitespace.");

        }

​

        if ((values?.Length ?? 0) == 0) // Let's assume we requre the string array to be populated.

        {

            throw new InvalidSyntaxStringException($"The \"{nameof(values)}\"  parameter must not be null or empty.");

        }

    }

​

    private int CalculateSyntaxValue(string syntax)

    {

        // Try getting a non-composite value.

        if (TryGetTermValue<WholeTerms>(syntax, out var nonCompositeValue)

            || TryGetTermValue<IntermediateTerms>(syntax, out nonCompositeValue))

        {

            return nonCompositeValue;

        }

​

        var compositeValue = CalculateCompositeSyntaxValue(syntax, syntax, 0);

        return compositeValue;

    }

​

    // This is a recursive function (not a method). It's a classic function in that it requires input, always provides output,

    // and incurrs no side-effects. This is a reliable and testable piece of code to have in a code base.

    private int CalculateCompositeSyntaxValue(string originalSyntax, string decomposedSyntax, int runningTotal)

    {

        // Employ a chain-of-command pattern with members that return tuples instead of using referenced (ref) parameters.

        var result = CalculateIntermediateTermValue(originalSyntax, decomposedSyntax);

        if (result.iterationTotal != 0)

        {

            return runningTotal += result.iterationTotal;

        }

​

        result = CalculateRootTermValue(originalSyntax, result.iterationTotal, result.iterationDecomp);

        result = CalculateMultiplicativeTermSuffixValue(originalSyntax, result.iterationTotal, result.iterationDecomp);

        result = CalculateAdditiveTermSuffixValue(result.iterationTotal, result.iterationDecomp);

​

        // Don't use a conditional operator ( ?: )  in a return statement because it hides the result from debug step-through.

        if (result.iterationDecomp.Length == 0)

        {

            var total = runningTotal + result.iterationTotal;

            return total;

        }

        else

        {

            return CalculateCompositeSyntaxValue(originalSyntax, result.iterationDecomp, runningTotal + result.iterationTotal);

        }

    }

​

    private (int iterationTotal, string iterationDecomp) CalculateIntermediateTermValue(string originalSyntax, string iterationDecomp)

    {

        // Note this IntermediateTerms enumeration names are not being handled efficiently here. A property with a backing sore is best for this.

        var intermediate = Enum.GetNames<IntermediateTerms>().FirstOrDefault(x => iterationDecomp.StartsWith(x));

​

        if (intermediate != null)

        {

            TryGetTermValue<IntermediateTerms>(intermediate, out var iterationTotal);

            var result = (iterationTotal: iterationTotal, iterationDecomp: iterationDecomp.Substring(intermediate.Length));

            if (result.iterationDecomp.Length != 0)

            {

                // Nothing should ever follow an intermediate suffix.

                throw new InvalidSyntaxStringException($"The \"syntax\" parameter is malformed: the term \"{originalSyntax}\" is not well formed.");

            }

            return result;

        }

​

        return (0, iterationDecomp);

    }

​

    private (int iterationTotal, string iterationDecomp) CalculateRootTermValue(string originalSyntax, int iterationTotal, string iterationDecomp)

    {

        var root = RootTermNames.FirstOrDefault(x => iterationDecomp.StartsWith(x));

        if (root != null)

        {

            if (root == iterationDecomp)

            {   // A root requires at least one suffix.

                throw new InvalidSyntaxStringException($"The \"syntax\" parameter is malformed: the term \"{originalSyntax}\" is invalid or not supported.");

            }

            TryGetTermValue<RootTerms>(root, out var rootValue); // This will not fail.

            return (rootValue, iterationDecomp.Substring(root.Length));

        }

        return (iterationTotal, iterationDecomp);

    }

​

    private (int iterationTotal, string iterationDecomp) CalculateMultiplicativeTermSuffixValue(string originalSyntax, int iterationTotal, string iterationDecomp)

    {

        var multSuffix = MultiplicativeTermSuffixNames.FirstOrDefault(x => iterationDecomp.StartsWith(x));

        if (multSuffix != null)

        {

            if (iterationTotal == 0) // We can't have a multiplicative suffix without a root!

            {

                throw new InvalidSyntaxStringException($"The \"syntax\" parameter is malformed: the term \"{originalSyntax}\" is invalid or not supported.");

            }

            TryGetTermValue<MultiplicativeTermSuffixes>(multSuffix, out var factor);

            return (iterationTotal *= factor, iterationDecomp.Substring(multSuffix.Length));

        }

        return (iterationTotal, iterationDecomp);

    }

​

    private (int iterationTotal, string iterationDecomp) CalculateAdditiveTermSuffixValue(int iterationTotal, string iterationDecomp)

    {

        var addSufix = AdditiveTermSuffixNames.FirstOrDefault(x => iterationDecomp.StartsWith(x));

        if (addSufix != null)

        {

            TryGetTermValue<AdditiveTermSuffixes>(addSufix, out var addend);

            return (iterationTotal += addend, iterationDecomp.Substring(addSufix.Length));

        }

        return (iterationTotal, iterationDecomp);

    }

​

    // When the specified Enum type contains an enumaration matching the "syntaxWord" string, 

    // return True and sets the associated value to the numberVale output parameter.

    // Otherwise, returns false and a 0 value.

    private bool TryGetTermValue<T>(string syntaxWord, out int numberValue) where T : Enum

    {

        if (Enum.TryParse(typeof(T), syntaxWord, out var parsed))

        {

            numberValue = (int)parsed;

            return true;

        }

        numberValue = 0;

        return false;

    }

​

    // These terms are never used in composite form and entirely represent their value.

    private enum WholeTerms

    {

        tenth = 10,

        eleventh = 11,

        twelveth = 12,

        hundredth = 100

    }

​

    // These can be whole or an additive root suffix.

    private enum IntermediateTerms

    {

        first = 1,

        second = 2,

    }

​

    // These are roots of composite values.

    private enum RootTerms

    {

        twen = 2,

        thir = 3,

        four = 4,

        fif = 5,

        six = 6,

        seven = 7,

        eight = 8,

        nin = 9

    }

    // Instantiate the property value on demand to potentially reduce resource utilization.

    // After initializing the backing field, hold the array in memory for future reference, to avoid repetitive processing.

    private string[] _rootTermNames;

    private string[] RootTermNames

    {

        get

        {

            if (_rootTermNames == null)

            {

                _rootTermNames = Enum.GetNames<RootTerms>();

            }

            return _rootTermNames;

        }

    }

​

    // When these appear immediately after a root, multiply the  the associated value.

    private enum MultiplicativeTermSuffixes

    {  // Base 10 multipliers such as tens, hundreds, thousands appear here.

        ty = 10,

        tieth = 10

    }

    // Using this lambda format property for code brevity, at the cost of increased compute cycles.

    private string[] MultiplicativeTermSuffixNames => Enum.GetNames<MultiplicativeTermSuffixes>();

​

    // When these appear immediately after a root, add the associated value.

    private enum AdditiveTermSuffixes

    {

        d = 0,  // We need to know when a suffix is found, even if it has a zero value.

        th = 0,

        teenth = 10,

    }

    private string[] AdditiveTermSuffixNames => Enum.GetNames<AdditiveTermSuffixes>();

}

​

public abstract class ParserException : Exception

{

    public ParserException(string message) : base(message) { }

}

​

public class InvalidSyntaxStringException : ParserException

{

    public InvalidSyntaxStringException(string message) : base(message) { }

}

public class InvalidWordsArrayException : ParserException

{

    public InvalidWordsArrayException(string message) : base(message) { }

}

​