//Rextester.Program.Main is the entry point for your code. Don't change it.

//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

​

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Linq;

using System.Text;

​

namespace Rextester

{

    public class Program

    {

        //common start for all three methods here -- pull it out to help with potential benchmarking later

        public static string PreProcess(string input)

        {

            byte[] r = Convert.FromBase64String(input);

            return BitConverter.ToString(r);

        } 

        public static string Original(string input)

        {   

            input = PreProcess(input);          

            string c = input.Replace("-", string.Empty);

            string h = c.Replace("A", "K").Replace("B", "L").Replace("C", "M").Replace("D", "N").Replace("E", "O")

                .Replace("F", "P").Replace("0", "A").Replace("1","B").Replace("2", "C").Replace("3", "D").Replace("4", "E")

                .Replace("5", "F").Replace("6", "G").Replace("7", "H").Replace("8", "I")

                .Replace("9", "J");

            return h.ToLower();

        }

        private static Dictionary<char, char> map = new Dictionary<char, char> {

            {'A', 'k'}, {'B', 'l'}, {'C', 'm'}, {'D', 'n'}, {'E', 'o'}, {'F', 'p'},

            {'0', 'a'},{'1', 'b'}, {'2', 'c'}, {'3', 'd'},{'4', 'e'}, {'5', 'f'},

            {'6', 'g'},{'7', 'h'},{'8', 'i'}, {'9', 'j'}

        };

        public static string MyOption1(string input)

        {

            input = PreProcess(input);          

            return string.Create(2*(input.Length+1)/3 , input, (r, d) => {

                int i = 0;

                foreach(char c in d)

                {   

                    if (c == '-') continue;

                    r[i++] = map[c];

                }

            });

        }

        public static string MyOption2(string input)

        {

            input = PreProcess(input);          

            var result = new StringBuilder(2*(input.Length+1)/3);

            foreach(char c in input)

            {

                if (c == '-') continue;

                result.Append(map[c]);

            }

            return result.ToString();

        }

        private static string OtherOption1(string input)

        {

            input = PreProcess(input);

            StringBuilder sb = new StringBuilder(input.Replace("-", ""));

            foreach(char x in map.Keys)

                sb.Replace(x, map[x]);

            return sb.ToString().ToLower();

        }

        const string lookup = "abcdefghijklmnop";

        private static string OtherOption2(string input)

        {

            byte[] r = Convert.FromBase64String(input);

            return string.Concat(r.Select(b => "" +  lookup[b >> 4] + lookup[b & 0xf]));    

        }

        private static string OtherOption3(string input)

        {

            byte[] buf = Convert.FromBase64String(input);

            var result = new StringBuilder(buf.Length*2);

            foreach (byte b in buf)

            {

                result.Append(lookup[b >> 4]).Append(lookup[b & 0xf]);

            }

            return result.ToString();

        }

        private static string OtherOption4(string input)

        {

            return string.Concat(PreProcess(input).Replace("-", string.Empty)

                .Select(s => char.IsLetter(s) ? (char)(s + 42) : (char)('a' + (s - '0'))));

        }

        private static string OtherOption5(string input)

        {

            input = PreProcess(input);

            var result = new StringBuilder(2*(input.Length+1)/3);

            foreach (char s in input)

            {

                if (s == '-') continue;

                result.Append( char.IsLetter(s) ? (char)(s + 42) : (char)('a' + (s - '0')) );

            }

            return result.ToString();

        }

        private static Stopwatch watcher;

        public static (string, long,string) TimeIt(string name, string input, Func<string,string> method)

        {

            watcher = Stopwatch.StartNew();

            var result = method(input);

            watcher.Stop();

            var time = watcher.ElapsedTicks;

            return (name, time, result);

        }

        public static void Main(string[] args)

        {

            // always in the form AA-BB-CC etc

            string baseData = "XFEWtnopccImhpHTzGeoeXBg4ws=";

            string input = PreProcess(baseData);            

            string temp = "OTAtMTctMjMtMDktNDItMzM="; // "90-17-23-09-42-33"; //random, used to force JIT of methods so JIT won't pollute stopwatch times;

            string t0 = Original(temp);

            string t1 = MyOption1(temp);

            string t2 = MyOption2(temp);

            string t3 = OtherOption1(temp);

            string t4 = OtherOption2(temp);

            string t5 = OtherOption3(temp);

            string t6 = OtherOption4(temp);

            string t7 = OtherOption5(temp);

            var results = new List<(string, long, string)>();

            results.Add(TimeIt("Original", baseData, Original));

            results.Add(TimeIt("Option 1", baseData, MyOption1));

            results.Add(TimeIt("Option 2", baseData, MyOption2));

            results.Add(TimeIt("AltOpt 1", baseData, OtherOption1));

            results.Add(TimeIt("AltOpt 2", baseData, OtherOption2));

            results.Add(TimeIt("AltOpt 3", baseData, OtherOption3));

            results.Add(TimeIt("AltOpt 4", baseData, OtherOption4));

            results.Add(TimeIt("AltOpt 5", baseData, OtherOption5));

​

            foreach (var tuple in results)

            {

                Console.WriteLine($"{tuple.Item1} Time: {tuple.Item2,5}\tResult: {tuple.Item3}");

            }

        }

    }

}