using System;

using System.Collections.Generic;

​

public class Program

{

    // Formatted with Tidy Up tool.

    public static void Main()

    {

        Console.WriteLine("\nThis program takes 2 user entries: int 'patternLength', string: 'input'.");

        Console.WriteLine("'input' is then iterated over to find patterns of lengh 'patternLength'.");

        Console.WriteLine("Recurring patterns are then output alongside their occurance count.");

        Console.WriteLine("Assumptions:");

        Console.WriteLine(" - 'patternLength' is an integer AND is less than 'input.Length'");

        Console.WriteLine(" - 'input' is trimmed of leading and trailing whitespace, and escape characters are ignored.");

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

        // Obtain user input for patternLength

        Console.Write("\nSearch for patterns of 'patternLength' (int): ");

        string patternLengthString = Console.ReadLine();

        // Attempt to obtain integer from string.

        // Using int.tryParse over System.Convert.ToInt32 to avoid exception handling, keeping code more concise with a bool

        int patternLength = -1;

        bool parseSuccess = int.TryParse(patternLengthString, out patternLength);

        if (!parseSuccess)

        {

            // Failed to obtain length - exiting.

            Console.WriteLine("\nERR: '{0}' is not an integer.", patternLengthString);

            return;

        }

​

        // check > 0

        if (patternLength <= 0)

        {

            // patternLength not long enough to proceed

            Console.WriteLine("\nERR: patternLength {0} should be greater than zero.", patternLength);

            return;

        }

​

        // Obtain user input for 'input' - the string to be parsed

        Console.Write("\nWithin 'input' (string): ");

        string input = Console.ReadLine();

        // Parse and print results.

        formatOutput(match(input, patternLength));

        return;

    }

​

    /*

     * match - given input and patternLength, returns dictionary of all unique substrings of pattern length, and their number of occurances.

     */

    private static Dictionary<string, int> match(string input, int patternLength)

    {

        Dictionary<string, int> results = new Dictionary<string, int>();

        // Check patternLength is smaller than input.Length

        if (patternLength < input.Length)

        {

            // Loop over each index in the input string from 0 to (input.Length - patternLength) - this ensures all substrings taken can be of length patternLength without going out of bounds.

            for (int i = 0; i <= input.Length - patternLength; i++)

            {

                // Obtain substring starting at current index.

                string pattern = input.Substring(i, patternLength);

                // Check if the pattern substring is already a key in the results

                if (results.ContainsKey(pattern))

                {

                    // We should bump the count.

                    results[pattern]++;

                }

                else

                {

                    // Not previously encountered so try to Add to results, with a an occurance value of 2

                    try

                    {

                        results.Add(pattern, 1);

                    }

                    catch (ArgumentException)

                    {

                    // Exception occured - key already exists - fail silently as previously checked for key so should never be able to drop into this catch.

                    }

                }

            }

        }

        else

        {

            Console.WriteLine("\nERR: patternLength ({0}) in not shorter than input length ({1}) - no repeated patterns can be found.", patternLength, input.Length);

        }

​

        return results;

    }

​

    /*

     * formatOutput - takes a Dictionary and iterates over it printing any entry with a Value greater than 1.

     */

    private static void formatOutput(Dictionary<string, int> results)

    {

        bool haveResult = false;

        // Loop over each result

        foreach (var result in results)

        {

            // Ignore patterns not seen more than once

            if (result.Value > 1)

            {

                if (!haveResult)

                {

                    haveResult = true;

                    Console.WriteLine("\nThe following repeated patterns were found:\n");

                }

​

                Console.WriteLine("{0} : {1}", result.Key, result.Value.ToString().PadLeft(3));

            }

        }

​

        if (!haveResult)

        {

            // No results found

            Console.WriteLine("\nNo repeated patterns found.");

            return;

        }

    }

}