C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Text;
using System.Collections.Generic;
using System.IO;

namespace blah
{
    class Program
    {
        static void Main(string[] args)
        {
            var stringAsArray = Encoding.UTF8.GetBytes("hello world");
            int loopCount = 256000;
            {
                var n = DateTime.Now;
                for (int i = 0; i < loopCount; i++)
                {
                    var encoded = Base91.Encode("hello world");
                    var decoded = Base91.Decode(encoded);
                }
                var e = DateTime.Now;
                Console.WriteLine("Base91 "+ (e - n));
            }
            {
                var n = DateTime.Now;
                for (int i = 0; i < loopCount; i++)
                {
                    var encoded = Ascii85.Encode(stringAsArray);
                    var decoded = Ascii85.Decode(encoded);
                }
                var e = DateTime.Now;
                Console.WriteLine("Base85 "+ (e - n));
            }
            {
                var n = DateTime.Now;
                for (int i = 0; i < loopCount; i++)
                {
                    var encoded = Convert.ToBase64String(stringAsArray);
                    var decoded = Convert.FromBase64String(encoded);
                }
                var e = DateTime.Now;
                Console.WriteLine("Base64 "+ (e - n));
            }
        }
    }
    class Base91
    {
        private static char[] EncodeTable = new char[] 
        {
		    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
		    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
		    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
		    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
		    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
		    '%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
		    '>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'
        };

        private static Dictionary<byte, int> DecodeTable;

        static Base91()
        {
            InitDecodeTable();
        }

        private static void InitDecodeTable()
        {
            DecodeTable = new Dictionary<byte, int>();
            for (int i = 0; i < 255; i++)
            {
                DecodeTable[(byte)i] = -1;
            }
            for (int i = 0; i < EncodeTable.Length; i++)
            {
                DecodeTable[(byte)EncodeTable[i]] = i;
            }
        }

        public static string Encode(string input)
        {
            StringBuilder output = new StringBuilder();
            int b = 0;
            int n = 0;
            int v = 0;
            for (int i = 0; i < input.Length; i++)
            {
                b |= (byte)input[i] << n;
                n += 8;
                if (n > 13)
                {
                    v = b & 8191;
                    if (v > 88)
                    {
                        b >>= 13;
                        n -= 13;
                    }
                    else
                    {
                        v = b & 16383;
                        b >>= 14;
                        n -= 14;
                    }
                    output.Append((char)EncodeTable[v % 91]);
                    output.Append((char)EncodeTable[v / 91]);
                }
            }
            if (n != 0)
            {
                output.Append((char)EncodeTable[b % 91]);
                if (n > 7 || b > 90)
                    output.Append((char)EncodeTable[b / 91]);
            }
            return output.ToString();
        }

        public static string Decode(string input)
        {
            StringBuilder output = new StringBuilder();
            int c = 0;
            int v = -1;
            int b = 0;
            int n = 0;
            for (int i = 0; i < input.Length; i++)
            {
                c = DecodeTable[(byte)input[i]];
                if (c == -1) continue;
                if (v < 0)
                {
                    v = c;
                }
                else
                {
                    v += c * 91;
                    b |= v << n;
                    n += (v & 8191) > 88 ? 13 : 14;
                    do
                    {
                        output.Append((char)(b & 255));
                        b >>= 8;
                        n -= 8;
                    } while (n > 7);
                    v = -1;
                }
            }
            if (v + 1 != 0)
            {
                output.Append((char)((b | v << n) & 255));
            }
            return output.ToString();
        }
    }
public static class Ascii85
	{
		/// <summary>
		/// Encodes the specified byte array in Ascii85.
		/// </summary>
		/// <param name="bytes">The bytes to encode.</param>
		/// <returns>An Ascii85-encoded string representing the input byte array.</returns>
		public static string Encode(byte[] bytes)
		{
			if (bytes == null)
				throw new ArgumentNullException("bytes");

			// preallocate a StringBuilder with enough room to store the encoded bytes
			StringBuilder sb = new StringBuilder(bytes.Length * 5 / 4);

			// walk the bytes
			int count = 0;
			uint value = 0;
			foreach (byte b in bytes)
			{
				// build a 32-bit value from the bytes
				value |= ((uint) b) << (24 - (count * 8));
				count++;

				// every 32 bits, convert the previous 4 bytes into 5 Ascii85 characters
				if (count == 4)
				{
					if (value == 0)
						sb.Append('z');
					else
						EncodeValue(sb, value, 0);
					count = 0;
					value = 0;
				}
			}

			// encode any remaining bytes (that weren't a multiple of 4)
			if (count > 0)
				EncodeValue(sb, value, 4 - count);

			return sb.ToString();
		}

		/// <summary>
		/// Decodes the specified Ascii85 string into the corresponding byte array.
		/// </summary>
		/// <param name="encoded">The Ascii85 string.</param>
		/// <returns>The decoded byte array.</returns>
		public static byte[] Decode(string encoded)
		{
			if (encoded == null)
				throw new ArgumentNullException("encoded");

			// preallocate a memory stream with enough capacity to hold the decoded data
			using (MemoryStream stream = new MemoryStream(encoded.Length * 4 / 5))
			{
				// walk the input string
				int count = 0;
				uint value = 0;
				foreach (char ch in encoded)
				{
					if (ch == 'z' && count == 0)
					{
						// handle "z" block specially
						DecodeValue(stream, value, 0);
					}
					else if (ch < c_firstCharacter || ch > c_lastCharacter)
					{
						//throw new FormatException("Invalid character '{0}' in Ascii85 block.".FormatInvariant(ch));
					}
					else
					{
						// build a 32-bit value from the input characters
						try
						{
							checked { value += (uint) (s_powersOf85[count] * (ch - c_firstCharacter)); }
						}
						catch (OverflowException ex)
						{
							throw new FormatException("The current group of characters decodes to a value greater than UInt32.MaxValue.", ex);
						}
						
						count++;

						// every five characters, convert the characters into the equivalent byte array
						if (count == 5)
						{
							DecodeValue(stream, value, 0);
							count = 0;
							value = 0;
						}
					}
				}

				if (count == 1)
				{
					throw new FormatException("The final Ascii85 block must contain more than one character.");
				}
				else if (count > 1)
				{
					// decode any remaining characters
					for (int padding = count; padding < 5; padding++)
					{
						try
						{
							checked { value += 84 * s_powersOf85[padding]; }
						}
						catch (OverflowException ex)
						{
							throw new FormatException("The current group of characters decodes to a value greater than UInt32.MaxValue.", ex);
						}
					}
					DecodeValue(stream, value, 5 - count);
				}

				return stream.ToArray();
			}
		}

		// Writes the Ascii85 characters for a 32-bit value to a StringBuilder.
		private static void EncodeValue(StringBuilder sb, uint value, int paddingBytes)
		{
			char[] encoded = new char[5];

			for (int index = 4; index >= 0; index--)
			{
				encoded[index] = (char) ((value % 85) + c_firstCharacter);
				value /= 85;
			}

			if (paddingBytes != 0)
				Array.Resize(ref encoded, 5 - paddingBytes);

			sb.Append(encoded);
		}

		// Writes the bytes of a 32-bit value to a stream.
		private static void DecodeValue(Stream stream, uint value, int paddingChars)
		{
			stream.WriteByte((byte) (value >> 24));
			if (paddingChars == 3)
				return;
			stream.WriteByte((byte) ((value >> 16) & 0xFF));
			if (paddingChars == 2)
				return;
			stream.WriteByte(((byte) ((value >> 8) & 0xFF)));
			if (paddingChars == 1)
				return;
			stream.WriteByte((byte) (value & 0xFF));
		}

		// the first and last characters used in the Ascii85 encoding character set
		const char c_firstCharacter = '!';
		const char c_lastCharacter = 'u';

		static readonly uint[] s_powersOf85 = new uint[] { 85u * 85u * 85u * 85u, 85u * 85u * 85u, 85u * 85u, 85u, 1 };
	}

}

​x
 
using System;
using System.Text;
using System.Collections.Generic;
using System.IO;
​
namespace blah
{
    class Program
    {
        static void Main(string[] args)
        {
            var stringAsArray = Encoding.UTF8.GetBytes("hello world");
            int loopCount = 256000;
            {
                var n = DateTime.Now;
                for (int i = 0; i < loopCount; i++)
                {
                    var encoded = Base91.Encode("hello world");
                    var decoded = Base91.Decode(encoded);
                }
                var e = DateTime.Now;
                Console.WriteLine("Base91 "+ (e - n));
            }
            {
                var n = DateTime.Now;
                for (int i = 0; i < loopCount; i++)
                {
                    var encoded = Ascii85.Encode(stringAsArray);
                    var decoded = Ascii85.Decode(encoded);
                }
                var e = DateTime.Now;
                Console.WriteLine("Base85 "+ (e - n));
            }
            {
                var n = DateTime.Now;
                for (int i = 0; i < loopCount; i++)
                {
                    var encoded = Convert.ToBase64String(stringAsArray);
                    var decoded = Convert.FromBase64String(encoded);
                }
                var e = DateTime.Now;
                Console.WriteLine("Base64 "+ (e - n));
            }
        }
    }
    class Base91
    {
        private static char[] EncodeTable = new char[] 
        {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
            'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
            'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
            'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
            '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '!', '#', '$',
            '%', '&', '(', ')', '*', '+', ',', '.', '/', ':', ';', '<', '=',
            '>', '?', '@', '[', ']', '^', '_', '`', '{', '|', '}', '~', '"'
        };
​
        private static Dictionary<byte, int> DecodeTable;
​
        static Base91()
        {
            InitDecodeTable();
        }
​
        private static void InitDecodeTable()
        {
            DecodeTable = new Dictionary<byte, int>();
            for (int i = 0; i < 255; i++)
            {
                DecodeTable[(byte)i] = -1;
            }
            for (int i = 0; i < EncodeTable.Length; i++)
            {
                DecodeTable[(byte)EncodeTable[i]] = i;
            }
        }
​
        public static string Encode(string input)
        {
            StringBuilder output = new StringBuilder();
            int b = 0;
            int n = 0;
            int v = 0;
            for (int i = 0; i < input.Length; i++)
            {
                b |= (byte)input[i] << n;
                n += 8;
                if (n > 13)
                {
                    v = b & 8191;
                    if (v > 88)
                    {
                        b >>= 13;
                        n -= 13;
                    }
                    else
                    {
                        v = b & 16383;
                        b >>= 14;
                        n -= 14;
                    }
                    output.Append((char)EncodeTable[v % 91]);
                    output.Append((char)EncodeTable[v / 91]);
                }
            }
            if (n != 0)
            {
                output.Append((char)EncodeTable[b % 91]);
                if (n > 7 || b > 90)
                    output.Append((char)EncodeTable[b / 91]);
            }
            return output.ToString();
        }
​
        public static string Decode(string input)
        {
            StringBuilder output = new StringBuilder();
            int c = 0;
            int v = -1;
            int b = 0;
            int n = 0;
            for (int i = 0; i < input.Length; i++)
            {
                c = DecodeTable[(byte)input[i]];
                if (c == -1) continue;
                if (v < 0)
                {
                    v = c;
                }
                else
                {
                    v += c * 91;
                    b |= v << n;
                    n += (v & 8191) > 88 ? 13 : 14;
                    do
                    {
                        output.Append((char)(b & 255));
                        b >>= 8;
                        n -= 8;
                    } while (n > 7);
                    v = -1;
                }
            }
            if (v + 1 != 0)
            {
                output.Append((char)((b | v << n) & 255));
            }
            return output.ToString();
        }
    }
public static class Ascii85
    {
        /// <summary>
        /// Encodes the specified byte array in Ascii85.
        /// </summary>
        /// <param name="bytes">The bytes to encode.</param>
        /// <returns>An Ascii85-encoded string representing the input byte array.</returns>
        public static string Encode(byte[] bytes)
        {
            if (bytes == null)
                throw new ArgumentNullException("bytes");
​
            // preallocate a StringBuilder with enough room to store the encoded bytes
            StringBuilder sb = new StringBuilder(bytes.Length * 5 / 4);
​
            // walk the bytes
            int count = 0;
            uint value = 0;
            foreach (byte b in bytes)
            {
                // build a 32-bit value from the bytes
                value |= ((uint) b) << (24 - (count * 8));
                count++;
​
                // every 32 bits, convert the previous 4 bytes into 5 Ascii85 characters
                if (count == 4)
                {
                    if (value == 0)
                        sb.Append('z');
                    else
                        EncodeValue(sb, value, 0);
                    count = 0;
                    value = 0;
                }
            }
​
            // encode any remaining bytes (that weren't a multiple of 4)
            if (count > 0)
                EncodeValue(sb, value, 4 - count);
​
            return sb.ToString();
        }
​
        /// <summary>
        /// Decodes the specified Ascii85 string into the corresponding byte array.
        /// </summary>
        /// <param name="encoded">The Ascii85 string.</param>
        /// <returns>The decoded byte array.</returns>
        public static byte[] Decode(string encoded)
        {
            if (encoded == null)
                throw new ArgumentNullException("encoded");
​
            // preallocate a memory stream with enough capacity to hold the decoded data
            using (MemoryStream stream = new MemoryStream(encoded.Length * 4 / 5))
            {
                // walk the input string
                int count = 0;
                uint value = 0;
                foreach (char ch in encoded)
                {
                    if (ch == 'z' && count == 0)
                    {
                        // handle "z" block specially
                        DecodeValue(stream, value, 0);
                    }
                    else if (ch < c_firstCharacter || ch > c_lastCharacter)
                    {
                        //throw new FormatException("Invalid character '{0}' in Ascii85 block.".FormatInvariant(ch));
                    }
                    else
                    {
                        // build a 32-bit value from the input characters
                        try
                        {
                            checked { value += (uint) (s_powersOf85[count] * (ch - c_firstCharacter)); }
                        }
                        catch (OverflowException ex)
                        {
                            throw new FormatException("The current group of characters decodes to a value greater than UInt32.MaxValue.", ex);
                        }
                        
                        count++;
​
                        // every five characters, convert the characters into the equivalent byte array
                        if (count == 5)
                        {
                            DecodeValue(stream, value, 0);
                            count = 0;
                            value = 0;
                        }
                    }
                }
​
                if (count == 1)
                {
                    throw new FormatException("The final Ascii85 block must contain more than one character.");
                }
                else if (count > 1)
                {
                    // decode any remaining characters
                    for (int padding = count; padding < 5; padding++)
                    {
                        try
                        {
                            checked { value += 84 * s_powersOf85[padding]; }
                        }
                        catch (OverflowException ex)
                        {
                            throw new FormatException("The current group of characters decodes to a value greater than UInt32.MaxValue.", ex);
                        }
                    }
                    DecodeValue(stream, value, 5 - count);
                }
​
                return stream.ToArray();
            }
        }
​
        // Writes the Ascii85 characters for a 32-bit value to a StringBuilder.
        private static void EncodeValue(StringBuilder sb, uint value, int paddingBytes)
        {
            char[] encoded = new char[5];
​
            for (int index = 4; index >= 0; index--)
            {
                encoded[index] = (char) ((value % 85) + c_firstCharacter);
                value /= 85;
            }
​
            if (paddingBytes != 0)
                Array.Resize(ref encoded, 5 - paddingBytes);
​
            sb.Append(encoded);
        }
​
        // Writes the bytes of a 32-bit value to a stream.
        private static void DecodeValue(Stream stream, uint value, int paddingChars)
        {
            stream.WriteByte((byte) (value >> 24));
            if (paddingChars == 3)
                return;
            stream.WriteByte((byte) ((value >> 16) & 0xFF));
            if (paddingChars == 2)
                return;
            stream.WriteByte(((byte) ((value >> 8) & 0xFF)));
            if (paddingChars == 1)
                return;
            stream.WriteByte((byte) (value & 0xFF));
        }
​
        // the first and last characters used in the Ascii85 encoding character set
        const char c_firstCharacter = '!';
        const char c_lastCharacter = 'u';
​
        static readonly uint[] s_powersOf85 = new uint[] { 85u * 85u * 85u * 85u, 85u * 85u * 85u, 85u * 85u, 85u, 1 };
    }
​
}
​

Last Run:	11:53:21 am
Compile:	0.425s
Execute:	0s
Memory:	28kb
CPU:	0.062s

View IL Code