Fastest way to solve chain-calculations

Question

I have a input like

string input = \"14 + 2 * 32 / 60 + 43 - 7 + 3 - 1 + 0 * 7 + 87 - 32 / 34\"; 
// up to 10MB string size

int result = Calc(input); // 11
         


        

Answer 1

Edit edit: updated with latest versions by The General and Mirai Mann:

If you want to know which horse is fastest: race the horses. Here are BenchmarkDotNet results comparing various answers from this question (I have not merged their code into my full example, because that feels wrong - only the numbers are presented) with repeatable but large random input, via:

static MyTests()
{
    Random rand = new Random(12345);
    StringBuilder input = new StringBuilder();
    string operators = "+-*/";
    var lastOperator = '+';
    for (int i = 0; i < 1000000; i++)
    {
        var @operator = operators[rand.Next(0, 4)];
        input.Append(rand.Next(lastOperator == '/' ? 1 : 0, 100) + " " + @operator + " ");
        lastOperator = @operator;
    }
    input.Append(rand.Next(0, 100));
    expression = input.ToString();
}
private static readonly string expression;

with sanity checks (to check they all do the right thing):

Original: -1426
NoSubStrings: -1426
NoSubStringsUnsafe: -1426
TheGeneral4: -1426
MiraiMann1: -1426

we get timings (note: Original is OP's version in the question; NoSubStrings[Unsafe] is my versions from below, and two other versions from other answers by user-name):

(lower "Mean" is better)

(note; there is a newer version of Mirai Mann's implementation, but I no longer have things setup to run a new test; but: fair to assume it should be better!)

Runtime: .NET Framework 4.7 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.2633.0

             Method |      Mean |     Error |    StdDev |
------------------- |----------:|----------:|----------:|
           Original | 104.11 ms | 1.4920 ms | 1.3226 ms |
       NoSubStrings |  21.99 ms | 0.4335 ms | 0.7122 ms |
 NoSubStringsUnsafe |  20.53 ms | 0.4103 ms | 0.6967 ms |
        TheGeneral4 |  15.50 ms | 0.3020 ms | 0.5369 ms |
         MiraiMann1 |  15.54 ms | 0.3096 ms | 0.4133 ms |

Runtime: .NET Framework 4.7 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.2633.0

             Method |      Mean |     Error |    StdDev |    Median |
------------------- |----------:|----------:|----------:|----------:|
           Original | 114.15 ms | 1.3142 ms | 1.0974 ms | 114.13 ms |
       NoSubStrings |  21.33 ms | 0.4161 ms | 0.6354 ms |  20.93 ms |
 NoSubStringsUnsafe |  19.24 ms | 0.3832 ms | 0.5245 ms |  19.43 ms |
        TheGeneral4 |  13.97 ms | 0.2795 ms | 0.2745 ms |  13.86 ms |
         MiraiMann1 |  15.60 ms | 0.3090 ms | 0.4125 ms |  15.53 ms |

Runtime: .NET Core 2.1.0-preview1-26116-04 (CoreCLR 4.6.26116.03, CoreFX 4.6.26116.01), 64bit RyuJIT

             Method |      Mean |     Error |    StdDev |    Median |
------------------- |----------:|----------:|----------:|----------:|
           Original | 101.51 ms | 1.7807 ms | 1.5786 ms | 101.44 ms |
       NoSubStrings |  21.36 ms | 0.4281 ms | 0.5414 ms |  21.07 ms |
 NoSubStringsUnsafe |  19.85 ms | 0.4172 ms | 0.6737 ms |  19.80 ms |
        TheGeneral4 |  14.06 ms | 0.2788 ms | 0.3723 ms |  13.82 ms |
         MiraiMann1 |  15.88 ms | 0.3153 ms | 0.5922 ms |  15.45 ms |

---

Original answer from before I added BenchmarkDotNet:

If I was trying this, I'd be tempted to have a look at the Span work in 2.1 previews - the point being that a Span can be sliced without allocating (and a string can be converted to a Span without allocating); this would allow the string carving and parsing to be performed without any allocations. However, reducing allocations is not always quite the same thing as raw performance (although they are related), so to know if it was faster: you'd need to race your horses (i.e. compare them).

If Span isn't an option: you can still do the same thing by tracking an int offset manually and just *never using SubString)

In either case (string or Span): if your operation only needs to cope with a certain subset of representations of integers, I might be tempted to hand role a custom int.Parse equivalent that doesn't apply as many rules (cultures, alternative layouts, etc), and which works without needing a Substring - for example it could take a string and ref int offset, where the offset is updated to be where the parse stopped (either because it hit an operator or a space), and which worked.

Something like:

static class P
{
    static void Main()
    {
        string input = "14 + 2 * 32 / 60 + 43 - 7 + 3 - 1 + 0 * 7 + 87 - 32 / 34";

        var val = Evaluate(input);
        System.Console.WriteLine(val);
    }
    static int Evaluate(string expression)
    {
        int offset = 0;
        SkipSpaces(expression, ref offset);
        int value = ReadInt32(expression, ref offset);
        while(ReadNext(expression, ref offset, out char @operator, out int operand))
        {
            switch(@operator)
            {
                case '+': value = value + operand; break;
                case '-': value = value - operand; break;
                case '*': value = value * operand; break;
                case '/': value = value / operand; break;
            }
        }
        return value;
    }
    static bool ReadNext(string value, ref int offset,
        out char @operator, out int operand)
    {
        SkipSpaces(value, ref offset);

        if(offset >= value.Length)
        {
            @operator = (char)0;
            operand = 0;
            return false;
        }

        @operator = value[offset++];
        SkipSpaces(value, ref offset);

        if (offset >= value.Length)
        {
            operand = 0;
            return false;
        }
        operand = ReadInt32(value, ref offset);
        return true;
    }

    static void SkipSpaces(string value, ref int offset)
    {
        while (offset < value.Length && value[offset] == ' ') offset++;
    }
    static int ReadInt32(string value, ref int offset)
    {
        bool isNeg = false;
        char c = value[offset++];
        int i = (c - '0');
        if(c == '-')
        {
            isNeg = true;
            i = 0;
            // todo: what to do here if `-` is not followed by [0-9]?
        }

        while (offset < value.Length && (c = value[offset++]) >= '0' && c <= '9')
            i = (i * 10) + (c - '0');
        return isNeg ? -i : i;
    }
}

Next, I might consider whether it is worthwhile switching to unsafe to remove the double length checks. So I'd implement it both ways, and test it with something like BenchmarkDotNet to see whether it is worth it.

---

Edit: here is is with unsafe added and BenchmarkDotNet usage:

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using System;

static class P
{
    static void Main()
    {
        var summary = BenchmarkRunner.Run();
        System.Console.WriteLine(summary);
    }

}
public class MyTests
{
    const string expression = "14 + 2 * 32 / 60 + 43 - 7 + 3 - 1 + 0 * 7 + 87 - 32 / 34";
    [Benchmark]
    public int Original() => EvalOriginal.Calc(expression);
    [Benchmark]
    public int NoSubStrings() => EvalNoSubStrings.Evaluate(expression);
    [Benchmark]
    public int NoSubStringsUnsafe() => EvalNoSubStringsUnsafe.Evaluate(expression);
}
static class EvalOriginal
{
    public static int Calc(string sInput)
    {
        int iCurrent = sInput.IndexOf(' ');
        int iResult = int.Parse(sInput.Substring(0, iCurrent));
        int iNext = 0;
        while ((iNext = sInput.IndexOf(' ', iCurrent + 4)) != -1)
        {
            iResult = Operate(iResult, sInput[iCurrent + 1], int.Parse(sInput.Substring((iCurrent + 3), iNext - (iCurrent + 2))));
            iCurrent = iNext;
        }
        return Operate(iResult, sInput[iCurrent + 1], int.Parse(sInput.Substring((iCurrent + 3))));
    }

    public static int Operate(int iReturn, char cOperator, int iOperant)
    {
        switch (cOperator)
        {
            case '+':
                return (iReturn + iOperant);
            case '-':
                return (iReturn - iOperant);
            case '*':
                return (iReturn * iOperant);
            case '/':
                return (iReturn / iOperant);
            default:
                throw new Exception("Error");
        }
    }
}
static class EvalNoSubStrings {
    public static int Evaluate(string expression)
    {
        int offset = 0;
        SkipSpaces(expression, ref offset);
        int value = ReadInt32(expression, ref offset);
        while (ReadNext(expression, ref offset, out char @operator, out int operand))
        {
            switch (@operator)
            {
                case '+': value = value + operand; break;
                case '-': value = value - operand; break;
                case '*': value = value * operand; break;
                case '/': value = value / operand; break;
                default: throw new Exception("Error");
            }
        }
        return value;
    }
    static bool ReadNext(string value, ref int offset,
        out char @operator, out int operand)
    {
        SkipSpaces(value, ref offset);

        if (offset >= value.Length)
        {
            @operator = (char)0;
            operand = 0;
            return false;
        }

        @operator = value[offset++];
        SkipSpaces(value, ref offset);

        if (offset >= value.Length)
        {
            operand = 0;
            return false;
        }
        operand = ReadInt32(value, ref offset);
        return true;
    }

    static void SkipSpaces(string value, ref int offset)
    {
        while (offset < value.Length && value[offset] == ' ') offset++;
    }
    static int ReadInt32(string value, ref int offset)
    {
        bool isNeg = false;
        char c = value[offset++];
        int i = (c - '0');
        if (c == '-')
        {
            isNeg = true;
            i = 0;
        }

        while (offset < value.Length && (c = value[offset++]) >= '0' && c <= '9')
            i = (i * 10) + (c - '0');
        return isNeg ? -i : i;
    }
}

static unsafe class EvalNoSubStringsUnsafe
{
    public static int Evaluate(string expression)
    {

        fixed (char* ptr = expression)
        {
            int len = expression.Length;
            var c = ptr;
            SkipSpaces(ref c, ref len);
            int value = ReadInt32(ref c, ref len);
            while (len > 0 && ReadNext(ref c, ref len, out char @operator, out int operand))
            {
                switch (@operator)
                {
                    case '+': value = value + operand; break;
                    case '-': value = value - operand; break;
                    case '*': value = value * operand; break;
                    case '/': value = value / operand; break;
                    default: throw new Exception("Error");
                }
            }
            return value;
        }
    }
    static bool ReadNext(ref char* c, ref int len,
        out char @operator, out int operand)
    {
        SkipSpaces(ref c, ref len);

        if (len-- == 0)
        {
            @operator = (char)0;
            operand = 0;
            return false;
        }
        @operator = *c++;
        SkipSpaces(ref c, ref len);

        if (len == 0)
        {
            operand = 0;
            return false;
        }
        operand = ReadInt32(ref c, ref len);
        return true;
    }

    static void SkipSpaces(ref char* c, ref int len)
    {
        while (len != 0 && *c == ' ') { c++;len--; }
    }
    static int ReadInt32(ref char* c, ref int len)
    {
        bool isNeg = false;
        char ch = *c++;
        len--;
        int i = (ch - '0');
        if (ch == '-')
        {
            isNeg = true;
            i = 0;
        }

        while (len-- != 0 && (ch = *c++) >= '0' && ch <= '9')
            i = (i * 10) + (ch - '0');
        return isNeg ? -i : i;
    }
}