Demonstration of ChessBoard Traveling (CoderByte)
I see some things that may help you improve your code.

Fix the input parsing

The idea is sound but the implementation is flawed. Instead of the complex method currently used, I'd recommend using this single function:

std::replace_if(str.begin(), str.end(), 
        [](char ch){ return !std::isdigit(ch); }, ' ');


Using this, we're guaranteed that the string will contain only spaces and digits.

Use objects

I'd suggest that one could make good use of a Point2D object to make calculations very clear:

struct Point2D {
    int x = 0;
    int y = 0;
    int dx(const Point2D &amp;other) const {
        return x - other.x;
    }
    int dy(const Point2D &amp;other) const {
        return y - other.y;
    }
    friend std::istream&amp; operator&gt;&gt;(std::istream &amp;in, Point2D &amp;p) {
        return in &gt;&gt; p.x &gt;&gt; p.y;
    }
};


Reduce the numerical range for calculations

The current code uses a generic factorial which boils down to $$\frac{(dx + dy)!}{dx! dy!}$$  The maximum for \$dx\$ or \$dy\$ is 7, so the largest factorial required is \$14! = 87178291200\$.  ... Or is it?  In fact, we could consider instead how to generically calculate $$\frac{n!}{m!}$$ with \$m &lt; n\$.  A simple way to do this is like so: 

constexpr unsigned factDelta(unsigned n, unsigned m) {
    return n &gt; m ? n * factDelta(n-1, m) : 1;
}


And the ordinary factorial function could be expressed as:

constexpr unsigned fact(unsigned n) {
    return factDelta(n, 1);
}


This can reduce the range of the multiplications somewhat, especially if we always choose the larger of \$dx\$ or \$dy\$ to divide.  This means that the return value will always be \$&lt;= 7! = 5040\$ which easily fits into an unsigned.  Note, however, that these functions will overflow if they're given numbers outside that range.  For that reason, I'd recommend making them static functions and/or doing range checking.

Don't alter passed parameters

The current number_Of_Steps() routine takes a reference to a string and then alters the string.  It's not strictly wrong, but it's probably not the best interface design.  I would not expect that the passed string was altered.  Two ways to address this would be to pass a const reference or to simply declare the argument as std::string str which makes a local copy.  Because of the need to alter the string (by removing punctuation), I'd recommend the latter approach.

A worked example

Here's an alternative function that uses the functions and objects described above:

int alt(std::string str) {
    std::replace_if(str.begin(), str.end(), 
            [](char ch){ return !std::isdigit(ch); }, ' ');
    std::istringstream in(str);
    Point2D a; 
    Point2D b;
    in &gt;&gt; a &gt;&gt; b;
    int dx = b.dx(a);
    int dy = b.dy(a);
    if (dx &lt;= 0 || dy &lt;= 0) {
        return 0;
    }
    int m = dx + dy;
    if (dy &gt; dx) {
        std::swap(dx, dy);
    }
    return factDelta(m, dx) / fact(dy);
}