Números de Motzkin

30

O enésimo número de Motzkin é o número de caminhos de (0, 0) a (n, 0) em que cada etapa tem a forma (1, -1), (1, 0) ou (1, 1) e o caminho nunca fica abaixo de y = 0.

Aqui está uma ilustração desses caminhos para n = 1, 2, 3, 4, no link acima:

Motzkin numbers

A sequência desejada é OEIS A001006 . OEIS tem algumas outras caracterizações da sequência.


Você receberá um número inteiro positivo n como entrada. Você deve emitir o enésimo número Motzkin.

Aqui estão os números 1 a 10 de Motzkin:

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

Todos os métodos padrão de entrada e saída são permitidos. Aplicam-se brechas padrão .

Isso é código de golfe. Menos bytes ganha.

isaacg
fonte
Qual é o conjunto mínimo de números de Motzkin que devemos ser capazes de gerar?
Addison Crump
2
Related
Mego
@FlagAsSpam Todos eles, até as limitações de tempo / memória / tipo de dados.
Isaacg
Eu acho que as línguas precisam de palavras Dyck embutidas agora.
lirtosiast

Respostas:

15

MATL , 13 14 bytes

i-2/t.5+hH4Zh

Exemplo:

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

EDIT (16 de junho de 2017): você pode experimentá-lo online! Observe também que nas versões modernas do idioma (que pós esse desafio) iforam removidas.

Explicação

Bem simples, usando a equivalência (veja a equação (10)) com o método função hipergeométrica :

enter image description here

A partir da definição da função hipergeométrica

enter image description here

é claro que a ordem dos dois primeiros argumentos pode ser trocada, o que economiza um 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
fonte
1
This answer is tied for the shortest, and older by about an hour and a half, so I'm accepting it.
isaacg
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
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
fonte
It's a shame that '\' has special meaning otherwise using '_/\' characters would better suit the spirit of the question.
Neil
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
fonte
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
fonte
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
fonte
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
fonte
C(n, 2*k) does what now?
Addison Crump
@FlagAsSpam C(n,k) = nCk, or the number of combinations of k items from a pool of n items.
Mego
Oh, that makes way more sense than what I thought it was. +1.
Addison Crump
@FlagAsSpam I don't think I want to know what you thought it was...
Mego
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
fonte
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
fonte
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
fonte
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
fonte
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:

Mn=1n+1(n+11)2

where (nk)2 is a trinomial coefficient. By definition, (nk)2 is the coefficient of xn+k in the expansion of (1+x+x2)n.

alephalpha
fonte
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
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.
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
fonte
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
fonte
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
fonte
1

Brain-Flak, 90 bytes

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

Try it online!

Computes (n0)2(n2)2, where (nk)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 Cn=(2nn)(2nn+1).

Nitrodon
fonte
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
fonte
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
fonte