Каталонские номера

36

В число Каталонский ( OEIS ) представляют собой последовательность натуральных чисел часто появляются в комбинаторике.

N-е каталонское число - это число слов Дика (сбалансированные строки в скобках или скобки, такие как [[][]]; формально определяется как строка, использующая два символа a и b, так что любая подстрока, начинающаяся с начала, имеет число символов, большее или равное числу из символов b, и вся строка имеет одинаковое количество символов a и b) длиной 2n. N-е каталонское число (для n> = 0) также явно определяется как:

Начиная с n = 0, первые 20 каталонских номеров:

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

Вызов

Напишите полную программу или функцию, которая принимает неотрицательное целое число n через STDIN или приемлемую альтернативу и выводит n-е каталонское число. Ваша программа должна работать как минимум для входов 0-19.

I / O

вход

Ваша программа должна получать данные из STDIN, аргументы функций или любые приемлемые альтернативы для этого мета-поста. Вы можете прочитать введенное число как его стандартное десятичное представление, унарное представление или байты.

  • Если (и только если) ваш язык не может получить ввод из STDIN или любой приемлемой альтернативы, он может получить ввод из жестко закодированной переменной или подходящего эквивалента в программе.

Выход

Ваша программа должна вывести n-е каталонское число в STDOUT, результат функции или любую из приемлемых альтернатив для этого мета-поста. Вы можете вывести каталонское число в его стандартном десятичном представлении, унарном представлении или байтах.

Вывод должен состоять из оценочного каталонского номера, за которым, возможно, следует одна или несколько строк новой строки. Никакие другие выходные данные не могут быть сгенерированы, кроме постоянного вывода интерпретатора вашего языка, который не может быть подавлен (например, приветствие, цветовые коды ANSI или отступ).


Это не о том, чтобы найти самый короткий язык. Это о поиске самой короткой программы на каждом языке. Поэтому я не приму ответ.

В этой задаче языки, более новые, чем проблема, являются приемлемыми, если они имеют реализацию. Разрешается (и даже поощряется) самостоятельно писать этот переводчик для ранее не реализованного языка. Кроме этого, все стандартные правила должны соблюдаться. Материалы на большинстве языков будут оцениваться в байтах в соответствующей существующей кодировке (обычно UTF-8). Также обратите внимание, что встроенные модули для вычисления n-го каталонского числа допускаются.

Каталог

Фрагмент стека в нижней части этого поста создает каталог из ответов а) в виде списка кратчайшего решения для каждого языка и б) в качестве общей таблицы лидеров.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

## Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш результат равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

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

Вы также можете сделать имя языка ссылкой, которая будет отображаться во фрагменте кода:

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

спагетто
источник
Можем ли мы напечатать / вернуть число с плавающей точкой, а не целое число?
Алекс А.
@AlexA. Это приемлемо
спагетто
Должен ли быть тег oeis ?
Ви.
1
@Vi. Был мета разговор о том , что некоторое время назад , и мы договорились , что OEIS было ненужным
в spaghetto
@Vi. Вот мета пост: meta.codegolf.stackexchange.com/a/5546/8478 . Что касается некоторых рассуждений, вы можете найти задачи в стиле OEIS довольно надежно с помощью последовательности и одной из теории чисел или чисел . Является ли данная последовательность действительно находится в OEIS, совершенно не имеет отношения к проблеме.
Мартин Эндер

Ответы:

26

C 78 52 39 34 33 байта

Еще больше магии C (спасибо xsot):

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

?: это расширение GNU .


На этот раз, расширив повторяемость ниже (спасибо xnor и Thomas Kwa):

еще одна рекурсия

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

-(n+1)заменяется на ~n, что эквивалентно дополнению до двух и сохраняет 4 байта.


Опять как функция, но на этот раз эксплуатируем следующее повторение:

RECUR

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

c(n)вводит бесконечную рекурсию для негатива n, хотя это не актуально для этой задачи.


Поскольку вызов функции кажется приемлемой альтернативой консольному вводу / выводу:

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

c(n)принимает intи возвращает int.


Оригинальная запись:

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

Вместо непосредственного вычисления определения формула переписывается следующим образом:

переписать

Формула предполагает n >= 2, но код учитываетn = 0 и n = 1тоже.

В C беспорядок выше, nи kиграют ту же роль, что и в формуле, в то время какc как продукт накапливается. Все вычисления выполняются с использованием плавающей запятой double, что почти всегда является плохой идеей, но в этом случае результаты верны, по крайней мере, до n = 19, так что все в порядке.

float сохранил бы 1 байт, к сожалению, он недостаточно точен.

Стефано Санфилиппо
источник
Я не могу проверить это сейчас, но я думаю, что вы можете сократить его дальше:c(n){return!n?:(4+6./~n)*c(n-1);}
xsot
Спасибо @xsot, я не знал ?:! По-видимому, это расширение GNU C, но я думаю, что оно по-прежнему подходит.
Стефано Санфилиппо
23

Желе , 4 байта

Ḥc÷‘

Попробуйте онлайн!

Как это работает

Ḥc÷‘    Left argument: z

Ḥ       Compute 2z.
 c      Hook; apply combinations to 2z and z.
  ÷‘    Divide the result by z+1.
Деннис
источник
1
Что значит «зацепить»? Как cполучить 2zи zкак аргументы?
xnor
@xnor Хук означает функции, вычисленные как f (x, g (x)). Когда есть двоичная функция, за которой следует другая двоичная функция, анализатор оценивает первую как ловушку.
lirtosiast
5
@ Деннис Это действительно 4 байта? С этими не-ASCII символами mothereff.in/byte-counter говорит 9 байтов
Луис Мендо
@LuisMendo это, вероятно, другая кодировка
подземный
3
@LuisMendo Jelly использует свое собственное кодирование по умолчанию, где каждый символ представляет собой один байт. В UTF-8 исходный код действительно имеет длину 9 байтов.
Деннис
11

CJam, 12 байт

ri_2,*e!,\)/

Попробуйте онлайн.

Помимо ввода 11, вам нужно указать виртуальной машине Java использовать больше памяти. И я бы не советовал идти намного дальше 11. Хотя теоретически это работает для любого N, так как CJam использует целые числа произвольной точности.

объяснение

CJam не имеет встроенных биномиальных коэффициентов, и вычисление их из трех факториалов занимает много байтов ... поэтому нам придется сделать что-то лучше, чем это. :)

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.
Мартин Эндер
источник
Это действительно круто. +1
спагетто
Это умно. Я попробовал это с вычислением факториалов. Это займет всего два из трех обычных, так как два из них одинаковы. Он все еще использовал 17 байт ( ri_2*m!1$m!_*/\)/) в моей реализации. Единственная хорошая вещь - это намного быстрее. :)
Рето Коради
11

Mathematica, 16 13 байт

CatalanNumber

Встроенные модули, амириты: /

Не встроенная версия (21 байт):

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

Биноминальная версия (25 байт):

Product[(#+k)/k,{k,2,#}]&
спагетто
источник
10

TI-BASIC, 11 байтов

(2Ans) nCr Ans/(Ans+1

Как ни странно, nCr имеет более высокий приоритет, чем умножение.

lirtosiast
источник
10

Python 3, 33 байта

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

Использует повторение

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

Базовый случай 0 обрабатывается как 0**n or, который останавливается, 1когдаn==0 и в противном случае вычисляет рекурсивное выражение справа. Побитовый оператор~n==-n-1 сокращает знаменатель и экономит на паренсе.

Python 3 используется для его деления поплавка. Python 2 может сделать то же самое с еще одним байтом для записи 6..

XNOR
источник
Почему не n<1вместо 0**n?
feersum
@feersum Он возвращается Trueк , n==0а не 1. Конечно, True == 1но True is not 1и это печатает по-разному. Я ожидаю, что это не будет разрешено. Вы знаете, есть ли у нас решение по этому поводу?
xnor
Я считаю, что это хорошо. isinstance(True, int) is Trueв конце концов.
feersum
2
Я думаю, что это все еще сомнительно в общем случае и тем более здесь, где задача определяет выход в виде числа или его представления. Но до @quartata
xnor
7

J, 8 байт

>:%~]!+:

Это монадический поезд; он использует формулу (2x nCr x) / (x + 1). Попробуй это здесь .

lirtosiast
источник
7

pl, 4 байта

☼ç▲÷

Попробуйте онлайн.

объяснение

В pl функции извлекают свои аргументы из стека и возвращают результат обратно в стек. Обычно, когда в стеке недостаточно аргументов, функция просто молча завершается сбоем. Однако, что-то особенное происходит, когда количество аргументов в стеке равно единице функции - входная переменная _добавляется в список аргументов:

☼ç▲÷

☼      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

По сути, это псевдокод:

divide(combinations(double(_),_),_+1);
спагетто
источник
6

Сесос , 94 86 68 байт

8 байтов путем изменения факториала с версии 1 на версию 2.

18 байтов путем вычисления n!(n+1)!за один шаг. Во многом вдохновлен алгоритмом теста Денниса .

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

Попробуйте онлайн!

Использует формулу a(n) = (2n)! / (n!(n+1)!).

  • Факториал-эр: версия 1 (на месте, постоянная память), версия 2 (на месте, линейная память)
  • Множитель: здесь (на месте, постоянная память)
  • Разделитель: здесь (не останавливается, если не делится)

ассемблер

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

Brainfuck эквивалент

Этот скрипт Retina используется для генерации эквивалента брейкфука. Обратите внимание, что он принимает только одну цифру в качестве аргумента команды и не проверяет, есть ли команда в комментариях.

[->+>>++<<<]>+
[[-<+<+<+>>>]<-<-<[->>>+<<<]>]>>>
[[-<[-<+<+>>]<<[->>+<<]>>>]<[-]<[->>+<<]>>>]>
[[->+>+<<]>->[-<<+>>]<]<<
[[->[->+>+<<]>>[-<<+>>]<<<]>[-]>[-<<+>>]<<<]>
[>+<<<[->+>-<<]>[-<+>]>]>
Дрянная Монахиня
источник
5

Серьезно, 9 байт

,;;u)τ╣E\

Шестнадцатеричный дамп:

2c3b3b7529e7b9455c

Попробуйте онлайн

Объяснение:

,                   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
источник
Вы можете сохранить байт, используя тот факт, что строки треугольника Паскаля симметричны, так что медиана этой 2nстроки равна C(2n,n). Таким образом: ,;u@τ╣║/для 8 байтов.
Mego
Какая? Разве 2nCn не является максимумом 2-го ряда?
Quintopia
Да, и это также медиана. Так что, так и Mбудет работать.
Mego
@Mego Я беспокоюсь о вашей реализации медианы, если что-то может быть как медианой, так и макс., Если список не совпадает. Если вы имеете в виду «в середине списка», то вы можете выбрать другое имя для него ...
quintopia
Да, это середина списка. Для отсортированных списков это типичная статистическая медиана, но для несортированных списков это просто середина (или среднее из 2 средних элементов)
Mego
4

JavaScript (ES6), 24 байта

Основано на ответе Python .

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

Как это работает

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.

Я думаю, что это самое короткое, что можно получить, но предложения приветствуются!

ETHproductions
источник
4

Юлия, 23 байта

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

Это анонимная функция, которая принимает целое число и возвращает число с плавающей точкой. Используется основная формула бинома. Чтобы назвать его, дайте ему имя, например f=n->....

Алекс А.
источник
4

Matlab, 35 25 байт

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

Октава, 23 байта

@(n)nchoosek(2*n,n++)/n
costrom
источник
2
Вы можете использовать @(n)вместо функции, анонимные функции в порядке.
FryAmTheEggman
Я видел несколько ответов здесь до этого, к которым имели доступ переменные рабочей области (подразумевая, что они уже были установлены пользователем в другом месте). Скрипты в MATLAB / Octave также могут отображаться как простые фрагменты. Я превратил это в функцию на данный момент ...
Costrom
1
Вы можете отбросить еще 2 байта, увеличивая n:@(n)nchoosek(2*n,n++)/n
мензурка
@ Beaker спасибо за совет! он работает только в Octave, но не в Matlab, поэтому я разделил его
costrom
@costrom Это интересно. Я думаю, .../++nтоже не работает. : /
стакан
4

𝔼𝕊𝕄𝕚𝕟, 3 символа / 6 байтов

Мƅï

Try it here (Firefox only).

Встроенные ftw! Так рада, что я внедрила math.js на ранней стадии.

Бонусное решение, 12 символов / 19 байт

Мơ 2*ï,ï)/⧺ï

Try it here (Firefox only).

Ау! 19-й байт!

Оценивает псевдо-ES6 как:

nchoosek(2*input,input)/(input+1)
Mama Fun Roll
источник
3

Haskell, 27 байт

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

Рекурсивная формула. Должен быть способ сэкономить на паренсе ...

Непосредственно взятие продукта было на 2 байта длиннее:

g n=product[4-6/i|i<-[2..n+1]]
XNOR
источник
Где ваш код читает со стандартного ввода или пишет в стандартный вывод?
user2845840
2
@ user2845840 Функции являются одной из приемлемых альтернатив, указанных в спецификации.
xnor
g(n-1)=> g$n-1сохраняет один байт. Изменить: на самом деле это не работает, потому что тогда формула интерпретируется как (...*g) (n-1).
Восстановите Монику
3

Дьялог АПЛ, 9 байт

+∘1÷⍨⊢!+⍨

Это монадический поезд; он использует формулу (2x nCr x) / (x + 1). Попробуйте это онлайн здесь .

lirtosiast
источник
3

C 122 121 119 108 байт

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

Я использовал gcc (GCC) 3.4.4 (специальный cygming, gdc 0.12, используя dmd 0.125) для компиляции в среде windows cygwin. Ввод поступает в командной строке. Это похоже на решение Sherlock9 Python, но циклы объединены в один, чтобы избежать переполнения и получить результат до 20-го каталонского числа (n = 19).

cleblanc
источник
1
Вы можете удалить пробел после запятой в mainопределении, чтобы сохранить байт.
Алекс А.
Хорошо, я сейчас отредактирую пост
cleblanc
Вы можете сохранить больше 2 байта с char**vчем char *v[]. (Пробел перед *не нужен, а типы эквивалентны.)
Мат
Конечно же, это прекрасно работает. Спасибо Мат
Клеблан
Это использует некоторые вещи со страницы советов, чтобы сократить его. Обратите внимание, что для Ideone я жестко закодировал значение для n.
FryAmTheEggman
3

Javagony , 223 байта

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

Полностью расширен:

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
источник
Запись Esolangs не имеет значения - если вы используете переводчика, сделанного перед конкурсом, все это хорошо и правильно.
Эддисон Крамп
В любом случае не выиграю ^^
flawr
Это Java, так что да.
Rɪᴋᴇʀ
1
@Riker Ну, это хуже, чем Java.
Якоб
2

Japt, 16 байт

Даже Mathematica короче. :-/

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

Попробуйте онлайн!

Неуправляемый и объяснение

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

Альтернативная версия, основанная на рекурсивной формуле:

C=_?(4+6/~Z *C$(Z-1):1};$C(U
ETHproductions
источник
2

Витси , 13 байт

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.

Это функция в Vitsy . Вы спрашиваете, как сделать это программой, которая делает это? Объединить N. с:

Попробуйте онлайн!

Аддисон Крамп
источник
2

Млечный Путь 1.5.14 , 14 байт

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

объяснение

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

или, альтернативно, гораздо более эффективная версия:


Млечный Путь 1.5.14 , 22 байта

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

объяснение

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

использование

python3 milkyway.py <path-to-code> -i <input-integer>
Зак Гейтс
источник
2

Clojure / ClojureScript, 53 байта

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

Clojure может быть довольно неприятным для игры в гольф. Он очень содержательный, но в то же время очень удобочитаемый, но некоторые отличные черты действительно многословны. (inc x)более идиоматичен, чем (+ x 1)и «кажется» более лаконичным, но на самом деле не сохраняет символы. И написание цепочек операций приятнее (->> x inc (/ 6) (- 4)), но на самом деле это дольше, чем просто делать это безобразно.

MattPutnam
источник
2

Пролог, 42 байта

Использование рекурсии - это почти всегда путь к Прологу.

Код:

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

Пример:

19*X.
X = 1767263190.0

Попробуйте онлайн здесь

Emigna
источник
Вы переопределяете *символ здесь?
Paŭlo Ebermann
@ PaŭloEbermann не совсем так. Я определяю новый диадический предикат под названием *. Я все еще могу использовать обычную арифметическую. В приведенной выше программе M * Y - мой определенный предикат, а (4-6 / (N + 1)) * Y - регулярное умножение.
Emigna
Это немного короче, чем записать это как p (X, Y): - что хорошо для гольф-кода.
Emigna
2

Октава, 22 байта

@(n)prod(4-6./(2:n+1))
alephalpha
источник
2

Цейлон, 60 байт

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

Это работает до C 30 , поскольку целые числа Цейлона имеют 64-битные числа со знаком ( переполнение C 31 , будет рассчитано как -4050872099593203).

Я не знаю, есть ли у Цейлона какие-либо встроенные более высокие математические функции, но тогда импорт правильного пакета, вероятно, займет больше времени, чем просто вычисление этого пешком.

// 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);
Пауло Эберманн
источник
2

R, 35 28 16 байт

numbers::catalan

Изменить: использовать встроенный пакет чисел.

mnel
источник
2

05AB1E , 6 байтов

Dxcr>/

Объяснение:

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
Аднан
источник
2

R, 28 байт

Не используя пакет, поэтому немного дольше, чем предыдущий ответ

choose(2*(n=scan()),n)/(n+1)
Фредерик
источник