using System.Diagnostics;

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

​

/*

 * Assumptions:

 * - I am going to look for patterns while ignoring case sensitivity i.e. I will treat uppercase 'Z' same as lowercase 'z'

 * - I will treat spaces as valid characters for pattern matching

 * - I will throw exceptions when passed in invalid arguments

 * - I will treat whitespace only strings as invalid input for pattern matching i.e. it is NOT ok to pattern match groups of spaces of given patternLength

 * - I will throw exceptions at the first issue found instead of compiling a list of issues

 * - If no patterns are found after a successful search, will return a message saying no patterns found

 * - In order to make it easier to test, I will return a string PrintStringPatterns which could then be manipulated as the user wishes (e.g. output to console, etc.)

*/

public class Program

{

    public static void Main()

    {       

        var tester = new StringPatternTester();

        tester.RunTests();

    }

    public static string PrintStringPatterns(string input, int patternLength)

    {

        try{

            var repeatedPatterns = RetrieveStringPatterns(input, patternLength).ToArray();

            StringBuilder stringBuilder = new StringBuilder("");

            foreach (var entry in repeatedPatterns)

            {

                var output = string.Format("pattern = {0}, occurence value = {1}\n", entry.Key, entry.Value);

                stringBuilder.Append(output);

            }

            if(stringBuilder.Length == 0){

                return ErrorMessages.NoPattersFoundMessage;

            }

            else{

                return stringBuilder.ToString();

            }

        }catch(ArgumentException ex){

            return ex.Message;

        }

    }

    public static Dictionary<string, int> RetrieveStringPatterns(string input, int patternLength){

        ValidateInputs(input, patternLength);

        var processedInput = input.ToLower();

​

        var patterns = new Dictionary<string, int>();

        //only need to iterate through string towards input.Length - pattern length. Otherwise could hit IndexOutOfBoundsException

        var endIndex = processedInput.Length - patternLength;

        for (var i = 0; i <= endIndex; i++)

        {

            var substring = processedInput.Substring(i, patternLength);

​

            if (patterns.ContainsKey(substring))

            {

                patterns[substring] += 1;

            }

            else

            {

                patterns[substring] = 1;

            }

        }

​

        var repeatedPatterns = patterns.Where(x => x.Value > 1).ToDictionary(x => x.Key, x => x.Value);

        return repeatedPatterns;

    }

​

    public static void ValidateInputs(string input, int patternLength)

    {       

        if(string.IsNullOrWhiteSpace(input)){

            throw new ArgumentException(ErrorMessages.InputIsNullOrWhiteSpaceMessage);

        }

​

        if (patternLength < 1)

        {

            throw new ArgumentException(ErrorMessages.PatternLengthInadequateMessage);

        }

​

        // I'm going to consider it an invalid input when patternLength >= input length

        // Including = case because when pattern length = input length then we won't find any repeated pattern

        if (patternLength >= input.Length)

        {

            throw new ArgumentException(ErrorMessages.PatternLengthTooBigMessage);

        }

    }

}

​

public static class ErrorMessages

{

    public const string PatternLengthInadequateMessage = "Pattern length must be at least 1";

    public const string PatternLengthTooBigMessage = "Pattern length must not equal or exceed input length";

    public const string InputIsNullOrWhiteSpaceMessage = "String was null or Empty or only contained whitespace";

    public const string NoPattersFoundMessage = "No patterns found";

}

​

/*

 * Instead of using something like nunit, I'm opting to use debug.assert here to keep the fiddle simpler

*/

public class StringPatternTester{

    public void RunTests()

    {

        Console.WriteLine("starting tests");

        PrintStringPatterns_WhenInputIsNullOrEmpty_ReturnsExceptionMessage();

        PrintStringPatterns_WhenPatternLengthIsInvalid_ReturnsExceptionMessage();

        PrintStringPatterns_WhenPatternIsAllWhitespace_ReturnsErrorMessage();

        PrintStringPatterns_WhenPatternHasMixedCase_ReturnsCaseInsensitivePattern();

        PrintStringPatterns_WhenPatternInTypicalStrings_ReturnsCorrectPatterns();

        PrintStringPatterns_WhenThereAreNoPatternsMatched_ReturnsNoPatternsMessage();

        Console.WriteLine("finished tests");

    }

​

    private void PrintStringPatterns_WhenInputIsNullOrEmpty_ReturnsExceptionMessage(){

        var result = Program.PrintStringPatterns("", 2);

        Debug.Assert(result.Equals(ErrorMessages.InputIsNullOrWhiteSpaceMessage));

        result = Program.PrintStringPatterns(null, 2);

        Debug.Assert(result.Equals(ErrorMessages.InputIsNullOrWhiteSpaceMessage));

        result = Program.PrintStringPatterns("", 2);

        Debug.Assert(result.Equals(ErrorMessages.InputIsNullOrWhiteSpaceMessage));

    }

​

    private void PrintStringPatterns_WhenPatternLengthIsInvalid_ReturnsExceptionMessage(){

        var result = Program.PrintStringPatterns("TestString", 20);

        Debug.Assert(result.Equals(ErrorMessages.PatternLengthTooBigMessage));

        result = Program.PrintStringPatterns("test", 4);

        Debug.Assert(result.Equals(ErrorMessages.PatternLengthTooBigMessage));

        result = Program.PrintStringPatterns("ababcab", -2);

        Debug.Assert(result.Equals(ErrorMessages.PatternLengthInadequateMessage));

    }

​

    private void PrintStringPatterns_WhenPatternIsAllWhitespace_ReturnsErrorMessage(){

        var result = Program.PrintStringPatterns("    ", 2);

        Debug.Assert(result.Equals(ErrorMessages.InputIsNullOrWhiteSpaceMessage));

    }

​

    private void PrintStringPatterns_WhenPatternHasMixedCase_ReturnsCaseInsensitivePattern(){

        var result = Program.PrintStringPatterns("aBAbcAB", 2);

        var expectedResult = "pattern = ab, occurence value = 3\n";

        Debug.Assert(result.Equals(expectedResult));

    }

​

    private void PrintStringPatterns_WhenPatternInTypicalStrings_ReturnsCorrectPatterns(){

        var result = Program.PrintStringPatterns("ababcab", 2);

        var expectedResult = "pattern = ab, occurence value = 3\n";

        Debug.Assert(result.Equals(expectedResult));

        result = Program.PrintStringPatterns("zf3kabxcde224lkzf3mabxc51+crsdtzf3nab=", 3);

        expectedResult = "pattern = zf3, occurence value = 3\npattern = abx, occurence value = 2\npattern = bxc, occurence value = 2\n";

        Debug.Assert(result.Equals(expectedResult));

    }

​

    private void PrintStringPatterns_WhenThereAreNoPatternsMatched_ReturnsNoPatternsMessage(){

        var result = Program.PrintStringPatterns("abcdef", 3);      

        Debug.Assert(result.Equals(ErrorMessages.NoPattersFoundMessage));

    }

}

​

​

​