I numeri catalani ( OEIS ) sono una sequenza di numeri naturali che spesso compaiono in combinatoria.

L'ennesimo numero catalano è il numero di parole di Dyck (stringhe bilanciate di parentesi o parentesi come [[][]]; formalmente definite come una stringa usando due caratteri aeb in modo tale che ogni sottostringa a partire dall'inizio abbia un numero di caratteri maggiore o uguale al numero di caratteri b e l'intera stringa ha lo stesso numero di caratteri aeb) con lunghezza 2n. L'ennesimo numero catalano (per n> = 0) è anche esplicitamente definito come:

A partire da n = 0, i primi 20 numeri catalani sono:

1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845, 35357670, 129644790, 477638700, 1767263190...

Sfida

Scrivi un programma o una funzione completa che accetta un numero intero non negativo n tramite STDIN o un'alternativa accettabile e genera l'ennesimo numero catalano. Il programma deve funzionare almeno per gli ingressi 0-19.

I / O

Ingresso

Il tuo programma deve ricevere input da STDIN, argomenti di funzioni o una delle alternative accettabili per questo meta post. È possibile leggere il numero immesso come rappresentazione decimale standard, rappresentazione unaria o byte.

• Se (e solo se) la tua lingua non è in grado di accettare input da STDIN o qualsiasi altra alternativa accettabile, potrebbe accettare input da una variabile codificata o equivalente equivalente nel programma.

Produzione

Il tuo programma deve emettere l'ennesimo numero catalano su STDOUT, il risultato della funzione o una delle alternative accettabili per questo meta post. È possibile emettere il numero catalano nella sua rappresentazione decimale standard, rappresentazione unaria o byte.

L'output dovrebbe consistere nel numero catalano apprettato, seguito facoltativamente da una o più nuove righe. Nessun altro output può essere generato, tranne un output costante dell'interprete della tua lingua che non può essere soppresso (come un saluto, codici colore ANSI o rientro).

Non si tratta di trovare la lingua più breve. Si tratta di trovare il programma più breve in ogni lingua. Pertanto, non accetterò una risposta.

In questa sfida, le lingue più recenti della sfida sono accettabili purché abbiano un'implementazione. È permesso (e persino incoraggiato) di scrivere questo interprete per una lingua precedentemente non implementata. A parte questo, tutte le regole standard del code-golf devono essere rispettate. Le iscrizioni nella maggior parte delle lingue verranno classificate in byte in una codifica preesistente appropriata (di solito UTF-8). Si noti inoltre che sono consentiti incorporati per il calcolo dell'ennesimo numero catalano.

Catalogare

Lo snippet di stack nella parte inferiore di questo post genera il catalogo dalle risposte a) come elenco della soluzione più breve per lingua eb) come classifica generale.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

## Perl, 43 + 2 (-p flag) = 45 bytes

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 66127; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

C, 78 52 39 34 33 byte

Ancora più magia C (grazie xsot):

c(n){return!n?:(4+6./~n)*c(n-1);}

?: è un'estensione GNU .

Questa volta espandendo la ricorrenza di seguito (grazie xnor e Thomas Kwa):

c(n){return n?(4+6./~n)*c(n-1):1;}

-(n+1)è sostituito da ~n, che è equivalente nel complemento a due e salva 4 byte.

Ancora una volta in funzione, ma questa volta sfruttando la seguente ricorrenza:

c(n){return n?2.*(2*n++-1)/n*c(n-2):1;}

c(n)entra in una ricorsione infinita per negativo n, anche se non è rilevante per questa sfida.

Poiché chiamare una funzione sembra un'alternativa accettabile all'I / O della console:

c(n){double c=1,k=2;while(k<=n)c*=1+n/k++;return c;}

c(n)prende un inte restituisce un int.

Voce originale:

main(n){scanf("%d",&n);double c=1,k=2;while(k<=n)c*=1+n/k++;printf("%.0f",c);}

Invece di calcolare direttamente la definizione, la formula viene riscritta come:

La formula assume n >= 2, ma rappresenta il codice per n = 0e n = 1troppo.

Nel pasticcio C sopra, ne khanno lo stesso ruolo della formula, mentre caccumula il prodotto. Tutti i calcoli vengono eseguiti in virgola mobile utilizzando double, il che è quasi sempre una cattiva idea, ma in questo caso i risultati sono corretti fino a n = 19 almeno, quindi va bene.

float avrebbe salvato 1 byte, purtroppo non è abbastanza preciso.

Gelatina , 4 byte

Ḥc÷‘

Provalo online!

Come funziona

Ḥc÷‘    Left argument: z

Ḥ       Compute 2z.
 c      Hook; apply combinations to 2z and z.
  ÷‘    Divide the result by z+1.

CJam, 12 byte

ri_2,*e!,\)/

Provalo online.

Oltre l'ingresso 11, dovrai dire alla tua VM Java di usare più memoria. E in realtà non consiglierei di andare molto al di là di 11. In teoria, tuttavia, funziona per qualsiasi N, poiché CJam utilizza numeri interi di precisione arbitraria.

Spiegazione

CJam non ha un built-in per i coefficienti binomiali e calcolarli da tre fattoriali richiede molti byte ... quindi dovremo fare qualcosa di meglio. :)

ri  e# Read input and convert it to integer N.
_   e# Duplicate.
2,  e# Push [0 1].
*   e# Repeat this N times, giving [0 1 0 1 ... 0 1] with N zeros and N ones.
e!  e# Compute the _distinct_ permutations of this array.
,   e# Get the number of permutations - the binomial. There happen to be 2n-over-n of
    e# of them. (Since 2n-over-n is the number of ways to choose n elements out of 2n, and
    e# and here we're choosing n positions in a 2n-element array to place the zeros in.)
\   e# Swap with N.
)/  e# Increment and divide the binomial coefficient by N+1.

Mathematica, 16 13 byte

CatalanNumber

Incasso, ragazzi di amirite: /

Versione non integrata (21 byte):

Binomial[2#,#]/(#+1)&

Una versione senza binomio (25 byte):

Product[(#+k)/k,{k,2,#}]&

TI-BASIC, 11 byte

(2Ans) nCr Ans/(Ans+1

Stranamente, nCr ha una precedenza maggiore rispetto alla moltiplicazione.

Python 3, 33 byte

f=lambda n:0**n or(4+6/~n)*f(n-1)

Usa la ricorrenza

f(0) = 1
f(n) = (4-6/(n+1)) * f(n-1)

Il caso base di 0 viene gestito come 0**n or, che si interrompe come 1quando n==0e altrimenti valuta l'espressione ricorsiva a destra. L'operatore bit a bit ~n==-n-1accorcia il denominatore e salva le parentesi.

Python 3 è usato per la sua divisione float. Python 2 potrebbe fare lo stesso con un altro byte da scrivere 6..

J, 8 byte

>:%~]!+:

Questo è un treno monadico; utilizza la formula (2x nCr x) / (x + 1). Provalo qui .

pl, 4 byte

☼ç▲÷

Provalo online.

Spiegazione

In pl, le funzioni tolgono i loro argomenti dallo stack e rimandano il risultato nello stack. Normalmente quando non ci sono abbastanza argomenti nello stack, la funzione fallisce semplicemente in silenzio. Tuttavia, succede qualcosa di speciale quando la quantità di argomenti nello stack è diversa dall'arità della funzione: la variabile di input _viene aggiunta all'elenco degli argomenti:

☼ç▲÷

☼      double: takes _ as the argument since there is nothing on the stack
 ç     combinations: since there is only one item on the stack (and arity is 2), it adds _ to the argument list (combinations(2_,_))
  ▲    increment last used var (_)
   ÷   divide: adds _ to the argument list again

In effetti, questo è lo pseudocodice:

divide(combinations(double(_),_),_+1);

Sesos , 94 86 68 byte

8 byte modificando il fattoriale dalla versione 1 alla versione 2.

18 byte elaborando n!(n+1)!in un solo passaggio. In gran parte ispirato all'algoritmo del test di primalità di Dennis .

hexdump:

0000000: 16f8de a59f17 a0ebba 7f4cd3 e05f3f cf0fd0 a0ebde  ..........L.._?......
0000015: b1c1bb 76fe18 8cc1bb 76fe1c e0fbda 390fda bde3d8  ...v.....v.....9.....
000002a: 000fbe af9d1b b47bc7 cfc11c b47bc7 cff1fa e07bda  .......{.....{.....{.
000003f: 39e83e cf07                                       9.>..

Provalo online!

Usa la formula a(n) = (2n)! / (n!(n+1)!).

• Il fattoriale: versione 1 (sul posto, memoria costante), versione 2 (sul posto, memoria lineare)
• Il moltiplicatore: qui (sul posto, memoria costante)
• Il divisore: qui (non si ferma se non è divisibile)

assembler

set numin
set numout
get
jmp,sub 1,fwd 1,add 1,fwd 2,add 2,rwd 3,jnz
fwd 1,add 1
jmp
  jmp,sub 1,rwd 1,add 1,rwd 1,add 1,rwd 1,add 1,fwd 3,jnz
  rwd 1,sub 1,rwd 1,sub 1,rwd 1
  jmp,sub 1,fwd 3,add 1,rwd 3,jnz
  fwd 1
jnz
fwd 3
jmp
  jmp
    sub 1,rwd 1
    jmp,sub 1,rwd 1,add 1,rwd 1,add 1,fwd 2,jnz
    rwd 2
    jmp,sub 1,fwd 2,add 1,rwd 2,jnz
    fwd 3
  jnz
  rwd 1
  jmp,sub 1,jnz
  rwd 1
  jmp,sub 1,fwd 2,add 1,rwd 2,jnz
  fwd 3
jnz 
fwd 1
jmp
  jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
  fwd 1,sub 1,fwd 1
  jmp,sub 1,rwd 2,add 1,fwd 2,jnz
  rwd 1
jnz
rwd 2
jmp
  jmp
    sub 1,fwd 1
    jmp,sub 1,fwd 1,add 1,fwd 1,add 1,rwd 2,jnz
    fwd 2
    jmp,sub 1,rwd 2,add 1,fwd 2,jnz
    rwd 3
  jnz
  fwd 1
  jmp,sub 1,jnz
  fwd 1
  jmp,sub 1,rwd 2,add 1,fwd 2,jnz
  rwd 3
jnz 
fwd 1
jmp
  fwd 1,add 1,rwd 3
  jmp,sub 1,fwd 1,add 1,fwd 1,sub 1,rwd 2,jnz
  fwd 1
  jmp,sub 1,rwd 1,add 1,fwd 1,jnz
  fwd 1
jnz
fwd 1
put

Equivalente di Brainfuck

Questo script Retina viene utilizzato per generare l'equivalente di Brainfuck. Si noti che accetta solo una cifra come argomento del comando e non verifica se un commento è presente nei commenti.

[->+>>++<<<]>+
[[-<+<+<+>>>]<-<-<[->>>+<<<]>]>>>
[[-<[-<+<+>>]<<[->>+<<]>>>]<[-]<[->>+<<]>>>]>
[[->+>+<<]>->[-<<+>>]<]<<
[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>
[>+<<<[->+>-<<]>[-<+>]>]>

Pyth, 8

/.cyQQhQ

Provalo online o esegui Test Suite

Spiegazione

/.cyQQhQ   ## implicit: Q = eval(input())
/     hQ   ## integer division by (Q + 1)
 .c        ## nCr
   yQ      ## use Q * 2 as n
     Q     ## use Q as r

Scherzi a parte, 9 byte

,;;u)τ╣E\

Dump esadecimale:

2c3b3b7529e7b9455c

Provalo online

Spiegazione:

,                   Read in evaluated input n
 ;;                 Duplicate it twice
   u)               Increment n and rotate it to bottom of stack
     τ╣             Double n, then push 2n-th row of Pascal's triangle
       E            Look-up nth element of the row, and so push 2nCn
        \           Divide it by the n+1 below it.

JavaScript (ES6), 24 byte

Basato sulla risposta di Python .

c=x=>x?(4+6/~x)*c(x-1):1

Come funziona

c=x=>x?(4+6/~x)*c(x-1):1
c=x=>                     // Define a function c that takes a parameter x and returns:
     x?               :1  //  If x == 0, 1.
       (4+6/~x)           //  Otherwise, (4 + (6 / (-x - 1)))
               *c(x-1)    //  times the previous item in the sequence.

Penso che questo sia il più breve possibile, ma i suggerimenti sono ben accetti!

Julia, 23 byte

n->binomial(2n,n)/(n+1)

Questa è una funzione anonima che accetta un numero intero e restituisce un float. Utilizza la formula binomiale di base. Per chiamarlo, dagli un nome, ad es f=n->....

Matlab, 35 25 byte

@(n)nchoosek(2*n,n)/(n+1)

Ottava, 23 byte

@(n)nchoosek(2*n,n++)/n

𝔼𝕊𝕄𝕚𝕟, 3 caratteri / 6 byte

Мƅï

Try it here (Firefox only).

Builtins ftw! Sono contento di aver implementato math.js all'inizio.

Soluzione bonus, 12 caratteri / 19 byte

Мơ 2*ï,ï)/⧺ï

Try it here (Firefox only).

Ay! 19th byte!

Valuta pseudo-ES6 come:

nchoosek(2*input,input)/(input+1)

Haskell, 27 byte

g 0=1
g n=(4-6/(n+1))*g(n-1)

Una formula ricorsiva. Deve esserci un modo per risparmiare sui genitori ...

La presa diretta del prodotto è stata di 2 byte più lunga:

g n=product[4-6/i|i<-[2..n+1]]

Dyalog APL, 9 byte

+∘1÷⍨⊢!+⍨

Questo è un treno monadico; utilizza la formula (2x nCr x) / (x + 1). Provalo online qui .

C, 122 121 119 108 byte

main(j,v)char**v;{long long p=1,i,n=atoi(v[1]);for(j=0,i=n+1;i<2*n;p=(p*++i)/++j);p=n?p/n:p;printf("%d",p);}

Ho usato gcc (GCC) 3.4.4 (cygming special, gdc 0.12, usando dmd 0.125) per compilare in un ambiente cygwin di Windows. L'ingresso arriva dalla riga di comando. È simile alla soluzione Python di Sherlock9 ma i loop sono combinati in uno per evitare il trabocco e ottenere un output fino al 20 ° numero catalano (n = 19).

Javagony , 223 byte

public class C{public static int f(int a,int b){try{int z=1/(b-a);}catch(Exception e){return 1;}return a*f(a+1,b);}public static void main(String[]s){int m=Integer.parseInt(s[0])+1;System.out.println(f(m,2*m-1)/f(1,m)/m);}}

Completamente espanso:

public class C {
    public static int f(int a,int b){
        try {
            int z=1/(b-a);
        } catch (Exception e){
            return 1;
        }
        return a*f(a+1,b);
    }
    public static void main(String[] s){
        int m=Integer.parseInt(s[0])+1;
        System.out.println(f(m,2*m-1)/f(1,m)/m);
    }
}

Japt, 16 bytes

Even Mathematica is shorter. :-/

U*2ª1 o àU l /°U

Try it online!

Ungolfed and explanation

U*2ª 1 o àU l /° U
U*2||1 o àU l /++U

         // Implicit: U = input number
U*2||1   // Take U*2. If it is zero, take 1.
o àU     // Generate a range of this length, and calculate all combinations of length U.
l /++U   // Take the length of the result and divide by (U+1).
         // Implicit: output result

Alternate version, based on the recursive formula:

C=_?(4+6/~Z *C$(Z-1):1};$C(U

Vitsy, 13 Bytes

VV2*FVF/V1+F/
V              Capture the input as a final global variable.
 V             Push it back.
  2*           Multiply it by 2
    F          Factorial.
     VF        Factorial of the input.
       /       Divide the second to top by the first.
        V1+    1+input
           F   Factorial.
            /  Divide.

This is a function in Vitsy. How to make it a program that does this, you ask? Concatenate N. c:

Try it online!

Milky Way 1.5.14, 14 bytes

':2K;*Ny;1+/A!

Explanation

'               # read input from the command line
 :              # duplicate the TOS
  2      1      # push integer to the stack
   K            # push a Pythonic range(0, TOS) as a list
    ;   ;       # swap the TOS and the STOS
     *          # multiply the TOS and STOS
      N         # push a list of the permutations of the TOS (for lists)
       y        # push the length of the TOS
          +     # add the STOS to the TOS
           /    # divide the TOS by the STOS
            A   # push the integer representation of the TOS
             !  # output the TOS

or, alternatively, the much more efficient version:

Milky Way 1.5.14, 22 bytes

'1%{;K£1+k1-6;/4+*}A!

Explanation

'                      # read input from the command line
 1     1  1 6  4       # push integer to the stack
  %{  £           }    # for loop
    ;        ;         # swap the TOS and the STOS
     K                 # push a Pythonic range(0, TOS) as a list
        +       +      # add the TOS and STOS
         k             # push the negative absolute value of the TOS
           -           # subtract the STOS from the TOS
              /        # divide the TOS by the STOS
                 *     # multiply the TOS and the STOS
                   A   # push the integer representation of the TOS
                    !  # output the TOS

Usage

python3 milkyway.py <path-to-code> -i <input-integer>

Clojure/ClojureScript, 53 bytes

(defn c[x](if(= 0 x)1(*(c(dec x))(- 4(/ 6(inc x))))))

Clojure can be pretty frustrating to golf in. It's very pithy while still being very readable, but some of the niftier features are really verbose. (inc x) is more idiomatic than (+ x 1) and "feels" more concise, but doesn't actually save characters. And writing chains of operations is nicer as (->> x inc (/ 6) (- 4)), but it's actually longer than just doing it the ugly way.

Prolog, 42 bytes

Using recursion is almost always the way to go with Prolog.

Code:

0*1.
N*X:-M is N-1,M*Y,X is(4-6/(N+1))*Y.

Example:

19*X.
X = 1767263190.0

Try it online here

Octave, 22 bytes

@(n)prod(4-6./(2:n+1))

Ceylon, 60 bytes

Integer c(Integer n)=>(1:n).fold(1)((p,i)=>p*(n+i)/i)/(n+1);

This works up to C₃₀, as Ceylon's Integers are signed 64-bit numbers (C₃₁ has overflow, will be calculated as -4050872099593203).

I don't know if Ceylon has any built-in higher mathematical functions, but then importing the right package would probably longer than just calculating this by foot.

// Catalan number C_n
//
// Question:  http://codegolf.stackexchange.com/q/66127/2338
// My answer: http://codegolf.stackexchange.com/a/66425/2338

Integer c(Integer n) =>
        // sequence of length n, starting at 1.
        (1:n)
        // starting with 1, for each element i, multiply the result
        // of the previous step by (n+i) and then divide it by i.
    .fold(1)((p, i) => p * (n + i) / i)
        // divide the result by n+1.
        / (n + 1);

R, 35 28 16 bytes

numbers::catalan

Edit: Use numbers package builtin.

MATL, 8 bytes

2*GXnGQ/

Try it online!

Explanation

2*     % take number n as input and multiply by 2
G      % push input again
Xn     % compute "2*n choose n"
G      % push input again
Q      % add 1
/      % divide

05AB1E, 6 bytes

Dxcr>/

Explanation:

Code:     Stack:               Explanation:

Dxcr>/

D         [n, n]               # Duplicate of the stack. Since it's empty, input is used.
 x        [n, n, 2n]           # Pops a, pushes a, a * 2
  c       [n, n nCr 2n]        # Pops a,b pushes a nCr b
   r      [n nCr 2n, n]        # Reverses the stack
    >     [n nCr 2n, n + 1]    # Increment on the last item
     /    [(n nCr 2n)/(n + 1)] # Divides the last two items
                               # Implicit, nothing has printed, so we print the last item

R, 28 bytes

Not using a package, so slightly longer than a previous answer

choose(2*(n=scan()),n)/(n+1)