Rosetta Code

Catalan numbers/Pascal's triangle: Difference between revisions

Page Discussion

Catalan numbers/Pascal's triangle (view source)

Revision as of 19:12, 26 August 2022

2,277 bytes added ,  1 year ago
m
syntax highlighting fixup automation
(→‎{{header|F#}}: Corrected header as suggested on the Count examples/Full list/Tier 4 talk page)
m (syntax highlighting fixup automation)
Line 17:
=={{header|11l}}==
{{trans|Python}}
<langsyntaxhighlight lang=11l>V n = 15
V t = [0] * (n + 2)
t[1] = 1
Line 26:
L(j) (i + 1 .< 1).step(-1)
t[j] += t[j - 1]
print(t[i + 1] - t[i], end' ‘ ’)</langsyntaxhighlight>
{{out}}
<pre>
Line 34:
=={{header|360 Assembly}}==
For maximum compatibility, this program uses only the basic instruction set.
<langsyntaxhighlight lang=360asm>CATALAN CSECT
USING CATALAN,R13,R12
SAVEAREA B STM-SAVEAREA(R15)
Line 124:
WTOBUF DC CL80' '
YREGS
END</langsyntaxhighlight>
{{out}}
<pre style="height:20ex">00000001
Line 144:
=={{header|Action!}}==
{{libheader|Action! Tool Kit}}
<langsyntaxhighlight lang=Action!>INCLUDE "D2:REAL.ACT" ;from the Action! Tool Ki
 
DEFINE PTR="CARD"
Line 191:
PrintF("C(%B)=",i) PrintRE(c)
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Catalan_numbers_Pascal's_triangle.png Screenshot from Atari 8-bit computer]
Line 216:
Uses package Pascal from the Pascal triangle solution[[http://rosettacode.org/wiki/Pascal%27s_triangle#Ada]]
 
<langsyntaxhighlight lang=Ada>with Ada.Text_IO, Pascal;
 
procedure Catalan is
Line 229:
Ada.Text_IO.Put(Integer'Image(Row(I+1)-Row(I+2)));
end loop;
end Catalan;</langsyntaxhighlight>
 
{{out}}
Line 237:
=={{header|ALGOL 68}}==
{{trans|C++}}
<langsyntaxhighlight lang=algol68>INT n = 15;
[ 0 : n + 1 ]INT t;
t[0] := 0;
Line 246:
FOR j FROM i+1 BY -1 TO 2 DO t[j] := t[j] + t[j-1] OD;
print( ( whole( t[i+1] - t[i], 0 ), " " ) )
OD</langsyntaxhighlight>
{{out}}
<pre>
Line 253:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang=algolw>begin
% print the first 15 Catalan numbers from Pascal's triangle %
integer n;
Line 272:
end for_c
end
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 279:
 
=={{header|APL}}==
<langsyntaxhighlight lang=apl>
⍝ Based heavily on the J solution
CATALAN←{¯1↓↑-/1 ¯1↓¨(⊂⎕IO+0 0)⍉¨0 2⌽¨⊂(⎕IO-⍨⍳N){+\⍣⍺⊢⍵}⍤0 1⊢1⍴⍨N←⍵+2}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 291:
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
<langsyntaxhighlight lang=AutoHotkey>/* Generate Catalan Numbers
//
// smgs: 20th Feb, 2014
Line 320:
}
}
MsgBox % result</langsyntaxhighlight>
{{out|Produces}}
<pre>
Line 327:
 
=={{header|AWK}}==
<langsyntaxhighlight lang=AWK>
# syntax: GAWK -f CATALAN_NUMBERS_PASCALS_TRIANGLE.AWK
# converted from C
Line 344:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 351:
 
=={{header|Batch File}}==
<langsyntaxhighlight lang=dos>@echo off
setlocal ENABLEDELAYEDEXPANSION
set n=15
Line 372:
)
)
pause</langsyntaxhighlight>
{{Out}}
<pre style="height:20ex">1
Line 391:
 
=={{header|C}}==
<syntaxhighlight lang=c>
<lang c>
//This code implements the print of 15 first Catalan's Numbers
//Formula used:
Line 437:
return 0;
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 446:
=={{header|C sharp|C#}}==
{{trans|C++}}
<langsyntaxhighlight lang=csharp>
int n = 15;
List<int> t = new List<int>() { 0, 1 };
Line 456:
Console.Write(((i == 1) ? "" : ", ") + (t[i + 1] - t[i]));
}
</syntaxhighlight>
</lang>
{{out|Produces}}
<pre>
Line 463:
 
=={{header|C++}}==
<langsyntaxhighlight lang=cpp>// Generate Catalan Numbers
//
// Nigel Galloway: June 9th., 2012
Line 478:
}
return 0;
}</langsyntaxhighlight>
{{out|Produces}}
<pre>
Line 486:
=={{header|Common Lisp}}==
 
<langsyntaxhighlight lang=Lisp>(defun catalan (n)
"Return the n-th Catalan number"
(if (<= n 1) 1
Line 495:
 
(dotimes (n 15)
(print (catalan (1+ n))) )</langsyntaxhighlight>
 
{{out}}
Line 517:
=={{header|D}}==
{{trans|C++}}
<langsyntaxhighlight lang=d>void main() {
import std.stdio;
 
Line 532:
write(t[i + 1] - t[i], ' ');
}
}</langsyntaxhighlight>
{{out}}
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 </pre>
Line 538:
See [https://rosettacode.org/wiki/Catalan_numbers/Pascal%27s_triangle#Pascal Pascal].
=={{header|EchoLisp}}==
<langsyntaxhighlight lang=scheme>
(define dim 100)
(define-syntax-rule (Tidx i j) (+ i (* dim j)))
Line 554:
(remember 'T #(1))
</syntaxhighlight>
</lang>
{{out}}
<langsyntaxhighlight lang=scheme>
;; take elements on diagonal = Catalan numbers
(for ((i (in-range 0 16))) (write (T (Tidx i i))))
 
→ 1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845
</syntaxhighlight>
</lang>
 
=={{header|EDSAC order code}}==
Rather than store a triangular array, this solution stores the right-hand half of the current row and updates it in place. It uses the third method in the link, e.g. once we have the half row (70, 56, 28, 8, 1), the Catalan number 42 appears as 70 - 28.
<langsyntaxhighlight lang=edsac>
[Catalan numbers from Pascal triangle, Rosetta Code website.
EDSAC program, Initial Orders 2]
Line 625:
[75] O4@ ZF [flush printer buffer; stop]
E9Z PF [define entry point; enter with acc = 0]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 646:
 
=={{header|Elixir}}==
<langsyntaxhighlight lang=elixir>defmodule Catalan do
def numbers(num) do
{result,_} = Enum.reduce(1..num, {[],{0,1}}, fn i,{list,t0} ->
Line 660:
end
 
IO.inspect Catalan.numbers(15)</langsyntaxhighlight>
 
{{out}}
Line 668:
 
=={{header|Erlang}}==
<langsyntaxhighlight lang=erlang>
-module(catalin).
-compile(export_all).
Line 686:
main()->
Ans=catl(1,2).
</syntaxhighlight>
</lang>
 
=={{header|ERRE}}==
<langsyntaxhighlight lang=ERRE>
PROGRAM CATALAN
 
Line 728:
END FOR
END PROGRAM
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 749:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang=fsharp>
let mutable nm=uint64(1)
let mutable dm=uint64(1)
Line 765:
if(i<>15) then
printf ", "
</syntaxhighlight>
</lang>
 
=={{header|Factor}}==
<langsyntaxhighlight lang=factor>USING: arrays grouping io kernel math prettyprint sequences ;
IN: rosetta-code.catalan-pascal
 
Line 781:
[ dup midpoint@ dup 1 + 2array swap nths first2 - ] if
pprint bl
] each drop</langsyntaxhighlight>
{{out}}
<pre>
Line 788:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang=freebasic>' version 15-09-2015
' compile with: fbc -s console
 
Line 843:
Print : Print "hit any key to end program"
Sleep
End</langsyntaxhighlight>
{{out}}
<pre>The first 15 Catalan numbers are
Line 865:
=={{header|Go}}==
{{trans|C++}}
<langsyntaxhighlight lang=go>package main
 
import "fmt"
Line 882:
fmt.Printf("%2d : %d\n", i, t[i+1]-t[i])
}
}</langsyntaxhighlight>
 
{{out}}
Line 905:
=={{header|Groovy}}==
{{trans|C}}
<langsyntaxhighlight lang=Groovy>
class Catalan
{
Line 929:
}
}
​</langsyntaxhighlight>
{{out}}
<pre>
Line 938:
As required by the task this implementation extracts the Catalan numbers from Pascal's triangle, rather
than calculating them directly. Also, note that it (correctly) produces [1, 1] as the first two numbers.
<langsyntaxhighlight lang=haskell>import System.Environment (getArgs)
 
-- Pascal's triangle.
Line 956:
main = do
ns <- fmap (map read) getArgs :: IO [Int]
mapM_ (print . flip take catalan) ns</langsyntaxhighlight>
 
{{out}}
Line 969:
that aren't used.
 
<langsyntaxhighlight lang=unicon>link math
 
procedure main(A)
limit := (integer(A[1])|15)+1
every write(right(binocoef(i := 2*seq(0)\limit,i/2)-binocoef(i,i/2+1),30))
end</langsyntaxhighlight>
 
Sample run:
Line 999:
=={{header|J}}==
 
<langsyntaxhighlight lang=j> Catalan=. }:@:(}.@:((<0 1)&|:) - }:@:((<0 1)&|:@:(2&|.)))@:(i. +/\@]^:[ #&1)@:(2&+)</langsyntaxhighlight>
{{out|Example use}}
<langsyntaxhighlight lang=j> Catalan 15
1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845
</langsyntaxhighlight>
 
A structured derivation of Catalan follows:
 
<langsyntaxhighlight lang=j> o=. @: NB. Composition of verbs (functions)
( PascalTriangle=. i. ((+/\@]^:[)) #&1 ) 5
1 1 1 1 1
Line 1,023:
Catalan
}:@:(}.@:((<0 1)&|:) - }:@:((<0 1)&|:@:(2&|.)))@:(i. +/\@]^:[ #&1)@:(2&+)</langsyntaxhighlight>
 
=={{header|Java}}==
{{trans|C++}}
<langsyntaxhighlight lang=java>public class Test {
public static void main(String[] args) {
int N = 15;
Line 1,046:
}
}
}</langsyntaxhighlight>
 
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845</pre>
Line 1,054:
Iteration
{{trans|C++}}
<langsyntaxhighlight lang=javascript>var n = 15;
for (var t = [0, 1], i = 1; i <= n; i++) {
for (var j = i; j > 1; j--) t[j] += t[j - 1];
Line 1,060:
for (var j = i + 1; j > 1; j--) t[j] += t[j - 1];
document.write(i == 1 ? '' : ', ', t[i + 1] - t[i]);
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,070:
{{Trans|Haskell}}
 
<langsyntaxhighlight lang=JavaScript>(() => {
'use strict';
 
Line 1,133:
 
return tail(catalanSeries(16));
})();</langsyntaxhighlight>
 
{{Out}}
<langsyntaxhighlight lang=JavaScript>[1,2,5,14,42,132,429,1430,4862,16796,58786,208012,742900,2674440,9694845]</langsyntaxhighlight>
 
=={{header|jq}}==
Line 1,143:
''Warning'': jq uses IEEE 754 64-bit arithmetic,
so the algorithm used here for Catalan numbers loses precision for n > 30 and fails completely for n > 510.
<langsyntaxhighlight lang=jq>def binomial(n; k):
if k > n / 2 then binomial(n; n-k)
else reduce range(1; k+1) as $i (1; . * (n - $i + 1) / $i)
Line 1,149:
 
# Direct (naive) computation using two numbers in Pascal's triangle:
def catalan_by_pascal: . as $n | binomial(2*$n; $n) - binomial(2*$n; $n-1);</langsyntaxhighlight>
 
'''Example''':
(range(0;16), 30, 31, 510, 511) | [., catalan_by_pascal]
{{Out}}
<langsyntaxhighlight lang=sh>$ jq -n -c -f Catalan_numbers_Pascal.jq
[0,0]
[1,1]
Line 1,174:
[31,14544636039226880]
[510,5.491717746183512e+302]
[511,null]</langsyntaxhighlight>
 
=={{header|Julia}}==
{{trans|Matlab}}
<langsyntaxhighlight lang=julia># v0.6
 
function pascal(n::Int)
Line 1,193:
end
 
@show catalan_num(15)</langsyntaxhighlight>
 
{{out}}
Line 1,199:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang=scala>// version 1.1.2
 
import java.math.BigInteger
Line 1,223:
val n = 15
catalanFromPascal(n * 2)
}</langsyntaxhighlight>
 
{{out}}
Line 1,247:
For each line of odd-numbered length from Pascal's triangle, print the middle number minus the one immediately to its right.
This solution is heavily based on the Lua code to generate Pascal's triangle from the page for that task.
<langsyntaxhighlight lang=Lua>function nextrow (t)
local ret = {}
t[0], t[#t + 1] = 0, 0
Line 1,263:
end
 
catalans(15)</langsyntaxhighlight>
{{out}}
<pre>1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440</pre>
Line 1,277:
We use & to pass by reference, here anarray, to sub, but because a sub can see anything in module we can change array name inside sub to same as triangle and we can remove arguments (including size).
 
<langsyntaxhighlight lang=M2000 Interpreter>
Module CatalanNumbers {
Def Integer count, t_row, size=31
Line 1,311:
}
CatalanNumbers
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,333:
=={{header|Maple}}==
 
<langsyntaxhighlight lang=maple>catalan:=proc(n)
local i,a:=[1],C:=[1];
for i to n do
Line 1,344:
 
catalan(10);
# [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796]</langsyntaxhighlight>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
This builds the entire Pascal triangle that's needed and holds it in memory. Very inefficienct, but seems to be what is asked in the problem.
<langsyntaxhighlight lang=Mathematica>nextrow[lastrow_] := Module[{output},
output = ConstantArray[1, Length[lastrow] + 1];
Do[
Line 1,363:
]
(* testing *)
catalannumbers[15]</langsyntaxhighlight>
{{out}}
<pre>{1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845}</pre>
Line 1,369:
=={{header|MATLAB}} / {{header|Octave}}==
 
<langsyntaxhighlight lang=MATLAB>n = 15;
p = pascal(n + 2);
p(n + 4 : n + 3 : end - 1)' - diag(p, 2)</langsyntaxhighlight>
{{Out}}
<pre>ans =
Line 1,392:
=={{header|Nim}}==
{{trans|Python}}
<langsyntaxhighlight lang=nim>const n = 15
var t = newSeq[int](n + 2)
 
Line 1,401:
for j in countdown(i+1, 1): t[j] += t[j-1]
stdout.write t[i+1] - t[i], " "
stdout.write '\n'</langsyntaxhighlight>
{{Out}}
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 </pre>
 
=={{header|OCaml}}==
<langsyntaxhighlight lang=ocaml>
let catalan : int ref = ref 0 in
Printf.printf "%d ," 1 ;
Line 1,419:
print_int (!catalan); print_string "," ;
done;;
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,428:
=={{header|Oforth}}==
 
<langsyntaxhighlight lang=Oforth>import: mapping
 
: pascal( n -- [] )
Line 1,434:
 
: catalan( n -- m )
n 2 * pascal at( n 1+ ) n 1+ / ;</langsyntaxhighlight>
 
{{out}}
Line 1,443:
 
=={{header|PARI/GP}}==
<langsyntaxhighlight lang=parigp>vector(15,n,binomial(2*n,n)-binomial(2*n,n+1))</langsyntaxhighlight>
{{out}}
<pre>%1 = [1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845]</pre>
 
=={{header|Pascal}}==
<langsyntaxhighlight lang=pascal>
Program CatalanNumbers
type
Line 1,484:
For i := 1 to L do
Writeln(i:3,Catalan[i]:20);
end.</langsyntaxhighlight>
<pre> 1 1
2 2
Line 1,505:
=={{header|Perl}}==
{{trans|C++}}
<langsyntaxhighlight lang=Perl>use constant N => 15;
my @t = (0, 1);
for(my $i = 1; $i <= N; $i++) {
Line 1,512:
for(my $j = $i+1; $j>1; $j--) { $t[$j] += $t[$j-1] }
print $t[$i+1] - $t[$i], " ";
}</langsyntaxhighlight>
{{out}}
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845</pre>
Line 1,518:
After the 28th Catalan number, this overflows 64-bit integers. We could add <tt>use bigint;</tt> <tt>use Math::GMP ":constant";</tt> to make it work, albeit not at a fast pace. However we can use a module to do it much faster:
{{libheader|ntheory}}
<langsyntaxhighlight lang=Perl>use ntheory qw/binomial/;
print join(" ", map { binomial( 2*$_, $_) / ($_+1) } 1 .. 1000), "\n";</langsyntaxhighlight>
 
The <tt>Math::Pari</tt> module also has a binomial, but isn't as fast and overflows its stack after 3400.
Line 1,525:
=={{header|Phix}}==
Calculates the minimum pascal triangle in minimum memory. Inspired by the comments in, but not the code of the FreeBasic example
<!--<langsyntaxhighlight lang=Phix>(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">N</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">15</span> <span style="color: #000080;font-style:italic;">-- accurate to 30, nan/inf for anything over 514 (gmp version is below).</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">catalan</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{},</span> <span style="color: #000080;font-style:italic;">-- (&gt;=1 only)</span>
Line 1,540:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">catalan</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,546:
</pre>
Explanatory comments to accompany the above
<langsyntaxhighlight lang=Phix>-- FreeBASIC said:
--' 1 1 1 1 1 1
--' 1 2 3 4 5 6
Line 1,578:
-- 10 15 21
-- 35 56
-- 126 (unused)</langsyntaxhighlight>
 
=== gmp version ===
{{libheader|Phix/mpfr}}
<!--<langsyntaxhighlight lang=Phix>(phixonline)-->
<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>
Line 1,604:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">100</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">catalanB</span><span style="color: #0000FF;">(</span><span style="color: #000000;">100</span><span style="color: #0000FF;">)))})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">250</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">mpz_get_str</span><span style="color: #0000FF;">(</span><span style="color: #000000;">catalanB</span><span style="color: #0000FF;">(</span><span style="color: #000000;">250</span><span style="color: #0000FF;">)))})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,619:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight lang=PicoLisp>(de bino (N K)
(let f
'((N)
Line 1,632:
(bino (* 2 N) N)
(bino (* 2 N) (inc N)) ) ) )
(bye)</langsyntaxhighlight>
 
=={{header|PureBasic}}==
{{trans|C}}
<langsyntaxhighlight lang=PureBasic>#MAXNUM = 15
Declare catalan()
 
Line 1,661:
Print(Str(cat)+" ")
Next
EndProcedure</langsyntaxhighlight>
{{out}}
<pre>
Line 1,669:
===Procedural===
{{trans|C++}}
<langsyntaxhighlight lang=python>>>> n = 15
>>> t = [0] * (n + 2)
>>> t[1] = 1
Line 1,680:
1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845
>>> </langsyntaxhighlight>
 
{{Works with|Python|2.7}}
<langsyntaxhighlight lang=python>def catalan_number(n):
nm = dm = 1
for k in range(2, n+1):
Line 1,691:
print [catalan_number(n) for n in range(1, 16)]
[1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845]</langsyntaxhighlight>
 
===Composition of pure functions===
Line 1,700:
{{Trans|Haskell}}
{{Works with|Python|3.7}}
<langsyntaxhighlight lang=python>'''Catalan numbers from Pascal's triangle'''
 
from itertools import (islice)
Line 1,833:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>[1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, 742900, 2674440, 9694845]</pre>
Line 1,839:
=={{header|Quackery}}==
 
<langsyntaxhighlight lang=Quackery> [ [] 0 rot 0 join
witheach
[ tuck +
Line 1,853:
drop ] is catalan ( n --> )
 
15 catalan</langsyntaxhighlight>
 
{{out}}
Line 1,860:
 
=={{header|Racket}}==
<langsyntaxhighlight lang=Racket>
#lang racket
 
Line 1,872:
;; -> '(1 1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900
;; 2674440 9694845)
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang=raku perl6line>constant @pascal = [1], -> @p { [0, |@p Z+ |@p, 0] } ... *;
 
constant @catalan = gather for 2, 4 ... * -> $ix {
Line 1,885:
}
 
.say for @catalan[^20];</langsyntaxhighlight>
{{out}}
<pre>1
Line 1,911:
===explicit subscripts===
All of the REXX program examples can handle arbitrary large numbers.
<langsyntaxhighlight lang=rexx>/*REXX program obtains and displays Catalan numbers from a Pascal's triangle. */
parse arg N . /*Obtain the optional argument from CL.*/
if N=='' | N=="," then N=15 /*Not specified? Then use the default.*/
Line 1,921:
@.ip=@.i; do k=ip by -1 for N; km=k-1; @.k=@.k+@.km; end /*k*/
say @.ip - @.i /*display the Ith Catalan number. */
end /*i*/ /*stick a fork in it, we're all done. */</langsyntaxhighlight>
'''output''' &nbsp; when using the default input:
<pre>
Line 1,942:
 
===implicit subscripts===
<langsyntaxhighlight lang=rexx>/*REXX program obtains and displays Catalan numbers from a Pascal's triangle. */
parse arg N . /*Obtain the optional argument from CL.*/
if N=='' | N=="," then N=15 /*Not specified? Then use the default.*/
Line 1,954:
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
@: parse arg !; return @.! /*return the value of @.[arg(1)] */</langsyntaxhighlight>
'''output''' &nbsp; is the same as the 1<sup>st</sup> version.
 
===using binomial coefficients===
<langsyntaxhighlight lang=rexx>/*REXX program obtains and displays Catalan numbers from a Pascal's triangle. */
parse arg N . /*Obtain the optional argument from CL.*/
if N=='' | N=="," then N=15 /*Not specified? Then use the default.*/
Line 1,970:
/*──────────────────────────────────────────────────────────────────────────────────────*/
comb: procedure; parse arg x,y; if x=y then return 1; if y>x then return 0
if x-y<y then y=x-y; _=1; do j=x-y+1 to x; _=_*j; end; return _/!(y)</langsyntaxhighlight>
'''output''' &nbsp; is the same as the 1<sup>st</sup> version.
 
===binomial coefficients, memoized===
This REXX version uses memoization for the calculation of factorials.
<langsyntaxhighlight lang=rexx>/*REXX program obtains and displays Catalan numbers from a Pascal's triangle. */
parse arg N . /*Obtain the optional argument from CL.*/
if N=='' | N=="," then N=15 /*Not specified? Then use the default.*/
Line 1,989:
/*──────────────────────────────────────────────────────────────────────────────────────*/
comb: procedure expose !.; parse arg x,y; if x=y then return 1; if y>x then return 0
if x-y<y then y=x-y; _=1; do j=x-y+1 to x; _=_*j; end; return _/!(y)</langsyntaxhighlight>
'''output''' &nbsp; is the same as the 1<sup>st</sup> version. <br><br>
 
=={{header|Ring}}==
<langsyntaxhighlight lang=ring>
n=15
cat = list(n+2)
Line 2,007:
see "" + (cat[i+1]-cat[i]) + " "
next
</syntaxhighlight>
</lang>
Output:
<pre>
Line 2,014:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang=tcl>def catalan(num)
t = [0, 1] #grows as needed
(1..num).map do |i|
Line 2,024:
end
 
p catalan(15)</langsyntaxhighlight>
{{out}}
<pre>
Line 2,031:
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang=runbasic>n = 15
dim t(n+2)
t(1) = 1
Line 2,039:
for j = i+1 to 1 step -1: t(j) = t(j) + t(j-1 : next j
print t(i+1) - t(i);" ";
next i</langsyntaxhighlight>
{{out}}
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 </pre>
 
=={{header|Rust}}==
<langsyntaxhighlight lang=rust>
 
fn main()
Line 2,073:
}
}
</syntaxhighlight>
</lang>
{{out}}
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845 </pre>
 
=={{header|Scala}}==
<langsyntaxhighlight lang=Scala>def catalan(n: Int): Int =
if (n <= 1) 1
else (0 until n).map(i => catalan(i) * catalan(n - i - 1)).sum
 
(1 to 15).map(catalan(_))</langsyntaxhighlight>
{{Out}}See it in running in your browser by [https://scastie.scala-lang.org/2ybpRZxCTOyrx3mIy8yIDw Scastie (JVM)].
 
=={{header|Scilab}}==
<syntaxhighlight lang=text>n=15
t=zeros(1,n+2)
t(1)=1
Line 2,098:
end
disp(t(i+1)-t(i))
end</langsyntaxhighlight>
{{out}}
<pre style="height:20ex"> 1.
Line 2,117:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang=seed7>$ include "seed7_05.s7i";
 
const proc: main is func
Line 2,137:
end for;
writeln;
end func;</langsyntaxhighlight>
 
{{out}}
Line 2,146:
=={{header|Sidef}}==
{{trans|Ruby}}
<langsyntaxhighlight lang=ruby>func catalan(num) {
var t = [0, 1]
(1..num).map { |i|
Line 2,156:
}
 
say catalan(15).join(' ')</langsyntaxhighlight>
{{out}}
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845</pre>
 
=={{header|smart BASIC}}==
<langsyntaxhighlight lang=qbasic>PRINT "Catalan Numbers from Pascal's Triangle"!PRINT
x = 15
DIM t(x+2)
Line 2,174:
NEXT m
PRINT n,"#######":t(n+1) - t(n)
NEXT n</langsyntaxhighlight>
 
=={{header|Tcl}}==
<langsyntaxhighlight lang=tcl>proc catalan n {
set result {}
array set t {0 0 1 1}
Line 2,189:
}
 
puts [catalan 15]</langsyntaxhighlight>
{{out}}
<pre>1 2 5 14 42 132 429 1430 4862 16796 58786 208012 742900 2674440 9694845</pre>
 
=={{header|TI-83 BASIC}}==
<langsyntaxhighlight lang=ti83b>"CATALAN
15→N
seq(0,I,1,N+2)→L1
Line 2,207:
End
Disp L1(I+1)-L1(I)
End</langsyntaxhighlight>
{{out}}
<pre> 1
Line 2,228:
=={{header|Vala}}==
{{trans|C++}}
<langsyntaxhighlight lang=vala>void main() {
const int N = 15;
uint64[] t = {0, 1};
Line 2,238:
}
print("\n");
}</langsyntaxhighlight>
 
{{out}}
Line 2,247:
=={{header|VBScript}}==
To run in console mode with cscript.
<langsyntaxhighlight lang=vbscript>dim t()
if Wscript.arguments.count=1 then
n=Wscript.arguments.item(0)
Line 2,266:
next 'j
Wscript.echo t(i+1)-t(i)
next 'i</langsyntaxhighlight>
 
=={{header|Visual Basic}}==
{{trans|Rexx}}
{{works with|Visual Basic|VB6 Standard}}
<syntaxhighlight lang=vb>
<lang vb>
Sub catalan()
Const n = 15
Line 2,288:
Next i
End Sub 'catalan
</syntaxhighlight>
</lang>
{{Out}}
<pre style="height:20ex">
Line 2,310:
=={{header|Wren}}==
{{trans|C++}}
<langsyntaxhighlight lang=ecmascript>var n = 15
var t = List.filled(n+2, 0)
t[1] = 1
Line 2,319:
System.write("%(t[i+1]-t[i]) ")
}
System.print()</langsyntaxhighlight>
 
{{out}}
Line 2,328:
=={{header|Zig}}==
Uses comptime functionality to compile Pascal's triangle into the object code, then at runtime, it's simply a table lookup. (uses code from AKS primality task.)
<langsyntaxhighlight lang=Zig>
const std = @import("std");
const stdout = std.io.getStdOut().outStream();
Line 2,371:
break :build coefficients;
};
</syntaxhighlight>
</lang>
{{Out}}
<pre>
Line 2,393:
=={{header|zkl}}==
{{trans|PARI/GP}} using binomial coefficients.
<langsyntaxhighlight lang=zkl>fcn binomial(n,k){ (1).reduce(k,fcn(p,i,n){ p*(n-i+1)/i },1,n) }
(1).pump(15,List,fcn(n){ binomial(2*n,n)-binomial(2*n,n+1) })</langsyntaxhighlight>
{{out}}
<pre>
Line 2,402:
=={{header|ZX Spectrum Basic}}==
{{trans|C++}}
<langsyntaxhighlight lang=zxbasic>10 LET N=15
20 DIM t(N+2)
30 LET t(2)=1
Line 2,410:
70 FOR j=i+1 TO 2 STEP -1: LET t(j)=t(j)+t(j-1): NEXT j
80 PRINT t(i+1)-t(i);" ";
90 NEXT i</langsyntaxhighlight>
Thundergnat
10,333

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327191"