esac

using System;
using System.Text.RegularExpressions;
using System.Text;
using System.Diagnostics;
using System.Linq;

namespace Speed
{
    public static class Utility
    {
         public static string ReplaceDirkGently(this string original, char[] pattern, char replacement)
        {
            char[] result = new char[original.Length];

            for (int i = 0; i < original.Length; i++)
            {
                if (Array.IndexOf(pattern, original[i]) >= 0)
                {
                    result[i] = original[i];
                }
                else
                {
                    result[i] = replacement;
                }
            }

            return new string(result);
        }

        public static string ReplaceMine(this string original, char[] pattern, char replacement)
        {
            int index = 0;
            int old = -1;

            StringBuilder sb = new StringBuilder(original.Length);

            while ((index = original.IndexOfAny(pattern, index)) > -1)
            {
                sb.Append(new string(replacement, index - old - 1));
                sb.Append(original[index]);
                old = index++;
            }

            if (original.Length - old > 1)
            {
                sb.Append(new string(replacement, original.Length - (old + 1)));
            }

            return sb.ToString();
        }


        public static string ReplaceGuffa(this string original, char[] pattern, char replacement)
        {
            int index = 0;
            int old = -1;

            StringBuilder sb = new StringBuilder(original.Length);

            while ((index = original.IndexOfAny(pattern, index)) > -1)
            {
                sb.Append(replacement, index - old - 1);
                sb.Append(original[index]);
                old = index++;
            }

            if (original.Length - old > 1)
            {
                sb.Append(replacement, original.Length - (old + 1));
            }

            return sb.ToString();
        }

        public static string ReplacePeter(this string original, string pattern, string replacement)
        {
            Regex regex = new Regex(@"[^" + pattern + "]");
            return regex.Replace(original, replacement);
        }


        public static string ReplaceMichael(this string original, char[] pattern, char replacement)
        {
            StringBuilder sb = new StringBuilder(original.Length);

            foreach (char ch in original)
            {
                if (Array.IndexOf(pattern, ch) >= 0)
                {
                    sb.Append(ch);
                }
                else
                {
                    sb.Append(replacement);
                }
            }

            return sb.ToString();
        }

        public static string ReplaceJohn(this string original, char[] pattern, char replacement)
        {
            int index = 0;

            StringBuilder sb = new StringBuilder(new string(replacement, original.Length));

            while ((index = original.IndexOfAny(pattern, index)) > -1)
            {
                sb[index] = original[index++];
            }

            return sb.ToString();
        }
    }

    public class Speed
    {
        public static int Main(string[] args)
        {
            string original = "abcdefg\rhijklmn\nopqrstuvwxyz\r\n";
            string pattern = "\r\n";
            char[] pattch = pattern.ToCharArray();
            string result = "";
            original.ReplaceMichael(pattch, '*');
            original.ReplaceMine(pattch, '*');
            original.ReplaceGuffa(pattch, '*');
            original.ReplacePeter(pattern, "*");
            original.ReplaceDirkGently(pattch, '*');
            original.ReplaceJohn(pattch, '*');

            Stopwatch sw = new Stopwatch();

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                original.ReplaceMichael(pattch, '*');
            }
            sw.Stop();
            Console.WriteLine("Michael: {0} ms", sw.ElapsedMilliseconds);

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                original.ReplaceMine(pattch, '*');
            }
            sw.Stop();
            Console.WriteLine("Mine: {0} ms", sw.ElapsedMilliseconds);

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                original.ReplacePeter(pattern, "*");
            }
            sw.Stop();
            Console.WriteLine("Peter: {0} ms", sw.ElapsedMilliseconds);

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                original.ReplaceGuffa(pattch, '*');
            }
            sw.Stop();
            Console.WriteLine("Guffa: {0} ms", sw.ElapsedMilliseconds);

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                original.ReplaceDirkGently(pattch, '*');
            }
            sw.Stop();
            Console.WriteLine("DirkGently: {0} ms", sw.ElapsedMilliseconds);

            sw.Reset();
            sw.Start();
            for (int i = 0; i < 1000000; i++)
            {
                original.ReplaceJohn(pattch, '*');
            }
            sw.Stop();
            Console.WriteLine("John: {0} ms", sw.ElapsedMilliseconds);
            return 0;
        }
    }
}