using System;

using System.Linq;

using System.Collections.Generic;

public class Program

{

    public static void validSize(ref int size){

        if(size == 0){

            throw new InvalidInputSizeException("input size == 0");

        }

    }

    public static void FindSubstringOccurence(ref string s, ref int size, ref Dictionary<string, int> d){

        try{

            //validating input size

            validSize(ref size);

            // populating dictionary with entries

            for(int j = 0; j < (s.Length-size)+1; j++){

                char[] cArray = s.ToCharArray(j, size);

                string outS = new string(cArray);

                if(!d.ContainsKey(outS)){

                    d.Add(outS, 1);

                } else{

                    d[outS]++;

                }           

            }

            // refining dictionary to only contain entries where count is greater than 1

            d = d.Where(pair=> pair.Value>1).ToDictionary(pair=>pair.Key, pair=>pair.Value);

        }catch (InvalidInputSizeException ie){

            Console.WriteLine("InvalidInputSizeException: {0}", ie.Message);

        }

    }

    public static void PrintResult(ref Dictionary<string, int> d){      

        foreach(KeyValuePair<string, int> item in d){

            Console.WriteLine("substring: {0}, Occurence: {1}", item.Key, item.Value);

        }

    }

    public static void Main()

    {

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

        string input = "zf3kabxcde224lkzf3mabxc51+crsdtzf3nab=";

        Console.WriteLine("Test: Base Case -- size > 1 ");

        int size = 3;

        FindSubstringOccurence(ref input, ref size, ref result);

        Assert.areEqual(result["zf3"], 3);

        Assert.areEqual(result["zf3"], 4);

        Console.WriteLine("Substrings that occurred more than once are:");

        PrintResult(ref result);

        Console.WriteLine("Test: Lower bound -- size = 1");

        size = 1;

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

        FindSubstringOccurence(ref input, ref size, ref result);

        Assert.areEqual(result["a"], 3);

        Assert.areEqual(result["x"], 2);

        // No Upper bound test  -- size = input.Length <-- one occurence

        // findsubStringOccurence will only return substrings where occurrence > 1

        Console.WriteLine("Test: Special case -- size = 0");

        size = 0;

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

        FindSubstringOccurence(ref input, ref size, ref result);

    }

}

​

public class Assert{

    public static void areEqual(object expected, object actual){

        var o1 = expected == null? null : expected.ToString();

        var o2 = actual == null? null: actual.ToString();

        if(o1 == o2){

            Console.WriteLine("Assertion passed!");

        } else {

            Console.WriteLine("Assertion FAILED - expected: {0} and actual: {1}", expected, actual);

        }       

    }

}

​

public class InvalidInputSizeException : Exception{

    public InvalidInputSizeException(string message): base(message){

    }

}

​

​

​