Números catalães

36

Os números catalães ( OEIS ) são uma sequência de números naturais que geralmente aparecem na combinatória.

O enésimo número catalão é o número de palavras dyck (cadeias equilibradas de parênteses ou colchetes, como [[][]]; formalmente definido como uma cadeia usando dois caracteres aeb, de modo que qualquer substring iniciada no início tenha um número de caracteres maior ou igual ao número de caracteres b, e a sequência inteira tem o mesmo número de caracteres aeb) com o comprimento 2n. O enésimo número catalão (para n> = 0) também é definido explicitamente como:

Começando com n = 0, os 20 primeiros números catalães são:

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

Desafio

Escreva um programa ou função completo que use um número inteiro não negativo n via STDIN ou uma alternativa aceitável e emita o enésimo número catalão. Seu programa deve funcionar no mínimo para as entradas de 0 a 19.

I / O

Entrada

Seu programa deve receber informações de STDIN, argumentos de função ou qualquer uma das alternativas aceitáveis para esta meta post. Você pode ler o número inserido como sua representação decimal padrão, representação unária ou bytes.

  • Se (e somente se) o seu idioma não puder receber informações do STDIN ou de qualquer alternativa aceitável, ele poderá receber informações de uma variável codificada permanentemente ou de um equivalente adequado no programa.

Saída

Seu programa deve gerar o enésimo número catalão em STDOUT, resultado da função ou qualquer uma das alternativas aceitáveis para esta meta postagem. Você pode imprimir o número catalão em sua representação decimal padrão, representação unária ou bytes.

A saída deve consistir no número catalão apropriado, opcionalmente seguido por uma ou mais novas linhas. Nenhuma outra saída pode ser gerada, exceto a saída constante do intérprete do seu idioma que não pode ser suprimida (como uma saudação, códigos de cores ANSI ou recuo).


Não se trata de encontrar o idioma mais curto. Trata-se de encontrar o programa mais curto em todos os idiomas. Portanto, não aceitarei uma resposta.

Nesse desafio, os idiomas mais novos que o desafio são aceitáveis desde que tenham uma implementação. É permitido (e até encorajado) escrever esse intérprete para um idioma anteriormente não implementado. Fora isso, todas as regras padrão do devem ser obedecidas. Os envios na maioria dos idiomas serão pontuados em bytes em uma codificação preexistente apropriada (geralmente UTF-8). Observe também que os internos para o cálculo do enésimo número catalão são permitidos.

Catálogo

O snippet de pilha na parte inferior desta postagem gera o catálogo a partir das respostas a) como uma lista da solução mais curta por idioma eb) como uma tabela geral de líderes.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet:

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

um spaghetto
fonte
Podemos imprimir / retornar um float em vez de um número inteiro?
Alex A.
@AlexA. Isso é aceitável.
a spaghetto
Haverá uma etiqueta oeis ?
Vi.
1
@Vi. Houve uma discussão meta sobre isso um tempo atrás e nós concordamos que OEIS era desnecessário
um Spaghetto
@Vi. Aqui está o meta post: meta.codegolf.stackexchange.com/a/5546/8478 . Quanto a algum raciocínio, é possível encontrar desafios no estilo OEIS de maneira bastante confiável com a sequência e um dos números ou teoria dos números . Se a sequência fornecida realmente está no OEIS, é completamente irrelevante para o desafio.
Martin Ender

Respostas:

26

C, 78 52 39 34 33 bytes

Ainda mais magia C (obrigado xsot):

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

?: é uma extensão GNU .


Desta vez, expandindo a recorrência abaixo (obrigado xnor e Thomas Kwa):

ainda outra recursão

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

-(n+1)é substituído por ~n, que é equivalente ao complemento de dois e salva 4 bytes.


Novamente como uma função, mas desta vez explorando a seguinte recorrência:

repetir

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

c(n)entra em uma recursão infinita para negativo n, embora não seja relevante para esse desafio.


Como chamar uma função parece uma alternativa aceitável para a E / S do console:

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

c(n)pega um inte retorna um int.


Entrada original:

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

Em vez de calcular diretamente a definição, a fórmula é reescrita como:

reescrever

A fórmula assume n >= 2, mas o código representa n = 0e n = 1também.

Na bagunça C acima, ne ktem o mesmo papel que na fórmula, enquanto cacumula o produto. Todos os cálculos são realizados em vírgula flutuante double, o que quase sempre é uma má ideia, mas, neste caso, os resultados estão corretos até n = 19, pelo menos, então está tudo bem.

float teria economizado 1 byte, infelizmente não é preciso o suficiente.

Stefano Sanfilippo
fonte
Não posso testar isso agora, mas acho que você pode reduzi-lo ainda mais:c(n){return!n?:(4+6./~n)*c(n-1);}
xsot 10/12/15
Obrigado @xsot, eu não sabia ?:! Aparentemente, é uma extensão GNU C, mas acho que ainda se qualifica.
Stefano Sanfilippo
23

Gelatina , 4 bytes

Ḥc÷‘

Experimente online!

Como funciona

Ḥc÷‘    Left argument: z

Ḥ       Compute 2z.
 c      Hook; apply combinations to 2z and z.
  ÷‘    Divide the result by z+1.
Dennis
fonte
1
O que significa "hook"? Como cobter 2ze zcomo argumentos?
xnor
@xnor Um gancho significa funções avaliadas como f (x, g (x)). Quando há uma função diádica seguida por outra função diádica, o analisador avalia a primeira como um gancho.
precisa saber é o seguinte
5
@ Dennis Isso é realmente 4 bytes? Com esses caracteres não ASCII, mothereff.in/byte-counter diz 9 bytes
Luis Mendo
@LuisMendo é provavelmente uma codificação diferente
undergroundmonorail
3
O @LuisMendo Jelly usa seu próprio padrão de codificação personalizado, em que cada caractere é um único byte. Com o UTF-8, o código-fonte tem de fato 9 bytes.
Dennis
11

CJam, 12 bytes

ri_2,*e!,\)/

Experimente online.

Além da entrada 11, você precisará informar sua Java VM para usar mais memória. E eu realmente não recomendaria ir muito além do 11. Na teoria, funciona para qualquer N, pois o CJam usa números inteiros de precisão arbitrária.

Explicação

O CJam não possui coeficientes binomiais integrados, e computá-los a partir de três fatoriais leva muitos bytes ... então teremos que fazer algo melhor que isso. :)

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.
Martin Ender
fonte
Isso é muito legal. +1
a spaghetto
Isso é inteligente. Eu tentei com o cálculo dos fatoriais. São necessários apenas dois dos três habituais, pois dois deles são iguais. Ele ainda usou 17 bytes ( ri_2*m!1$m!_*/\)/) na minha implementação. A única coisa boa é que é muito mais rápido. :)
Reto Koradi
11

Mathematica, 16 13 bytes

CatalanNumber

Companheiros de amirita embutidos: /

Versão não integrada (21 bytes):

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

Uma versão sem binômio (25 bytes):

Product[(#+k)/k,{k,2,#}]&
um spaghetto
fonte
10

TI-BASIC, 11 bytes

(2Ans) nCr Ans/(Ans+1

Estranhamente, o nCr tem maior precedência que a multiplicação.

lirtosiast
fonte
10

Python 3, 33 bytes

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

Usa a recorrência

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

O caso base de 0 é tratado como 0**n or, que para como 1quando n==0e avalia a expressão recursiva à direita. O operador bit a bit ~n==-n-1reduz o denominador e economiza em parênteses.

O Python 3 é usado para sua divisão de flutuação. Python 2 poderia fazer o mesmo com mais um byte para escrever 6..

xnor
fonte
Por que não, n<1e não 0**n?
feersum
@feersum Retorna Truepara em n==0vez de 1. Claro, True == 1mas True is not 1e imprime de forma diferente. Eu esperaria que isso não fosse permitido. Você sabe se temos uma decisão sobre isso?
Xnor
Eu acredito que está tudo bem. isinstance(True, int) is Truedepois de tudo.
precisa saber é
2
Eu acho que ainda é duvidoso no caso geral e mais aqui, onde o desafio especifica a saída como um número ou sua representação. Mas, até @quartata
xnor
7

J, 8 bytes

>:%~]!+:

Este é um trem monádico; ele usa a fórmula (2x nCr x) / (x + 1). Experimente aqui .

lirtosiast
fonte
7

pl, 4 bytes

☼ç▲÷

Experimente online.

Explicação

Em pl, as funções retiram seus argumentos da pilha e enviam o resultado de volta para a pilha. Normalmente, quando não há argumentos suficientes na pilha, a função simplesmente falha silenciosamente. No entanto, algo especial acontece quando a quantidade de argumentos na pilha é diferente da área da função - a variável de entrada _é adicionada à lista de argumentos:

☼ç▲÷

☼      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

Com efeito, este é o pseudocódigo:

divide(combinations(double(_),_),_+1);
um spaghetto
fonte
6

Sesos , 94 86 68 bytes

8 bytes, alterando o fatorial-er da versão 1 para a versão 2.

18 bytes computando n!(n+1)!em uma etapa. Em grande parte inspirado pelo algoritmo de teste de primalidade de 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.>..

Experimente online!

Usa a fórmula a(n) = (2n)! / (n!(n+1)!).

  • O fatorador-er: versão 1 (in-loco, memória constante), versão 2 (in-loco, memória linear)
  • O multiplicador: aqui (no lugar, memória constante)
  • O divisor: aqui (não para se não for divisível)

Montador

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 a Brainfuck

Esse script da Retina é usado para gerar o equivalente do cérebro. Observe que ele aceita apenas um dígito como argumento de comando e não verifica se um comando está nos comentários.

[->+>>++<<<]>+
[[-<+<+<+>>>]<-<-<[->>>+<<<]>]>>>
[[-<[-<+<+>>]<<[->>+<<]>>>]<[-]<[->>+<<]>>>]>
[[->+>+<<]>->[-<<+>>]<]<<
[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>
[>+<<<[->+>-<<]>[-<+>]>]>
Freira Furada
fonte
5

Pitão, 8

/.cyQQhQ

Experimente online ou execute o Test Suite

Explicação

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

Sério, 9 bytes

,;;u)τ╣E\

Hex Dump:

2c3b3b7529e7b9455c

Experimente online

Explicação:

,                   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.
quintopia
fonte
Você pode salvar um byte explorando o fato de que as linhas do triângulo de Pascal são simétricas, portanto a mediana da 2nlinha th é C(2n,n). Assim: ,;u@τ╣║/por 8 bytes.
Mego
O que? 2nCn não é o máximo da 2ª linha?
quintopia
Sim, e também é a mediana. Então, ambos e Miria funcionar.
Mego
@Mego Preocupo-me com a sua implementação da mediana se algo puder ser tanto a mediana quanto a máxima no caso em que a lista não seja o mesmo número. Se você quer dizer "no meio da lista", pode escolher um nome diferente para ele ...
quintopia
Sim, é o meio da lista. Para listas ordenadas, é a mediana estatística típica, mas para listas indiferenciados é apenas no meio (ou média de 2 elementos do meio)
Mego
4

JavaScript (ES6), 24 bytes

Baseado na resposta do Python .

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

Como funciona

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.

Acho que é o mais curto possível, mas sugestões são bem-vindas!

ETHproductions
fonte
4

Julia, 23 bytes

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

Esta é uma função anônima que aceita um número inteiro e retorna um número flutuante. Ele usa a fórmula binomial básica. Para chamá-lo, dê um nome, por exemplo f=n->....

Alex A.
fonte
4

Matlab, 35 25 bytes

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

Oitava, 23 bytes

@(n)nchoosek(2*n,n++)/n
costrom
fonte
2
Você pode usar em @(n)vez da função, funções anônimas estão ok.
FryAmTheEggman
Eu já vi várias respostas aqui antes que tinham variáveis ​​do espaço de trabalho sendo acessadas (o que implica que elas já foram definidas pelo usuário em outro lugar). Os scripts no MATLAB / Octave também podem aparecer como trechos simples. Eu re-transformá-lo em uma função por enquanto ...
costrom
1
Você pode eliminar mais 2 bytes pós-incrementando n:@(n)nchoosek(2*n,n++)/n
beaker
@beaker obrigado pela dica! ele só funciona em Octave, porém, não Matlab, então eu dividido já o diferencia
costrom
@ costrom Isso é interessante. Eu acho que .../++ntambém não funciona. : /
beaker
4

, 3 caracteres / 6 bytes

Мƅï

Try it here (Firefox only).

Builtins ftw! Estou tão feliz por ter implementado o math.js desde o início.

Solução de bônus, 12 caracteres / 19 bytes

Мơ 2*ï,ï)/⧺ï

Try it here (Firefox only).

Ay! 19 byte!

Avalia como pseudo-ES6 como:

nchoosek(2*input,input)/(input+1)
Mama Fun Roll
fonte
3

Haskell, 27 bytes

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

Uma fórmula recursiva. Tem que haver uma maneira de economizar em parênteses ...

Tomar o produto diretamente era 2 bytes mais longo:

g n=product[4-6/i|i<-[2..n+1]]
xnor
fonte
Onde seu código lê de stdin ou grava em stdout?
usar o seguinte comando
2
@ user2845840 As funções são uma das alternativas aceitáveis vinculadas na especificação.
Xnor
g(n-1)=> g$n-1salva um byte. Edit: na verdade, isso não funciona, porque a fórmula é interpretada como (...*g) (n-1).
Reintegrar Monica
3

Dyalog APL, 9 bytes

+∘1÷⍨⊢!+⍨

Este é um trem monádico; ele usa a fórmula (2x nCr x) / (x + 1). Experimente online aqui .

lirtosiast
fonte
3

C, 122 121 119 108 bytes

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

Eu usei o gcc (GCC) 3.4.4 (cygming special, gdc 0.12, usando dmd 0.125) para compilar em um ambiente windows cygwin. A entrada entra na linha de comando. É semelhante à solução Python do Sherlock9, mas os loops são combinados em um para evitar transbordamentos e obter saída até o 20º número catalão (n = 19).

cleblanc
fonte
1
Você pode remover o espaço após a vírgula na maindefinição para salvar um byte.
Alex A.
Bom, eu vou editar o post agora #
cleblanc
Você pode salvar mais 2 bytes em char**vvez de char *v[]. (O espaço anterior *não é necessário, e os tipos são equivalentes.) #
Mat
Com certeza, isso funciona muito bem. Obrigado Mat
cleblanc
Isso usa algumas coisas da página de dicas para reduzi-lo. Observe que, para Ideone, codifiquei um valor para n.
FryAmTheEggman
3

Javagony , 223 bytes

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

Totalmente expandido:

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);
    }
}
flawr
fonte
A inscrição no Esolangs não importa - desde que você use um intérprete feito antes do concurso, tudo é bom e válido.
Addison Crump
Não vai ganhar de qualquer maneira ^^ #
flawr
É java, então sim.
Rɪᴋᴇʀ
1
@Riker Bem, é pior que Java.
Jakob
2

Japonês, 16 bytes

Até o Mathematica é mais curto. :-/

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

Experimente online!

Ungolfed e explicação

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

Versão alternativa, com base na fórmula recursiva:

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

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.

Esta é uma função no Vitsy . Como torná-lo um programa que faz isso, você pergunta? Concatenar N. c:

Experimente online!

Addison Crump
fonte
2

Via Láctea 1.5.14 , 14 bytes

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

Explicação

'               # 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

ou, alternativamente, a versão muito mais eficiente:


Via Láctea 1.5.14 , 22 bytes

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

Explicação

'                      # 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

Uso

python3 milkyway.py <path-to-code> -i <input-integer>
Zach Gates
fonte
2

Clojure / ClojureScript, 53 bytes

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

Clojure pode ser bastante frustrante para jogar golfe. É muito conciso e ainda é muito legível, mas alguns dos recursos mais interessantes são realmente detalhados. (inc x)é mais idiomático do que (+ x 1)"parece" mais conciso, mas na verdade não salva os caracteres. E escrever cadeias de operações é mais agradável (->> x inc (/ 6) (- 4)), mas na verdade é mais longo do que apenas fazê-lo da maneira feia.

MattPutnam
fonte
2

Prolog, 42 bytes

Usar a recursão é quase sempre o caminho a seguir com o Prolog.

Código:

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

Exemplo:

19*X.
X = 1767263190.0

Experimente online aqui

Emigna
fonte
Você está redefinindo o *símbolo aqui?
Paŭlo Ebermann
@ PaŭloEbermann não exatamente. Estou definindo um novo predicado diádico chamado *. Ainda posso usar a aritmética regular. No programa acima, M * Y é o meu predicado definido, enquanto (4-6 / (N + 1)) * Y é a multiplicação regular.
Emigna
É um pouco mais curto do que escrevê-lo como p (X, Y): - o que é bom para o código de golfe.
Emigna
2

Oitava, 22 bytes

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

Ceilão, 60 bytes

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

Isso funciona até C 30 , já que os números inteiros do Ceilão são assinados com números de 64 bits (C 31 está excedente, será calculado como -4050872099593203).

Não sei se o Ceilão tem funções matemáticas superiores, mas importar o pacote certo provavelmente seria mais longo do que apenas calcular isso a pé.

// 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);
Paŭlo Ebermann
fonte
2

R, 35 28 16 bytes

numbers::catalan

Edit: Use o pacote de números embutido.

mnel
fonte
2

MATL , 8 bytes

2*GXnGQ/

Experimente online!

Explicação

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
Luis Mendo
fonte
2

05AB1E , 6 bytes

Dxcr>/

Explicação:

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
Adnan
fonte
2

R, 28 bytes

Não está usando um pacote, então um pouco mais do que uma resposta anterior

choose(2*(n=scan()),n)/(n+1)
Frédéric
fonte