TI-BASIC (TI-84 Plus CE Python), 37 bytes

Input N
N+1
Ans⁻¹Σ(Ans nCr K(Ans-K) nCr (K-1),K,1,int(.9+.5Ans

uses this equation: $$ a(n)=\frac{\sum_{k=1}^{\left\lceil \frac{n+1}{2} \right\rceil}(\binom{n+1}{k}\binom{n+1-k}{k-1})}{n+1} $$

Maxima, 49 bytes

Use the formula

\$ M_n=\frac{1}{n+1}\cdot[z^{n+2}](1+x+x^2)^n \$

f(n):=coeff(expand((1+x+x^2)^(n+1)),x,n+2)/(n+1);

Try it online!

Nekomata + -n, 8 bytes

3$ŧ←∫Ɔž≥

Attempt This Online!

3$ŧ←∫Ɔž≥    Let n be the input
3$ŧ         Find an n-tuple of integers in [0, 3)
   ←        Decrement each element
    ∫       Take the cumulative sum
     Ɔž     Check that the last element is 0
       ≥    And that each element is non-negative

-n counts the number of solutions.

MATL, 13 14 bytes

i-2/t.5+hH4Zh

Example:

>> matl i-2/t.5+hH4Zh
> 6
51

EDIT (June 16, 2017): you can try it online! Note also that in modern versions of the language (that post-date this challenge) the i could be removed.

Explanation

Pretty straightforward, using the equivalence (see equation (10)) with the hypergeometric function:

$$M_n = {}_2F_1 \left( \frac {1-n} 2, -\frac n 2 ; 2 ;4 \right)$$

From the definition of the hypergeometric function

$${}_2F_1(a,b; c; z) = \sum ^ \infty _ {n=0} \frac {(a)_n (b)_n} {(c)_n} \frac {z^n} {n!}$$

it's clear that the order of the first two arguments can be interchanged, which saves one byte.

i         % input                                                   
-2/       % divide by -2
t.5+      % duplicate and add 0.5
h         % horizontal concatenation into a vector                               
H         % number 2
4         % number literal                                          
Zh        % hypergeometric function with three inputs (first input is a vector)

Haskell, 55 52 bytes

Straightforward implementation of the recursion. Thanks @Delfad0r for -3 bytes!

a n|n>2=div((2*n+1)*a(n-1)+(3*n-3)*a(n-2))$n+2
a n=n

Try it online!

Stax, 12 bytes

îu¬@Y≤ÅÉÑ(πε

Run and debug it

I don't know how to do fancy math typesetting, but this essentially relies on a dynamic programming construction

M(0) = 1
M(1) = 1
M(n + 1) = M(n) + sum(M(k) * M(n - k - 1) for k in [0..n-1])

Brain-Flak, 90 bytes

(([{}]<(())>)<{({}()<{<>([({})]({}[({})]({}<>{}<>)))<>}<>>)}>){({}()<{}>)}{}({}{}[{}{}]<>)

Try it online!

Computes \${\binom{n}{0}}_2 - {\binom{n}{2}}_2\$, where \$\binom{n}{k}_2\$ is a trinomial coefficient. I couldn't find this formula anywhere, so I can't reference it, but it can be proved in the same way as the analogous formula \$C_n = \binom{2n}{n} - \binom{2n}{n+1}\$.

05AB1E, 13 12 bytes

ÝI<ãʒ.øDŸQ}g

Try it online!

While most answers use a formula or recurrence relation, this is a simple counting approach.

Each possible path through the grid is represented by the list of its y coordinates. For n segments, there are a total of (n+1) points, but the first and last one are necessarily 0, so that leaves (n-1) points to specify.

Ý           # range [0..n]
 I<         # n - 1
   ã        # cartesian power

We now have a list of paths (not yet including the initial and final 0). By construction, none of them ever go below 0. However, some of them have illegal slopes (e.g. jump from 0 to 2), so we need to filter them out.

ʒ      }g   # count how many paths satistfy the following condition
 0.ø        # surround with 0
      Q     # is equal to
    DŸ      # its own fluctuating range

Ÿ is the fluctuating range built-in. If there's any pair of non-adjacent numbers, it will fill in the missing numbers (e.g. [0, 2] becomes [0, 1, 2]). Only legal paths will be left unchanged.

A perhaps more intuitive way to check for illegal slopes would be üαà (assert the maximum of pairwise absolute differences equals 1). However, this misses the flat [0, 0, ... 0] path, which costs one extra byte to fix.

Finally, note that the actual code uses .ø where this explanation uses 0.ø. Instead of surrounding the path with 0s, this surrounds the implicit input with two copies of the path. This turns the coordinate system upside-down and inside-out, but is otherwise equivalent.

Pari/GP, 38 36 26 bytes

n->(1+x+x^2)^n++/n\x^n++%x

Try it online!

Using equation (11) from MathWorld:

\$ M_n = \dfrac{1}{n + 1} \dbinom{n + 1}{1}_2 \$

where \$ \binom{n}{k}_2 \$ is a trinomial coefficient. By definition, \$ \binom{n}{k}_2 \$ is the coefficient of \$ x^{n + k} \$ in the expansion of \$ (1 + x + x^2)^n \$.

Mathematica, 44 42 34 bytes

Sum[#!/(i!(i+1)!(#-2i)!),{i,0,#}]&

A 35 bytes version:

Coefficient[(1+x+1/x)^#,x]/#&[#+1]&

Mathematica, 31 30 bytes

AppellF1[-#/2,.5,-#/2,2,4,4]&

For fun, here's a 37 byte version

Hypergeometric2F1[(1-#)/2,-#/2,2,4]&

and 52 byte version

SeriesCoefficient[1-x-Sqrt[1-2x-3x^2],{x,0,#+2}]/2&

ES6, 44 bytes

f=(n,k=0)=>n<1?1:k<n&&f(k)*f(n-2-k)+f(n,k+1)

Straightforward port of @xnor's recursive Python solution. Needs n<1?1: because n<1|| would make f(0) return true.

Jelly, 17 14 13 bytes

×US;
1;HÇƓ¡1ị

This uses the recurrence relation from @PeterTaylor's answer. Try it online!

How it works

×US;      Define a helper link. Left argument: a (list)

×U        Multiply (×) a by its reverse (U).
  S       Compute the sum of the resulting list.
   ;      Prepend it to a.
          Return the result.

1;HÇƓ¡1ị  Define the main link.

1         Set the left argument to 1.
 ;H       Append the half of 1 to 1. Result: [1, 0.5].
    Ɠ     Read an integer n from STDIN.
   Ç ¡    Call the helper link (Ç) n times.
      1ị  Retrieve the result at index 1.

Ruby, 50

straightforward implementation of the recurrence relation.

g=->n{n<2?1:(3*(n-1)*g[n-2]+(2*n+1)*g[n-1])/(n+2)}

CJam (20 bytes)

.5X]{__W%.*:++}qi*W=

Online demo

As Mego noted in the comments on the question, this is very closely related to the Catalan numbers: change the .5 to 1 and offset the index by one (or simply remove the .5 entirely and leave the index unchanged) to get Catalan numbers.

The recurrence used is

a(n+2) - a(n+1) = a(0)*a(n) + a(1)*a(n-1) + ... + a(n)*a(0). [Bernhart]

from the OEIS page. The corresponding recurrence for the Catalan numbers is listed as

a(n) = Sum_{k=0..n-1} a(k)a(n-1-k).

Retina, 59 58 bytes

+`(\D*)1(1*)
:$1<$2:$1>$2:$1_$2:
:(_|()<|(?<-2>)>)+:(?!\2)

Takes input in unary. Input 7 (i.e. 1111111) takes quite a while but still completes in less than a minute. I wouldn't go much further than that.

Try it online.

Explanation

A different characterisation of the Motzkin numbers is the number of strings of three different characters, where two of them are correctly balanced (hence the close relation to Catalan numbers, which are the same without the third character which is independent of the balancing).

.NET's balancing groups are pretty good at detecting correctly matched strings, so we simply generate all strings of length N (using _, < and > as the three characters) and then we count how many of those are correctly balanced. E.g. for N = 4 the valid strings are:

____
__<>
_<_>
_<>_
<__>
<_>_
<>__
<<>>
<><>

Compared with the definition in the challenge, _ corresponds to a (1,0) step, < to (1,1) and > to (1,-1).

As for the actual code, the : is used as a separator between the different strings. The second regex is just a golfed form of the standard .NET regex for balanced strings.

Something to note is that there is only a single : inserted between strings in each step, but the second regex matches a leading and a trailing : (and since matches cannot overlap, this means that adjacent strings generated from one template in the last step cannot both match). However, this is not a problem, because at most one of those three can ever match:

• If the string ending in _ matches, the prefix without that _ is already balanced correctly, and < or > would throw off that balance.
• If the string ending in > matches, the string is balanced with that >, so _ or < would throw off that balance.
• Strings ending in < can never be balanced.

R, 64 bytes

f=function(n)ifelse(n<2,1,f(n-1)+sum(rev(s<-sapply(2:n-2,f))*s))

Uses also the Mathworld formula of @xnor's python answer. Thanks to rules of precedence, 2:n-2 is equivalent to 0:(n-2).

Test cases:

> f(0)
[1] 1
> f(1)
[1] 1
> f(5)
[1] 21
> f(10)
[1] 2188
> sapply(0:20,f)
 [1]        1        1        2        4        9       21       51      127
 [9]      323      835     2188     5798    15511    41835   113634   310572
[17]   853467  2356779  6536382 18199284 50852019

Pyth, 15 bytes

Ls*V+KyMb1+t_K1

This defines a function y. Try it online: Demonstration

Explanation:

Let y[n] be the n-th Motzkin Number. I calculate y[n] with the formula

y[n] = dot product of (y[0], ..., y[n-1], 1) and (y[n-2], ..., y[0], 1)

Notice that the first vector is larger than the second one (except when calculating y[0]). When this is the case, than Pyth automatically ignores the 1 at the end of the first vector, so that both vectors are of equal length.

Ls*V+KyMb1+t_K1
L                 define a function y(b), which returns:
      yMb            compute the list [y[0], y[1], ..., y[b-1]]
     K               assign it to K
  *V                 vectorized multiplication of
    +K   1             * K with a 1 at the end
          +t_K1        * reverse(K), remove the first element, and append 1
 s                   return the sum (dot product)

This formula is a variation of one of the formulas listed on OEIS. It may be a little bit stupid. Because of the 1 at the end of the first vector (which make the lengths unequal), I don't actually have to give the recursion a base case. And I had hopes, that the two +...1s can be golfed somehow. Turns out I can't.

You can define a similar recursion with a dot product of equal length vectors and define the base case y[0] = 1 with with the same byte count.

Python 2, 51 bytes

M=lambda n:n<1or sum(M(k)*M(n-2-k)for k in range(n))

Uses the formula from Mathworld

Saves chars by putting the M[n-1] term into the summation as k=n-1, which gives M[-1]*M[n-1], with M[-1]=1 as part of the initial condition.

Edit: One char shorter writing the sum recursively:

M=lambda n,k=0:n<1or k<n and M(k)*M(n-2-k)+M(n,k+1)

Other approaches that turned out longer:

M=lambda n,i=0:n and(i>0)*M(n-1,i-1)+M(n-1,i)+M(n-1,i+1)or i==0
M=lambda n:+(n<2)or(3*~-n*M(n-2)+(n-~n)*M(n-1))/(n+2)

Seriously, 21 bytes

,;╗r`;τ╜█@;u@τ╣║\*`MΣ

Borrows some code from quintopia's Catalan Numbers solution, specifically the improvement I made in the comments.

I use the following formula:

Since nCk is 0 for k > n, I sum all the way to n-1, since those values will all be 0 and thus do not affect the sum.

Try it online

Explanation:

,;╗r`;τ╜█@;u@τ╣║\*`MΣ
,;╗                    push input, dupe, store one copy in register 0
   r                   push range(0, n) ([0,n-1])
    `             `M   map the function:
     ;τ╜█@               dupe k, push C(n, 2*k), swap with k
          ;u@τ╣║\        push the kth Catalan number
                 *       multiply
                    Σ  sum