The nth Motzkin Number is the number of paths from (0, 0) to (n, 0) where each step is of the form (1, -1), (1, 0) or (1, 1), and the path never goes below y = 0.

Here's an illustration of these paths for n = 1, 2, 3, 4, from the above link:

Motzkin numbers

The desired sequence is OEIS A001006. OEIS has some other characterizations of the sequence.

You will be given a positive integer n as input. You should output the nth Motzkin Number.

Here are Motzkin numbers 1 to 10:

1, 2, 4, 9, 21, 51, 127, 323, 835, 2188

All standard input and output methods are allowed. Standard loopholes apply.

This is code golf. Fewest bytes wins.

  • \$\begingroup\$ What's the minimum set of Motzkin numbers we must be able to generate? \$\endgroup\$ Commented Dec 17, 2015 at 8:09
  • 2
    \$\begingroup\$ Related \$\endgroup\$
    – user45941
    Commented Dec 17, 2015 at 8:15
  • \$\begingroup\$ @FlagAsSpam All of them, up to limitations of time/memory/data type. \$\endgroup\$
    – isaacg
    Commented Dec 17, 2015 at 8:35
  • \$\begingroup\$ I think languages need a Dyck words builtin now. \$\endgroup\$
    – lirtosiast
    Commented Dec 17, 2015 at 16:21

19 Answers 19


MATL, 13 14 bytes



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

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.


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)
  • 1
    \$\begingroup\$ This answer is tied for the shortest, and older by about an hour and a half, so I'm accepting it. \$\endgroup\$
    – isaacg
    Commented Jan 5, 2016 at 23:51
  • \$\begingroup\$ Thanks! I could hardly imagine MATL would even be tied with Pyth. It's such a hard language to beat, good job designing it! \$\endgroup\$
    – Luis Mendo
    Commented Jan 6, 2016 at 0:17

Retina, 59 58 bytes


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.


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.
  • \$\begingroup\$ It's a shame that '\' has special meaning otherwise using '_/\' characters would better suit the spirit of the question. \$\endgroup\$
    – Neil
    Commented Dec 17, 2015 at 21:30

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

enter image description here

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)

Pyth, 15 bytes


This defines a function y. Try it online: Demonstration


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.

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.


CJam (20 bytes)


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).


Seriously, 21 bytes


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

I use the following formula:

motzkin 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


,;╗                    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
  • \$\begingroup\$ C(n, 2*k) does what now? \$\endgroup\$ Commented Dec 17, 2015 at 8:27
  • \$\begingroup\$ @FlagAsSpam C(n,k) = nCk, or the number of combinations of k items from a pool of n items. \$\endgroup\$
    – user45941
    Commented Dec 17, 2015 at 8:28
  • \$\begingroup\$ Oh, that makes way more sense than what I thought it was. +1. \$\endgroup\$ Commented Dec 17, 2015 at 8:34
  • \$\begingroup\$ @FlagAsSpam I don't think I want to know what you thought it was... \$\endgroup\$
    – user45941
    Commented Dec 17, 2015 at 8:34

R, 64 bytes


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

Mathematica, 31 30 bytes


For fun, here's a 37 byte version


and 52 byte version


Jelly, 17 14 13 bytes


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.

Mathematica, 44 42 34 bytes


A 35 bytes version:


05AB1E, 13 12 bytes


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.


Stax, 12 bytes


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])

Pari/GP, 38 36 26 bytes


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 \$.

  • \$\begingroup\$ A 14-bytes Samau function using the first definition of the trinomial coefficient: );;7 2D$ⁿ$)╡$÷. I won't post it as an answer because the language is newer than the question. \$\endgroup\$
    – alephalpha
    Commented Dec 24, 2015 at 14:01
  • \$\begingroup\$ Posting it is just fine, you just have to add a disclaimer that the submission isn't eligible to win because, as you said, the language is newer than the question. \$\endgroup\$
    – Alex A.
    Commented Dec 24, 2015 at 17:20

Ruby, 50

straightforward implementation of the recurrence relation.


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}\$.


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!

  • \$\begingroup\$ 52 bytes \$\endgroup\$
    – Delfad0r
    Commented May 7, 2021 at 15:17
  • \$\begingroup\$ @Delfad0r Thanks, I updated it! \$\endgroup\$
    – flawr
    Commented May 7, 2021 at 15:48

Maxima, 49 bytes

Use the formula

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


Try it online!


ES6, 44 bytes


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


Nekomata + -n, 8 bytes


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.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.