Motzkin Numbers

30

2

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.

isaacg

Posted 2015-12-17T08:05:05.523

Reputation: 39 268

What's the minimum set of Motzkin numbers we must be able to generate? – Addison Crump – 2015-12-17T08:09:43.900

2Related – Mego – 2015-12-17T08:15:45.890

@FlagAsSpam All of them, up to limitations of time/memory/data type. – isaacg – 2015-12-17T08:35:16.433

I think languages need a Dyck words builtin now. – lirtosiast – 2015-12-17T16:21:31.053

Answers

15

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:

enter image description here

From the definition of the hypergeometric function

enter image description here

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)

Luis Mendo

Posted 2015-12-17T08:05:05.523

Reputation: 87 464

1This answer is tied for the shortest, and older by about an hour and a half, so I'm accepting it. – isaacg – 2016-01-05T23:51:00.617

Thanks! I could hardly imagine MATL would even be tied with Pyth. It's such a hard language to beat, good job designing it! – Luis Mendo – 2016-01-06T00:17:24.540

11

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.

Martin Ender

Posted 2015-12-17T08:05:05.523

Reputation: 184 808

It's a shame that '' has special meaning otherwise using '_/' characters would better suit the spirit of the question. – Neil – 2015-12-17T21:30:31.850

9

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)

xnor

Posted 2015-12-17T08:05:05.523

Reputation: 115 687

8

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

Peter Taylor

Posted 2015-12-17T08:05:05.523

Reputation: 41 901

8

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.

Jakube

Posted 2015-12-17T08:05:05.523

Reputation: 21 462

6

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:

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

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

Mego

Posted 2015-12-17T08:05:05.523

Reputation: 32 998

C(n, 2*k) does what now? – Addison Crump – 2015-12-17T08:27:50.793

@FlagAsSpam C(n,k) = nCk, or the number of combinations of k items from a pool of n items. – Mego – 2015-12-17T08:28:32.160

Oh, that makes way more sense than what I thought it was. +1. – Addison Crump – 2015-12-17T08:34:06.020

@FlagAsSpam I don't think I want to know what you thought it was... – Mego – 2015-12-17T08:34:33.410

5

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

plannapus

Posted 2015-12-17T08:05:05.523

Reputation: 8 610

5

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&

Chip Hurst

Posted 2015-12-17T08:05:05.523

Reputation: 151

4

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.

Dennis

Posted 2015-12-17T08:05:05.523

Reputation: 196 637

2

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.

Grimmy

Posted 2015-12-17T08:05:05.523

Reputation: 12 521

2

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

recursive

Posted 2015-12-17T08:05:05.523

Reputation: 8 616

2

Mathematica, 44 42 34 bytes

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

A 35 bytes version:

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

alephalpha

Posted 2015-12-17T08:05:05.523

Reputation: 23 988

2

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

alephalpha

Posted 2015-12-17T08:05:05.523

Reputation: 23 988

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.

– alephalpha – 2015-12-24T14:01:16.127

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. – Alex A. – 2015-12-24T17:20:51.860

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

Nitrodon

Posted 2015-12-17T08:05:05.523

Reputation: 9 181

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

Level River St

Posted 2015-12-17T08:05:05.523

Reputation: 22 049

0

Haskell, 55 bytes

Straightforward implementation of the recursion.

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

Try it online!

flawr

Posted 2015-12-17T08:05:05.523

Reputation: 40 560

0

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.

Neil

Posted 2015-12-17T08:05:05.523

Reputation: 95 035