using System;

using System.Linq;

using System.Collections.Generic;

using System.Text.RegularExpressions;

public class Program

{

    public static void Main()

    {

        string str1 = "021A,775U,000A,021A,1U2,206B,240,249,255B,260,263B,280,294,2U1,306B,336B,345,427,440,442,474,477,4U4,500508,523,543L,580,584,772,802,P55,VB" ;

        string str2 = "772+240+802+P55+263B+1U2+VB";

        Console.WriteLine("Simple Testing");

        Console.WriteLine("Expect True:" + ContainsAll(str1, str2));

        string str3 = "772+240+802+P55+263B+508+VB";

        Console.WriteLine("Expect False:" + ContainsAll(str1, str3));

​

        // More validation

        StringContainsAllTests tests = new StringContainsAllTests();

        Console.WriteLine("LinqExcept (true): " + tests.LinqExcept(str1, str2));

        Console.WriteLine("RegexMatchIterator (true): " + tests.RegexMatchIterator(str1, str2));

        Console.WriteLine("RegexMatchAllPattern (true): " + tests.RegexMatchAllPattern(str1, str2));

        Console.WriteLine("LinqExcept (false): " + tests.LinqExcept(str1, str3));

        Console.WriteLine("RegexMatchIterator (false): " + tests.RegexMatchIterator(str1, str3));

        Console.WriteLine("RegexMatchAllPattern (false): " + tests.RegexMatchAllPattern(str1, str3));

        Console.WriteLine("Testing boundary conditions, all should match");

        Console.WriteLine("ConcatenatedString: " + tests.ConcatenatedString(str1, "021A"));

        Console.WriteLine("ConcatenatedString: " + tests.ConcatenatedString(str1, "021A+VB"));

        Console.WriteLine("ConcatenatedString: " + tests.ConcatenatedString(str1, "VB"));   

        Console.WriteLine("RegexMatchIterator: " + tests.RegexMatchIterator(str1, "021A"));

        Console.WriteLine("RegexMatchIterator: " + tests.RegexMatchIterator(str1, "021A+VB"));

        Console.WriteLine("RegexMatchIterator: " + tests.RegexMatchIterator(str1, "VB"));   

        Console.WriteLine("RegexMatchAllPattern: " + tests.RegexMatchAllPattern(str1, "021A"));

        Console.WriteLine("RegexMatchAllPattern: " + tests.RegexMatchAllPattern(str1, "021A+VB"));

        Console.WriteLine("RegexMatchAllPattern: " + tests.RegexMatchAllPattern(str1, "VB"));   

​

        Console.WriteLine();

        Console.WriteLine("Benchmark the Matches");

        var optionals = new string [] { str1 };

        var requireds = new string [] { str2 };

        var results = tests.RunTests(optionals, requireds, 1);

        FiddleHelper.WriteTable(results);

        //Console.WriteLine(results.WriteMarkdownTable());

        results = tests.RunTests(optionals, requireds, 10);

        FiddleHelper.WriteTable(results);

        //Console.WriteLine(results.WriteMarkdownTable());

        results = tests.RunTests(optionals, requireds, 100);

        FiddleHelper.WriteTable(results);

        //Console.WriteLine(results.WriteMarkdownTable());

        results = tests.RunTests(optionals, requireds, 1000);

        FiddleHelper.WriteTable(results);

        //Console.WriteLine(results.WriteMarkdownTable());

        results = tests.RunTests(optionals, requireds, 10000);

        FiddleHelper.WriteTable(results);

        //Console.WriteLine(results.WriteMarkdownTable());

​

    }

​

    public static bool ContainsAll(string str1, string str2)

    {

        return !str2.Split('+')

            .Except(new HashSet<string>(str1.Split(',')))

            .Any();

    }

}

​

public class StringContainsAllTests

{

​

    public void Setup()

    {

        // 1. Build a list of all possible terms. 

    }

    public List<TestResults> RunTests(string [] optionals, string [] requireds, int iterations)

    {

        List<TestResults> results = new List<TestResults>();

        results.Add(RunTest("Arrays", optionals, requireds, iterations, Arrays));

        results.Add(RunTest("ConcatenatedString", optionals, requireds, iterations, ConcatenatedString));

        results.Add(RunTest("FormattedString", optionals, requireds, iterations, FormattedString));

        //results.Add(RunTest("InterpolatedString", optionals, requireds, iterations, InterpolatedString));

        results.Add(RunTest("LinqExcept", optionals, requireds, iterations, LinqExcept));

        results.Add(RunTest("LinqHashsetExcept", optionals, requireds, iterations, LinqHashsetExcept));

        results.Add(RunTest("RegexMatchIterator", optionals, requireds, iterations, RegexMatchIterator));

        results.Add(RunTest("RegexMatchAllPattern", optionals, requireds, iterations, RegexMatchAllPattern));

        return results;

    }

    public TestResults RunTest(string methodName, string [] optionals, string [] requireds, int iterations, Func<string, string, bool> testMethod)

    {

        //Console.WriteLine(methodName);

        var timer = new System.Diagnostics.Stopwatch();

​

        // record the cold start

        timer.Reset();

        timer.Start();

        testMethod(optionals[0], requireds[0]);

        timer.Stop();

        var coldStartMilliseconds = timer.Elapsed.TotalMilliseconds;

        // kill the cold start...

        foreach(var i in Enumerable.Range(0,10))

        {

            testMethod(optionals[i % optionals.Length], requireds[i % requireds.Length]);

        }

        bool result = false;

        List<double> results = new List<double>(iterations * optionals.Length * requireds.Length);

        var overallTimer = System.Diagnostics.Stopwatch.StartNew();

​

        // fix for zero or negatives

        iterations = Math.Max(1, iterations);

        for(int i = 0 ; i < iterations ; i ++)

        {

            foreach(var optional in optionals)

            {

                foreach(var required in requireds)

                {

                    timer.Reset();

                    timer.Start();

                    result = testMethod(optional, required);

                    timer.Stop();

                    results.Add(timer.Elapsed.TotalMilliseconds);

                    //Console.WriteLine("{0} => {1} | {2}", result, optional, required);

                }

            }

        }

        overallTimer.Stop();

        // calculate standard deviation

        double average = results.Average();

        double sd = results.StdDev(); 

        double variance = results.StdDevVar();

        return new TestResults(methodName, optionals.Length * requireds.Length, iterations, results.Count(), overallTimer.Elapsed, coldStartMilliseconds, average, sd, variance);

    }

    public bool Arrays(string optionalValuesCSV, string requiredValuesPSV)

    {

        string[] str1Arr = optionalValuesCSV.Split(',');

        foreach (var s in requiredValuesPSV.Split('+'))

        {

            if (!str1Arr.Contains(s))

                return false;

        }

        return true;

    }

    public bool ConcatenatedString(string optionalValuesCSV, string requiredValuesPSV)

    {

        string str1Fixed = "," + optionalValuesCSV + ",";

        foreach (var s in requiredValuesPSV.Split('+'))

        {

            if (!str1Fixed.Contains("," + s + ","))

                 return false;

        }

        return true;

    }

    public bool FormattedString(string optionalValuesCSV, string requiredValuesPSV)

    {

        string str1Fixed = String.Format(",{0},", optionalValuesCSV);

        foreach (var s in requiredValuesPSV.Split('+'))

        {

            if (!str1Fixed.Contains(String.Format(",{0},", s)))

                 return false;

        }

        return true;

    }

//  public bool InterpolatedString(string optionalValuesCSV, string requiredValuesPSV)

//  {

//      string str1Fixed = $",{optionalValuesCSV},";

//      foreach (var s in requiredValuesPSV.Split('+'))

//      {

//          if (!str1Fixed.Contains($",{s},"))

//               return false;

//      }

//      return true;

//  }

    public bool LinqExcept(string optionalValuesCSV, string requiredValuesPSV)

    {

        return !requiredValuesPSV.Split('+')

            .Except(optionalValuesCSV.Split(','))

            .Any();

    }

    public bool LinqHashsetExcept(string optionalValuesCSV, string requiredValuesPSV)

    {

        return !requiredValuesPSV.Split('+')

            .Except(new HashSet<string>(optionalValuesCSV.Split(',')))

            .Any();

    }

    public bool RegexMatchIterator(string optionalValuesCSV, string requiredValuesPSV)

    {

        Regex searchPattern = null;

        foreach (var s in requiredValuesPSV.Split('+'))

        {

            searchPattern = new Regex("," + s + ",");

            if (!searchPattern.IsMatch("," + optionalValuesCSV + ","))

                 return false;

        }

        return true;

    }       

    public bool RegexMatchAllPattern(string optionalValuesCSV, string requiredValuesPSV)

    {

        // note: need to escape \b for word boundary

        var pattern = "(?=.*?\\b" + requiredValuesPSV.Replace("+","\\b)(?=.*?\\b") + "\\b)";

        Regex searchPattern = new Regex(pattern);

        //return searchPattern.IsMatch("," + optionalValuesCSV + ","))

        return searchPattern.IsMatch(optionalValuesCSV);

    }   

​

}

​

public class TestResults

{

    public TestResults(){}

    public TestResults (string method, int testCases, int iterations, int totalTests, TimeSpan elapsed, double coldStart, double meanSeconds, double stdDev, double variance)

    {

        Method = method;

        TestCases = testCases;

        Iterations = iterations;

        TotalTests = totalTests;

        Overall = elapsed;

        ColdStart = coldStart;

        Mean = meanSeconds;

        StdDev = stdDev;

        Variance = variance;

    }

    public string Method { get;set; }

    public int TestCases { get;set; }

    public int Iterations { get;set; }

    public int TotalTests { get;set; }

    public TimeSpan Overall { get;set; }

    public double Milliseconds { get { return Overall.TotalMilliseconds; } }

    public double ColdStart { get;set; }

    public double Mean { get; set; }

    public double StdDev { get; set; }

    public double Variance { get; set; }

}

​

public static class LinqExtensions

{

    /// <summary>Calculates the mean absolute deviation of a set of values using Welford's Method.</summary>

    /// <param name="values">The list of values to calculate</param>

    /// <remarks>This method has a higher higher numerical accuracy compared to the <b><i>Average(x^2)-Average(x)^2</i></b> method.</remarks>

    public static double StdDev(this IEnumerable<double> values)

    {

        double mean = 0.0;

        double sum = 0.0;

        double stdDev = 0.0;

        double n = 0.0;

        foreach (double val in values)

        {

            n++;

            double delta = val - mean;

            mean += delta / n;

            sum += delta * (val - mean);

        }

        // We specifically want the population or normal standard deviation, so don't subtract 1

        stdDev = Math.Sqrt(sum / n);

​

        return stdDev;

    }   

    /// <summary>Calculates the variance of a set of values (StdDev of a sample from the population) using Welford's Method. </summary>

    /// <param name="values">The list of values to calculate</param>

    /// <remarks>This method has a higher higher numerical accuracy compared to the <b><i>Average(x^2)-Average(x)^2</i></b> method.</remarks>

    public static double StdDevVar(this IEnumerable<double> values)

    {

        double mean = 0.0;

        double sum = 0.0;

        double stdDev = 0.0;

        double n = 0.0;

        foreach (double val in values)

        {

            n++;

            double delta = val - mean;

            mean += delta / n;

            sum += delta * (val - mean);

        }

        if (1 < n)

            stdDev = Math.Sqrt(sum / (n - 1));

​

        return stdDev;

    }   

    /// <summary>Simple Table Markdown Format helper so we can dump a table into Stack Overflow or other Blogging platforms that support GitHub markdown<summary>

    public static string WriteMarkdownTable<T>(this IEnumerable<T> list)

        where T : class

    {

        var output = new System.Text.StringBuilder();

        var properties = typeof(T).GetProperties(); 

        output.AppendFormat("|{0}|", String.Join("|", properties.Select(p => p.Name)));

        output.AppendLine();

        output.AppendFormat("|{0}|", String.Join("|", properties.Select(p => new string ('-', p.Name.Length))));

        output.AppendLine();

        foreach(var item in list)

        {

            output.AppendFormat("|{0}|", String.Join("|", properties.Select(p => String.Format("{0}", p.GetValue(item)).Replace('|','~'))));

            output.AppendLine();

        }

        return output.ToString();

    }

}