Catalan numbers: Difference between revisions

*[[Evaluate binomial coefficients]]

<br><br>

=={{header|11l}}==

L(n) 1..15

print(c)

2674440

</pre>

=={{header|360 Assembly}}==

Very compact version.

USING CATALAN,R15

LA R7,1 c=1

15 9694845

</pre>

=={{header|ABAP}}==

This works for ABAP Version 7.40 and above

report z_catalan_numbers.

C(14) = 2674440

</pre>

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

PROC Main()

C(15)=9694845

</pre>

=={{header|Ada}}==

procedure Test_Catalan is

15 = 9694845

</pre>

=={{header|ALGOL 68}}==

# (64-bit quantities in Algol 68G which can handle up to C23) #

15: 9694845

</pre>

=={{header|ALGOL W}}==

% print the catalan numbers up to C15 %

integer Cprev;

15: 9694845

</pre>

=={{header|APL}}==

{{out}}

<pre>1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440</pre>

=={{header|Arturo}}==

if? n=0 -> 1

else -> div (catalan n-1) * (4*n)-2 n+1

14 2674440

15 9694845</pre>

=={{header|AutoHotkey}}==

As AutoHotkey has no BigInt, the formula had to be tweaked to prevent overflow. It still fails after n=22

out .= "`n" Catalan(A_Index)

Msgbox % clipboard := SubStr(out, 2)

2674440

9694845</pre>

=={{header|AWK}}==

BEGIN {

for (i=0; i<=15; i++) {

15 9694845

</pre>

=={{header|BASIC}}==

{{works with|FreeBASIC}}

Use of <code>REDIM PRESERVE</code> means this will not work in QBasic (although that could be worked around if desired).

REDIM SHARED results(0) AS SINGLE

==={{header|GW-BASIC}}===

20 C(0) = 1

30 PRINT 0, C(0)

==={{header|Minimal BASIC}}===

{{trans|GW-BASIC}}

10 REM Catalan numbers

20 DIM C(15)

The specification asks for the first 15 Catalan numbers. A lot of the other implementations produce either C(0) to C(15), which is 16 numbers, or else C(1) to C(15)—which is 15 numbers, but I'm not convinced they're the first 15. This program produces C(0) to C(14).

20 LET X=N

30 GOSUB 130

==={{Header|Tiny BASIC}}===

Integers are limited to 32767 so only the first ten Catalan numbers can be represented. And even then one has to do some finagling to avoid internal overflows.

10 LET N = 0

20 LET C = 1

9 4862

10 16796</pre>

=={{header|BASIC256}}==

{{trans|FreeBASIC}}

if n = 0 then return 1

return n * factorial(n - 1)

{{out}}

<pre>Same as FreeBASIC entry.</pre>

=={{header|BBC BASIC}}==

20 PRINT FNcatalan(i%)

30 NEXT

742900

2674440</pre>

=={{header|Befunge}}==

{{trans|Ada}}

v 2-1*2p00 :+1g00\< $

> **00g1+/^v,*84,"="<

14 = 2674440

15 = 9694845</pre>

=={{header|Bracmat}}==

& ( C

=

);</syntaxhighlight>

{{out}}

C0 = 1

C1 = 1

+ 9694845*X^15

</syntaxhighlight>

=={{header|Brat}}==

true? n == 0

{ 1 }

15 - 9694845

</pre>

=={{header|C}}==

All three methods mentioned in the task:

typedef unsigned long long ull;

14 2674440 2674440 2674440

15 9694845 9694845 9694845

=={{header|C sharp|C#}}==

{

/// <summary>

It took 0.3 to execute

</pre>

=={{header|C++}}==

===4 Classes===

We declare 4 classes representing the four different algorithms for calculating Catalan numbers as given in the description of the task. In addition, we declare two supporting classes for the calculation of factorials and binomial coefficients. Because these two are only internal supporting code they are hidden in namespace 'detail'. Overloading the function call operator to execute the calculation is an obvious decision when using C++. (algorithms.h)

#define __ALGORITHMS_H__

#endif //!defined __ALGORITHMS_H__</syntaxhighlight>

Here is the implementation of the algorithms. The c'tor of each class tells us the algorithm which will be used. (algorithms.cpp)

using std::cout;

using std::endl;

}</syntaxhighlight>

In order to test what we have done, a class Test is created. Using the template parameters N (number of Catalan numbers to be calculated) and A (the kind of algorithm to be used) the compiler will create code for all the test cases we need. What would C++ be without templates ;-) (tester.h)

#define __TESTER_H__

#endif //!defined __TESTER_H__</syntaxhighlight>

Finally, we test the four different algorithms. Note that the first one (direct calculation using the factorial) only works up to N = 10 because some intermediate result (namely (2n)! with n = 11) exceeds the boundaries of an unsigned 64 bit integer. (catalanNumbersTest.cpp)

#include "tester.h"

using namespace rosetta::catalanNumbers;

C(15) = 9694845

</pre>

=={{header|Clojure}}==

(defn catalan-numbers-direct []

user> (take 15 (catalan-numbers-recursive))

(1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440)</syntaxhighlight>

=={{header|Common Lisp}}==

With all three methods defined.

;; factorial. CLISP actually has "!" defined for this

(labels ((! (x) (if (zerop x) 1 (* x (! (1- x))))))

(format t "~%Method ~d:~%" i)

(dotimes (i 16) (format t "C(~2d) = ~d~%" i (funcall f i))))</syntaxhighlight>

=={{header|Crystal}}==

{{trans|Ruby}}

require "benchmark"

15 : 9694845 9694845 9694845

</pre>

=={{header|D}}==

auto product(R)(R r) { return reduce!q{a * b}(1.BigInt, r); }

[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440]

[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440]</pre>

=={{header|Delphi}}==

See [https://www.rosettacode.org/wiki/Catalan_numbers#Pascal Pascal].

=={{header|EasyLang}}==

if n = 0

ans = 1

2674440

</pre>

=={{header|EchoLisp}}==

{{incorrect|Echolisp|series starts 1, 1, 2, ...}}

(lib 'sequences)

(lib 'bigint)

→ 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845

</syntaxhighlight>

=={{header|EDSAC order code}}==

The Catalan numbers are here computed by the second method, as a sum of products.

But if we multiply two 35-bit integers A and B, the result is really A*B*(2^-68),

and needs to be multiplied by 2^34 to get the same scaling as for A and B.

[Calculation of Catalan numbers.

EDSAC program, Initial Orders 2.]

15 9694845

</pre>

=={{header|Eiffel}}==

class

APPLICATION

2674440

</pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def cat(n), do: div( factorial(2*n), factorial(n+1) * factorial(n) )

[1,1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440]

</pre>

=={{header|Erlang}}==

-export([test/0]).

[1,1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440]

</pre>

=={{header|ERRE}}==

PROCEDURE CATALAN(N->RES)

15 = 9694845

</pre>

=={{header|Euphoria}}==

--User:Lnettnay

9694845

</pre>

=={{header|F_Sharp|F#}}==

Seq.unfold(fun (c,n) -> let cc = 2*(2*n-1)*c/(n+1) in Some(c,(cc,n+1))) (1,1) |> Seq.take 15 |> Seq.iter (printf "%i, ")

</syntaxhighlight>

1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440,

</pre>

=={{header|Factor}}==

The first method:

: catalan ( n -- n ) [ 1 + recip ] [ 2 * ] [ nCk * ] tri ;

The last method, memoized by using arrays.

: next ( seq -- newseq )

{{out}}

Similar to above.

=={{header|Fantom}}==

{{incorrect|Fantom|series starts 1, 1, 2, ...}}

{

static Int factorial (Int n)

15 -2 9694845 9694845

</pre>

=={{header|Fermat}}==

for i=1 to 15 do !Catalan(i);!' ' od;</syntaxhighlight>

{{out}}<pre>

1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845

</pre>

=={{header|Forth}}==

=={{header|Fortran}}==

{{works with|Fortran|90 and later}}

!=======================================================================================

implicit none

===============

</pre>

=={{header|FreeBASIC}}==

Function factorial(n As UInteger) As UInteger

15 9694845 9694845 9694845

</pre>

=={{header|Frink}}==

Frink includes efficient algorithms for calculating arbitrarily-large binomial coefficients and automatically caches factorials.

for n = 0 to 15

println[catalan[n]]</syntaxhighlight>

=={{header|FunL}}==

import util.TextTable

+----+------------+---------+-----------+

</pre>

=={{header|Fōrmulæ}}==

In '''[https://formulae.org/?example=Catalan_numbers this]''' page you can see the program(s) related to this task and their results.

=={{header|GAP}}==

Catalan2 := n -> Binomial(2*n, n)/(n + 1);

# Same output for all four:

# [ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440 ]</syntaxhighlight>

=={{header|Go}}==

Direct:

import (

</pre>

Recursive (alternative):

package main

9694845

</pre>

=={{header|Groovy}}==

class Catalan

{

9694845

</pre>

=={{header|Harbour}}==

PROCEDURE Main()

LOCAL i

5: 9694845

</pre>

=={{header|Haskell}}==

-- definitions in the problem statement.

[1,1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440]

[1,1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440]</pre>

=={{header|Icon}} and {{header|Unicon}}==

every writes(catalan(0 to 14)," ")

end

{{out}}

<pre>1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440</pre>

=={{header|J}}==

1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440</syntaxhighlight>

=={{header|Java}}==

Replace double inexact computations with BigInteger implementation.

import java.math.BigInteger;

import java.util.ArrayList;

C(15) = 9,694,845 9,694,845 9,694,845

</pre>

=={{header|JavaScript}}==

<body><pre id='x'></pre><script type="application/javascript">

function disp(x) {

14 2674440 2674440 2674440

15 9694845 9694845 9694845</pre>

=={{header|jq}}==

{{ works with|jq|1.4 }}

that formula is used (a) to define a function for computing a single Catalan number; (b) to define a function for generating a sequence of Catalan numbers; and (c) to write a single expression for generating a sequence of Catalan numbers using jq's builtin "recurse/1" filter.

==== Compute a single Catalan number====

if . == 0 then 1

elif . < 0 then error("catalan is not defined on \(.)")

end;</syntaxhighlight>

'''Example 1'''

{{Out}}

<div style="overflow:scroll; height:150px;">

[0,1]

[1,1]

==== Generate a sequence of Catalan numbers ====

def _catalan: # state: [n, catalan(n)]

if .[0] > max then empty

</syntaxhighlight>

'''Example 2''':

{{Out}}

As above for 0 to 15.

==== An expression to generate Catalan numbers ====

[0,1]

| recurse( if .[0] == 15 then empty

{{out}}

As above for 0 to 15.

=={{header|Julia}}==

{{works with|Julia|0.6}}

@show catalannum.(1:15)

(In the second example, we have used arbitrary-precision integers to avoid overflow for large Catalan numbers.)

=={{header|K}}==

catalan'!:15

1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440</syntaxhighlight>

=={{header|Kotlin}}==

{{works with|Java|1.7.0}}

{{works with|Kotlin|1.1.4}}

abstract operator fun invoke(n: Int) : Double

2674440 2674440 2674440

9694845 9694845 9694845</pre>

=={{header|langur}}==

{{trans|Perl}}

val .catalan = f(.n) .factorial(2 x .n) / .factorial(.n+1) / .factorial(.n)

10000: 224537812493385215633593584257360578701103586219365887773293713835854436588700534490998102719114320210209905393799589701149327326500953702713977513001838761306936534407802585494454599941773729984591764542782202886796997833276495496514760245912220654267091568311812071300891219894022165175451441066691435091975969499731921675488934120638046514134965974069039677192984714638704528752769863567952620334847707274529741976558104236293861846622622783294667505268651205024766408784881872997404042356319626323351089169906635603513309014645157443570842822082866699012415455339518777770781742052837799476906230350785959040487158118992753484022865373274100095762968510625236915280143408460651206678398725681703811505423791566261735329550627967717189932855983913468867794806585863794483869239933179341394259456515091026456652770409848702116046445406995085092488210998732255656992243441519938747425554228724734242623566663631968254490897214106655375215196762710825001305055093871863518797311135688370964194817463890187212845332422257193414201244344808864449873736345425670715824582633802476282521798739438044652622163657359012681653473214512797365047989922327391063907061792126264420963262176161781711086630089636828211837643128677915076724947168653050318426339007489738275045346257959685376480042860870398232333705506506342394485443047987642390287346746539674780326188825579548593281319807827279403944008553690033855132088140116099772393778770685018936338194366302053586633406848404622048675525765095697363909787189635178694239275237185046710057476484117945279786897787624602379494797322427251542758312638233073625857897083435831841717971137851874666094337671443717108457737153283641719103639784923520519013700030680553564442331411313831920775983175313709250333784211385811480015293165463406576311626295629412110652218717603537723650144357966952842696678735624157616428716812764985074925414219421312810089785108621126934245959900367104035334200067714905754827856122801987429837706493130435832752072139392743006620396370486473952500144779413596417260472218266529167783118015414918168260722824885550181735638670588682513610805160133611349864194033776132438535863120087679096358696928233598996870302136347936567444208209125300149683552369341937471817860835774359234009557030148123353114950735217736514617017504851011193104728986836180908987352236659629183725016607437110422583156042941955830763092095074443334625318588569114114087985404048889671202396824806275701581378689568449507132793603852731445602923990458926101180821029108808623323378547869169352237448925371763574346501610378415722137519019474474794069155118626291447578558908522430436148987521551911541787974276591708584289036595642180860178815462862735993859177180582760389253540408842580225467216988321950591728369194164290645992782274919561096308372635908842325870580231011459216934235078490764707633348336131667313582584404397290232519769625777374165187949140092779343812345117947306771376053099536367169631889642304360871187460737580808157222861127968703067542270175460553478533349238111434409526724363429611803844595968793121871649699680963646793415774160274520010905236593324062464542927011227158945796188186430711399250096518886617184049325827319276468018789191520522185358895653192882843061349706085770767046601045697944646638311930027354235643643713545212361580694059553720806659066661496416423676930095857438882302891350789287291844752601744462789158506243012088536936184422120232369244564444689340142897415432231452353338115944183447986470689449043710051589958391273681116292415738776171575775695905846247205522469202801517417551374761549677412720803623129527503286287755308576386461385928958587649159872019202866614901547860974883963007792442796064165417207167072370586790722366932349325253877744621251386864069101337572557790214048760202008337611577675840153696735860276810033694744314488435390547908483357054897387317002405793108554524629034558098886977538473481750772616164313845337139245688079995996839933620829828339492800825536599964878893947278408890351634126931068657027524005795713514365098086505030570362785115155293306343520969872400876180105031975302255898787642403303027682634969586730202117121076117629457710028105378124677420093990476071697970354661002217702623344454780740808459286778553016318604430682610618871098652904537323336381304469735192868285840882036271136058499391069436145426450229039329475974178236465920534171895204155964515055983303017823692138977622016292722019365841360360274557488926673754175222061483328914099598663902320310143583379354121664996173733086613692927391384486261610892314450463841637667054196985332620403539011932606618414419229492637564924726411270720189611019154677281846409387514072618176832310721327819277699943226895919915049652045449281057471199978267843961724883768772155477073354744908923995448752333726740642292872107500458349718026322755698226793850983280706045951407323891263270928264657562125955511946782954645656015480418543664557515041692091317941000997342935512311493290722434384401250133402934163457264794261787386862382738330195237770190998115114193014769006071380834085352290585937952429981509893303796306071520571655936820282768086579891336876000368502562579738337809071051261343359121744773055264455701014137255399929760233753812017596045145926791136761130783810840502248142803073720015451941006030172192834375431286154255159659778817089767964922549014569972777126726537787896968876337799235679125368824867754881036161730805613471278633981478858113141202728303435218970292775366288829203013873713349923690394124920402725698544786016048685431525811047414746045227535216327530901827040588505255466803793791888002231571686068617764292584075135236237044383334893874602177596602979234717936820827427229615827657960492946059695301906791494260652411424538532836730097985187522379068364429583532675896349363295120431429006688249818006722311568902288350452581968418068616818268667067741994472455501649753611708445979082338902214467454627107888156489438584617793175431865532382711812960546611287516640

</pre>

=={{header|Liberty BASIC}}==

print catNonRec(5)

for i = 0 to 15

14 = 2674440

15 = 9694845</pre>

=={{header|Logo}}==

output ifelse [less? :n 1] 1 [product :n factorial difference :n 1]

end

742900

2674440</pre>

=={{header|Lua}}==

catalan = {[0] = 1}

setmetatable(catalan, {

742900

2674440</pre>

=={{header|MAD}}==

DIMENSION C(15)

C(13) = 742900

C(14) = 2674440</pre>

=={{header|Maple}}==

return seq( (2*i)!/((i + 1)!*i!), i = 0 .. n - 1 );

end proc:

1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440

</pre>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{out|Sample Output}}

//TableForm=

1

2674440

9694845</syntaxhighlight>

=={{header|MATLAB}} / {{header|Octave}}==

for i = (1:length(n))

n(i) = (1/(n(i)+1))*nchoosek(2*n(i),n(i));

end</syntaxhighlight>

The following version computes at the same time the n first Catalan numbers (including C0).

n = [1 cumprod((2:4:4*n-6) ./ (2:n))];

end</syntaxhighlight>

{{out|Sample Output}}

ans =

The following version uses the identity Ln(x!)=Gammaln(x+1) and prod(1:x)=sum(ln(1:x))

CatalanNumber=@(n) round(exp(gammaln(2*n+1)-sum(gammaln([n+2 n+1]))));

</syntaxhighlight>

{{out|Sample Output}}

ans =

</syntaxhighlight>

=={{header|Maxima}}==

cata[n] := sum(cata[i]*cata[n - 1 - i], i, 0, n - 1)$

cata[0]: 1$

/* both return [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440] */</syntaxhighlight>

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

ReadChar

END CatalanNumbers.</syntaxhighlight>

=={{header|Nim}}==

import strformat

14 2674440 2674440 2674440

15 9694845 9694845 9694845</pre>

=={{header|OCaml}}==

let return = ref 1 in

for i = 1 to n do

memoized (10000000 runs) : 0.167

...</pre>

=={{header|Oforth}}==

n ifZero: [ 1 ] else: [ catalan( n 1- ) 2 n * 1- * 2 * n 1+ / ] ;</syntaxhighlight>

[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845]

</pre>

=={{header|ooRexx}}==

Three versions of this.

say "catI("i") =" .catalan~catI(i)

say "catR1("i") =" .catalan~catR1(i)

catR1(15) = 9694845

catR2(15) = 9694845</pre>

=={{header|PARI/GP}}==

Memoization is not worthwhile; PARI has fast built-in facilities for calculating binomial coefficients and factorials.

A second version:

Naive version with binary splitting:

Naive version:

my(t=1);

for(k=n+2,2*n,t*=k);

};</syntaxhighlight>

The first version takes about 1.5 seconds to compute the millionth Catalan number, while the second takes 3.9 seconds. The naive implementations, for comparison, take 21 and 45 minutes. In any case, printing the first 15 is simple:

=={{header|Pascal}}==

function catalanNumber1(n: integer): double;

14 2674440

</pre>

=={{header|Perl}}==

sub catalan {

my $n = shift;

print "$_\t@{[ catalan($_) ]}\n" for 0 .. 20;</syntaxhighlight>

For computing up to 20 ish, memoization is not needed. For much bigger numbers, this is faster:

sub catalan {

use bigint;

That has two downsides: high memory use and slow access to an isolated large value. Using a fast binomial function can solve both these issues. The downside here is if the platform doesn't have the GMP library then binomials won't be fast.

{{libheader|ntheory}}

sub catalan {

my $n = shift;

}

print "$_\t", catalan($_), "\n" for 0 .. 10000;</syntaxhighlight>

=={{header|Phix}}==

See also [[Catalan_numbers/Pascal%27s_triangle#Phix]] which may be faster.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #000080;font-style:italic;">-- returns inf/-nan for n&gt;85, and needs the rounding for n&gt;=14, accurate to n=29</span>

=== memoized recursive gmp version ===

{{libheader|Phix/mpfr}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

100: 896519947090131496687170070074100632420837521538745909320

</pre>

=={{header|PHP}}==

class CatalanNumbersSerie

15 = 9694845

</pre>

<?php

$n = 15;

1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 35357670

</pre>

=={{header|Picat}}==

{{works with|Picat}}

table

factorial(0) = 1.

14. 2674440 = 2674440

</pre>

=={{header|PicoLisp}}==

(de fact (N)

(if (=0 N)

13 => 742900 742900 742900

14 => 2674440 2674440 2674440</pre>

=={{header|PL/I}}==

declare (i, n) fixed;

6564120420

</pre>

=={{header|PlainTeX}}==

\newcount\r

\newcount\x

\bye</syntaxhighlight>

=={{header|PowerShell}}==

function Catalan([uint64]$m) {

function fact([bigint]$n) {

===An Alternate Version===

This version could easily be modified to work with big integers.

function Get-CatalanNumber

{

</syntaxhighlight>

Get the first fifteen Catalan numbers as a PSCustomObject:

0..14 | Get-CatalanNumber

</syntaxhighlight>

</pre>

To return only the array of Catalan numbers:

(0..14 | Get-CatalanNumber).CatalanNumber

</syntaxhighlight>

2674440

</pre>

=={{header|Prolog}}==

{{Works with|SWI-Prolog}}

length(L1, N),

L = [1 | L1],

true .

</pre>

=={{header|PureBasic}}==

Using the third formula...

; numerator by the smallest denominator

33 212336130412243110

</pre>

=={{header|Python}}==

Three algorithms including explicit memoization. (Pythons [http://svn.python.org/view/python/branches/release31-maint/Modules/mathmodule.c?revision=82224&view=markup factorial built-in function] is not memoized internally).

{{Works with|Python|3}}

import functools

The third definition is directly expressible, as an infinite series, in terms of '''itertools.accumulate''':

from itertools import accumulate, chain, count, islice

742900

2674440</pre>

=={{header|Quackery}}==

[ times [ i 1+ / ] ] is /n! ( n --> n )

14 : 2674440

</pre>

=={{header|R}}==

catalan(0:15)

[1] 1 1 2 5 14 42 132 429 1430

[10] 4862 16796 58786 208012 742900 2674440 9694845</syntaxhighlight>

=={{header|Racket}}==

(require planet2)

; (install "this-and-that") ; uncomment to install

'(1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440)

</pre>

=={{header|Raku}}==

(formerly Perl 6)

The recursive formulas are easily written into a constant array, either:

or

742900

2674440</pre>

=={{header|REXX}}==

===version 1===

has been rearranged to:

:::::::: <big> (n+1) * [fact(n) **2] </big>

parse arg LO HI . /*obtain optional arguments from the CL*/

if LO=='' | LO=="," then do; HI=15; LO=0; end /*No args? Then use a range of 0 ──► 15*/

===version 2===

Implements the 3 methods shown in the task description

* 01.07.2014 Walter Pachl

*--------------------------------------------------------------------*/

20 6564120420 6564120420 6564120420

n c1.n c2.n c3.n</pre>

=={{header|Ring}}==

for n = 1 to 15

see catalan(n) + nl

9694845

</pre>

=={{header|Ruby}}==

{{libheader|RubyGems}}

(1..n).reduce(1, :*)

end

15 : 9694845 9694845 9694845

</pre>

=={{header|Run BASIC}}==

PRINT i;" ";catalan(i)

NEXT

14 2674440

15 9694845</pre>

=={{header|Rust}}==

match n {

0 => 1,

c(14) = 2674440

c(15) = 9694845</pre>

=={{header|Scala}}==

Simple and straightforward. Noticeably out of steam without memoizing at about 5000.

object CatalanNumbers {

def main(args: Array[String]): Unit = {

catalan(15) = 9694845

</pre>

=={{header|Scheme}}==

Tail recursive implementation.

(let loop ((c 1)(n 0))

(if (not (eqv? n m))

13: 742900

14: 2674440</pre>

=={{header|Seed7}}==

include "bigint.s7i";

9694845

</pre>

=={{header|Sidef}}==

func c(n) { f(2*n) / f(n) / f(n+1) }</syntaxhighlight>

With memoization:

n == 0 ? 1 : (c(n-1) * (4 * n - 2) / (n + 1))

}</syntaxhighlight>

Calling the function:

say "#{i}\t#{c(i)}"

}</syntaxhighlight>

14 2674440

</pre>

=={{header|smart BASIC}}==

FOR n = 0 TO 15

PRINT n,"#######":catrec(n)

catnonrec = temp

END DEF</syntaxhighlight>

=={{header|Standard ML}}==

* val catalan : int -> int

* Returns the nth Catalan number.

* 9694845

*)</syntaxhighlight>

=={{header|Stata}}==

set obs 15

gen catalan=1 in 1

| 2674440 |

+---------+</pre>

=={{header|Swift}}==

{{trans|Rust}}

switch n {

case 0:

catalan(15) => 9694845

</pre>

=={{header|Tcl}}==

# Memoization wrapper

}</syntaxhighlight>

Demonstration:

puts "C_$i = [expr {catalan($i)}]"

}</syntaxhighlight>

C_49 = 509552245179617138054608572

</pre>

=={{header|TI-83 BASIC}}==

This problem is perfectly suited for a TI calculator.

:Disp (2I)!/((I+1)!I!

:End</syntaxhighlight>

== {{header|TypeScript}} ==

{{trans|GW-BASIC}}

// Catalan numbers

var c: number[] = [1];

15 9694845

</pre>

=={{header|Ursala}}==

#import nat

2674440,

9694845></pre>

=={{header|Vala}}==

public class CatalanNumberGenerator {

private static double factorial(double n) {

Time Elapsed: 76 μs

</pre>

=={{header|VBA}}==

'Computes the first n Catalan numbers according to the first recursion given

Dim Cat() As Long

</pre>

(Expect same result with "Catalan2 15")

=={{header|VBScript}}==

Function catalan(n)

catalan = factorial(2*n)/(factorial(n+1)*factorial(n))

15 = 9694845

</pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Function Factorial(n As Double) As Double

CatalanNumber(15:9694845)

It took 0.8 to execute</pre>

=={{header|Vlang}}==

{{trans|Go}}

fn main() {

2674440

</pre>

=={{header|Wortel}}==

#~ddiFSFmSoFSn

; which stands for: dup dup inc fac swap fac mult swap double fac swap divide

!*#~ddiFSFmSoFSn @til 15

; returns [1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674439.9999999995]</syntaxhighlight>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "/math" for Int

15 9694845

</pre>

=={{header|Yabasic}}==

{{trans|FreeBASIC}}

print " - ----- ------ -----"

print

{{out}}

<pre>Same as FreeBASIC entry.</pre>