Evaluate binomial coefficients: Difference between revisions

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

{{trans|Python}}

V result = 1

L(i) 1..k

R result

 

 

{{out}}

{{trans|ABAP}}

Very compact version.

BINOMIAL CSECT

USING BINOMIAL,R15 set base register

PG DS CL12 buffer

YREGS

{{out}}

<pre>

 

=={{header|ABAP}}==

 

PUBLIC SECTION.

ENDMETHOD.

 

{{Out}}

<pre>lcl_binom=>calc( n = 5 k = 3 )

 

=={{header|ACL2}}==

(if (zp n)

1

 

(defun binom (n k)

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

procedure Test_Binomial is

end loop;

end Test_Binomial;

{{Out}}

<pre>

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

 

(

INT result;

test:(

print((choose(5, 3), new line))

{{Out}}

<pre>

 

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

% calculates n!/k! %

integer procedure factorialOverFactorial( integer value n, k ) ;

write( binomialCoefficient( 5, 3 ) )

 

 

=={{header|AppleScript}}==

===Imperative===

set k to 3

 

 

return n_factorial / (n_minus_k_factorial) * 1 / (k_factorial) as integer

 

===Functional===

Using a little more abstraction for readability, and currying for ease of both re-use and refactoring:

 

on factorial(n)

product(enumFromTo(1, n))

foldl(multiply, 1, xs)

{{Out}}

<pre>{10, 10}</pre>

 

=={{header|AutoHotkey}}==

 

;---------------------------------------------------------------------------

}

Return, r

Message box shows:

<pre>10</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f EVALUATE_BINOMIAL_COEFFICIENTS.AWK

BEGIN {

printf("%d %d = %d\n",n,k,r)

}

{{out}}

<pre>

 

=={{header|Batch File}}==

 

if "%~2"=="" ( echo Usage: %~nx0 n k && goto :EOF )

for /L %%I in (1, 1, %~3) do set /a coeff /= %%I

endlocal && set "%~1=%coeff%"

 

{{Out}}

</pre>

The Windows cmd console only handles 32-bit integers. If a factoral exceeds 2147483647 at any point, <code>set /a</code> will choke and roll over to a negative value, giving unexpected results. Unfortunately, this is as good as it gets for pure batch.

 

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

PRINT "Binomial (5,3) = "; FNbinomial(5, 3)

ENDWHILE

= R%

{{Out}}

<pre>Binomial (5,3) = 10

 

=={{header|Bracmat}}==

n k coef

. !arg:(?n,?k)

binomial$(5,3)

10

 

=={{header|Burlesque}}==

 

blsq ) 5 3nr

10

 

=={{header|C}}==

#include <limits.h>

 

printf("%lu\n", binomial(67, 31));

return 0;

{{out}}

<pre>10

 

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

 

namespace BinomialCoefficients

}

}

 

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

{

double result = nValue;

return Factorial(n) /(Factorial(k)*Factorial((n - k)));

}

 

Implementation:

{

cout<<"The Binomial Coefficient of 5, and 3, is equal to: "<< binomialCoefficient(5,3);

cin.get();

 

{{Out}}

 

=={{header|Clojure}}==

(let [rprod (fn [a b] (reduce * (range a (inc b))))]

 

=={{header|CoffeeScript}}==

binomial_coefficient = (n, k) ->

result = 1

for k in [0..n]

console.log "binomial_coefficient(#{n}, #{k}) = #{binomial_coefficient(n,k)}"

 

{{Out}}<pre>

binomial_coefficient(5, 5) = 1

</pre>

 

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

(defun choose (n k)

(labels ((prod-enum (s e)

(fact (n) (prod-enum 1 n)))

(/ (prod-enum (- (1+ n) k) n) (fact k))))

 

=={{header|D}}==

if (k > (n / 2))

k = n - k;

writefln("(%3d %3d) = %s", d[0], d[1], binomial(d[0], d[1]));

writeln("(100 50) = ", binomial(100.BigInt, 50.BigInt));

{{out}}

<pre>( 5 3) = 2

(100 50) = 1976664223067613962806675336</pre>

 

{

T nn = n, kk = k, c = cast(T)1;

BinomialCoeff(10UL, 3UL).writeln;

BinomialCoeff(100.BigInt, 50.BigInt).writeln;

{{out}}

<pre>120

 

=={{header|dc}}==

 

Demonstration:

 

<tt>10</tt>

 

Annotated version:

 

[sx [ x is our dump register; get rid of extraneous copy of n we no longer need]sx

1 [ return value is 1 ]sx

] sb

 

 

=={{header|Delphi}}==

 

 

{$APPTYPE CONSOLE}

Writeln('C(5,3) is ', BinomialCoff(5, 3));

ReadLn;

 

=={{header|Elixir}}==

{{trans|Erlang}}

def choose(n,k) when is_integer(n) and is_integer(k) and n>=0 and k>=0 and n>=k do

if k==0, do: 1, else: choose(n,k,1,1)

 

IO.inspect RC.choose(5,3)

 

{{out}}

 

=={{header|Erlang}}==

choose(N, 0) -> 1;

choose(N, K) when is_integer(N), is_integer(K), (N >= 0), (K >= 0), (N >= K) ->

choose(N, K, I, Acc) ->

choose(N, K, I+1, (Acc * (N-I+1)) div I).

 

=={{header|ERRE}}==

 

!$DOUBLE

PRINT("Binomial (33,17) = ";BIN)

END PROGRAM

{{out}}

<pre>Binomial (5,3) = 10

 

=={{header|F Sharp|F#}}==

let choose n k = List.fold (fun s i -> s * (n-i+1)/i ) 1 [1..k]

 

=={{header|Factor}}==

: fact ( n -- n-factorial )

dup 0 = [ drop 1 ] [ dup 1 - fact * ] if ;

: choose-fold ( n k -- n-choose-k )

2dup 1 + [a,b] product -rot - 1 [a,b] product / ;

 

=={{header|Forth}}==

 

5 3 choose . \ 10

 

=={{header|Fortran}}==

=== Direct Method ===

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

 

implicit none

end function choose

 

{{Out}}<pre>10</pre>

 

=== Avoiding Overflow ===

Of course this method doesn't avoid overflow completely just delays it. It could be extended by adding more entries to the '''primes''' array

program binomial

integer :: i, j

 

end program binomial

 

{{Out}}

 

=={{header|FreeBASIC}}==

 

Function factorial(n As Integer) As Integer

Print

Print "Press any key to quit"

 

{{out}}

Frink has a built-in efficient function to find binomial coefficients.

It produces arbitrarily-large integers.

println[binomial[5,3]]

 

=={{header|FunL}}==

FunL has pre-defined function <code>choose</code> in module <code>integers</code>, which is defined as:

choose( n, k ) | k < 0 or k > n = 0

choose( n, 0 ) = 1

 

println( choose(5, 3) )

{{out}}

<pre>

 

Here it is defined using the recommended formula for this task.

 

def

binomial( n, k ) | k < 0 or k > n = 0

 

=={{header|GAP}}==

Binomial(5, 3);

 

=={{header|Go}}==

import "fmt"

import "math/big"

fmt.Println(new(big.Int).Binomial(5, 3))

fmt.Println(new(big.Int).Binomial(60, 30))

{{out}}

<pre>

=={{header|Golfscript}}==

Actually evaluating n!/(k! (n-k)!):

{),(;{*}*}:f; # Define a factorial function

But Golfscript is meant for golfing, and it's shorter to calculate <math>\prod_{i=0}^{k-1} \frac{n-i}{i+1}</math>:

 

 

=={{header|Groovy}}==

Solution:

assert x > -1

x == 0 ? 1 : (1..x).inject(1G) { BigInteger product, BigInteger factor -> product *= factor }

assert n >= k

factorial(n).intdiv(factorial(k)*factorial(n-k))

 

Test:

assert combinations(20, 10) == (combinations(19, 9) + combinations(19, 10))

assert combinations(5, 3) == 10

 

{{Out}}

<pre>10</pre>

 

=={{header|Haskell}}==

The only trick here is realizing that everything's going to divide nicely, so we can use div instead of (/).

 

choose :: (Integral a) => a -> a -> a

choose n k = product [k+1..n] `div` product [1..n-k]

 

 

Or, generate the binomial coefficients iteratively to avoid computing with big numbers:

 

choose :: (Integral a) => a -> a -> a

choose n k = foldl (\z i -> (z * (n-i+1)) `div` i) 1 [1..k]

 

Or using "caching":

 

where

next ns = zipWith (+) (0:ns) $ ns ++ [0]

 

 

=={{header|HicEst}}==

 

FUNCTION factorial( n )

FUNCTION BinomCoeff( n, k )

BinomCoeff = factorial(n)/factorial(n-k)/factorial(k)

 

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

 

procedure main()

write("choose(5,3)=",binocoef(5,3))

{{Out}}

<pre>choose(5,3)=10</pre>

[http://www.cs.arizona.edu/icon/library/src/procs/factors.icn factors provides factorial].

 

 

k := integer(k) | fail

return i

 

 

=={{header|IS-BASIC}}==

110 PRINT "Binomial (5,3) =";BINOMIAL(5,3)

120 DEF BINOMIAL(N,K)

200 LOOP

210 LET BINOMIAL=R

 

=={{header|J}}==

 

'''Example usage:'''

 

=={{header|Java}}==

 

// precise, but may overflow and then produce completely incorrect results

demo(1000, 300);

}

{{Out}}

<pre>5 3 10 10 10.0 10

Recursive version, without overflow check:

 

{

private static long binom(int n, int k)

System.out.println(binom(5, 3));

}

{{Out}}

<pre>10</pre>

 

=={{header|JavaScript}}==

var coeff = 1;

var i;

}

 

{{Out}}

<pre>10</pre>

 

=={{header|jq}}==

def binomial(n; k):

if k > n / 2 then binomial(n; n-k)

 

([5,3], [100,2], [ 33,17]) | task

{{out}}

5 C 3 = 10

 

'''Built-in'''

 

'''Recursive version''':

n ≥ k || return 0 # short circuit base cases

(n == 1 || k == 0) && return 1

end

 

 

{{out}}

 

=={{header|K}}==

 

Alternative version:

 

Using Pascal's triangle:

pascal 5

(1

 

{[n;k](pascal n)[n;k]} . 5 3

 

=={{header|Kotlin}}==

 

fun binomial(n: Int, k: Int) = when {

println()

}

 

{{out}}

 

=={{header|Lambdatalk}}==

 

{def C

1 16 120 560 1820 4368 8008 11440 12870 11440 8008 4368 1820 560 120 16 1

 

 

=={{header|Lasso}}==

#k == 0 ? return 1

local(result = 1)

binomial(5, 3)

binomial(5, 4)

 

{{Out}}

 

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

' [RC] Binomial Coefficients

 

end function

 

=={{header|Logo}}==

if :k = 0 [output 1]

output (choose :n :k-1) * (:n - :k + 1) / :k

 

show choose 5 3 ; 10

 

=={{header|Lua}}==

if k > n then return nil end

if k > n/2 then k = n - k end -- (n k) = (n n-k)

end

return numer / denom

 

Additive recursion with memoization by hashing 2 input integer.

Lua 5.3 support bit-wise operation; assume 64 bit integer implementation here.

__call = function(self,n,k)

local hash = (n<<32) | (k & 0xffffffff)

})

print( Binomial(100,50)) -- 1.0089134454556e+029

 

=={{header|Maple}}==

 

{{Out}}

<pre> factorial(n)

 

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

 

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

 

Solution:

ans =

 

Alternative implementations are:

 

r = diag(rot90(pascal(n+1))); % vector of all binomial coefficients for order n

r = r(k);

 

prod((n-k+1:n)./(1:k))

 

m = pascal(max(n-k,k)+1);

r = m(n-k+1,k+1);

 

If you want a vectorized function that returns multiple binomial coefficients given vector inputs, you must define that function yourself. A sample implementation is given below. This function takes either scalar or vector inputs for "n" and "v" and returns either a: scalar, vector, or matrix. Where the columns are indexed by the "k" vector and the rows indexed by the "n" vector.

binomialCoeff.m:

 

coefficients = zeros(numel(n),numel(k)); %Preallocate memory

end

Sample Usage:

 

ans =

ans =

 

 

=={{header|Maxima}}==

binomial(-5, 3); /* -35 */

binomial( 5, -3); /* 0 */

 

binomial(a, b); /* binomial(a, b) */

 

=={{header|min}}==

{{works with|min|0.19.3}}

('dup dip dup ((fact) () (- fact) (fact * div)) spread) :binomial

 

{{out}}

<pre>

 

=={{header|MINIL}}==

00 0E Go: ENT R0 // n

01 1E ENT R1 // r

1D C9 JNZ Next

1E 03 R0 = R3

 

This uses the recursive definition:

 

=={{header|МК-61/52}}==

ИП0 ИП1 - ПП 22 ИП3 * П3 ИП2 ИП3

 

''Input'': ''n'' ^ ''k'' В/О С/П.

=={{header|Nanoquery}}==

{{trans|Python}}

result = 1

for i in range(1, k)

if main

println binomialCoeff(5,3)

 

=={{header|Nim}}==

Note that a function to compute these coefficients, named “binom”, is available in standard module “math”.

result = 1

for i in 1..k:

result = result * (n-i+1) div i

 

{{Out}}

<pre>10</pre>

 

{{works with|oo2c}}

MODULE Binomial;

IMPORT

Out.Int(For(5,2),0);Out.Ln

END Binomial.

{{Out}}

<pre>10</pre>

 

=={{header|OCaml}}==

let binomialCoeff n p =

let p = if p < n -. p then p else n -. p in

else res in

cm 1. n 1.

=== Alternate version using big integers ===

open Num;;

 

else a (succ j) ((v */ (Int (n - j))) // (Int (succ j)))

in a 0 (Int 1)

 

=== Simple recursive version ===

 

=={{header|Oforth}}==

 

 

{{out}}

=={{header|Oz}}==

{{trans|Python}}

fun {BinomialCoeff N K}

{List.foldL {List.number 1 K 1}

end

in

 

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

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

use bigint;

my ($r, $n, $k) = (1, @_);

}

 

{{out}}

 

Since the bigint module already has a binomial method, this could also be written as:

use bigint;

my($n,$k) = @_;

(0+$n)->bnok($k);

 

For better performance, especially with large inputs, one can also use something like:

{{libheader|ntheory}}

{{out}}

<pre>30101</pre>

 

=={{header|Phix}}==

Example:

{{out}}

<pre>

However errors will creep in should any result or interim value exceed 9,007,199,254,740,992 (on 32-bit), so:

{{libheader|Phix/mpfr}}

{{out}}

<pre>

"1004576581793084916475353119318331966507299414258370667602185866686463289093457468590558508056798211449853806741873396451735444387513582540860551330127062642417424083600"

</pre>

 

=={{header|PHP}}==

$n=5;

$k=3;

$binomial_coefficient=factorial($n)/(factorial($k)*factorial($n-$k));

echo $binomial_coefficient;

 

Alternative version, not based on factorial

function binomial_coefficient($n, $k) {

if ($k == 0) return 1;

return $result;

}

 

=={{header|PicoLisp}}==

(let f

'((N)

(/

(f N)

{{Out}}

<pre>: (binomial 5 3)

 

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

binomial_coefficients:

procedure options (main);

end fact;

end binomial_coefficients;

{{Out}}

<pre>

 

=={{header|PowerShell}}==

function choose($n,$k) {

if($k -le $n -and 0 -le $k) {

choose 10 2

choose 10 8

<b>Output:</b>

<pre>

 

=={{header|PureBasic}}==

Protected Result=1

While n>0

Print("Press ENTER to quit"): Input()

CloseConsole()

'''Example

Enter value n: 5

=={{header|Python}}==

===Imperative===

result = 1

for i in range(1, k+1):

 

if __name__ == "__main__":

{{Out}}

<pre>10</pre>

 

===Functional===

from functools import reduce

 

else:

return ( reduce( mul, range((n - r + 1), n + 1), 1)

 

 

 

{{Works with|Python|3.7}}

 

from functools import reduce

# TESTS ---------------------------------------------------

if __name__ == '__main__':

{{Out}}

<pre>10

Compare the use of Python comments, (above); with the use of Python type hints, (below).

 

from functools import reduce

from operator import mul

print(binomialCoefficient(5)(3))

# k=0 to k=5, where n=5

{{Out}}

<pre>10

[1, 5, 10, 10, 5, 1]</pre>

 

=={{header|R}}==

R's built-in choose() function evaluates binomial coefficients:

 

{{Out}}

 

=={{header|Racket}}==

#lang racket

(require math)

(binomial 10 5)

 

=={{header|Raku}}==

(formerly Perl 6)

For a start, you can get the length of the corresponding list of combinations:

{{out}}

<pre>10</pre>

This method is efficient, as Raku will not actually compute each element of the list, since it actually uses an iterator with a defined <tt>count-only</tt> method. Such method performs computations in a way similar to the following infix operator:

 

 

A possible optimization would use a symmetry property of the binomial coefficient:

 

 

One drawback of this method is that it returns a Rat, not an Int. So we actually may want to enforce the conversion:

 

And ''this'' is exactly what the <tt>count-only</tt> method does.

The task is to compute ANY binomial coefficient(s), but these REXX examples are limited to 100k digits.

===idiomatic===

numeric digits 100000 /*be able to handle gihugeic numbers. */

parse arg n k . /*obtain N and K from the C.L. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

comb: procedure; parse arg x,y; return !(x) % (!(x-y) * !(y))

'''output''' when using the input of: &nbsp; <tt> 5 &nbsp; 3 </tt>

<pre>

This REXX version takes advantage of reducing the size (product) of the numerator, and also,

<br>only two (factorial) products need be calculated.

numeric digits 100000 /*be able to handle gihugeic numbers. */

parse arg n k . /*obtain N and K from the C.L. */

comb: procedure; parse arg x,y; return pfact(x-y+1, x) % pfact(2, y)

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; is identical to the 1^st REXX version.

 

 

=={{header|Ring}}==

numer = 0

binomial(5,3)

next

return numer

 

=={{header|Ruby}}==

 

{{works with|Ruby|1.8.7+}}

# binomial coefficient: n C k

def choose(k)

 

p 5.choose(3)

result

<pre>10

another implementation:

 

def c n, r

(0...r).inject(1) do |m,i| (m * (n - i)) / (i + 1) end

end

 

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

print "binomial (5,2) = "; binomial(5, 2)

print "binomial (5,3) = "; binomial(5, 3)

next i

binomial = coeff

{{Out}}

<pre>binomial (5,1) = 5

 

=={{header|Rust}}==

let mut f:u64 = n as u64;

for i in 2..n {

fn main() {

println!("{}", choose(5,3));

{{Out}}

<pre>10</pre>

Alternative version, using functional style:

 

let factorial=|x| (1..=x).fold(1, |a, x| a * x);

factorial(n) / factorial(k) / factorial(n - k)

 

=={{header|Scala}}==

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

val n=5

def binomialCoefficient(n:Int, k:Int)=fact(n) / (fact(k) * fact(n-k))

def fact(n:Int):Int=if (n==0) 1 else n*fact(n-1)

{{Out}}

<pre>The Binomial Coefficient of 5 and 3 equals 10.</pre>

Another (more flexible and efficient) implementation. n and k are taken from command line. The use of BigInts allows to compute coefficients of arbitrary size:

 

def binomialCoefficient(n: Int, k: Int) =

(BigInt(n - k + 1) to n).product /

val Array(n, k) = args.map(_.toInt)

println("The Binomial Coefficient of %d and %d equals %,3d.".format(n, k, binomialCoefficient(n, k)))

 

{{Out}}

 

Using recursive formula <code>C(n,k) = C(n-1,k-1) + C(n-1,k)</code>:

case (n, 0) => 1

case (0, k) => 0

case (n, k) => bico(n - 1, k - 1) + bico(n - 1, k)

}

{{Out}}

<pre>bico(5,3) = 10</pre>

=={{header|Scheme}}==

{{Works with|Scheme|R<math>^5</math>RS}}

(define (*factorial n acc)

(if (zero? n)

 

(display (choose 5 3))

{{Out}}

<pre>10</pre>

Alternatively a recursive implementation can be constructed from Pascal's Triangle:

 

(cond ((= i 0) 1)

((= j 0) 1)

 

(display (choose 5 3))

{{Out}}

<pre>10</pre>

E.g.: <tt>(-6) ! 10</tt> evaluates to 3003.

 

 

const proc: main is func

writeln;

end for;

 

{{Out}}

for the type [http://seed7.sourceforge.net/manual/types.htm#bigInteger bigInteger]:

 

result

var bigInteger: binom is 0_;

end if;

end func;

 

Original source [http://seed7.sourceforge.net/algorith/math.htm#binomial_coefficient].

 

Simplest Solution:

choose(n, k) := product(k + 1 ... n) / product(1 ... n - k);

 

Tail-Recursive solution to avoid arithmetic with large integers:

 

choose(n,k) := binomial(n, k, 1, 1);

result when i > k else

binomial(n, k, i + 1, (result * (n - i + 1)) / i);

 

=={{header|Sidef}}==

Straightforward translation of the formula:

n! / ((n-k)! * k!)

}

 

 

Alternatively, by using the ''Number.nok()'' method:

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

Having a small language but a big class library in my bag, we can write:

{{out}}

<pre>10

 

A naïve implementation (in the Integer class) might look like:

 

=={{header|Stata}}==

Use the [http://www.stata.com/help.cgi?comb comb] function. Notice the result is a missing value if k>n or k<0.

 

 

=={{header|Swift}}==

 

guard n != 0 else {

return 1

 

print("binomial(\(5), \(3)) = \(binomial((5, 3)))")

 

{{out}}

=={{header|Tcl}}==

This uses exact arbitrary precision integer arithmetic.

proc binom {n k} {

# Compute the top half of the division; this is n!/(n-k)!

# Integer arithmetic divide is correct here; the factors always cancel out

return [expr {$pTop / $pBottom}]

Demonstrating:

{{Out}}

<pre>5_C_3 = 10

60_C_30 = 118264581564861424</pre>

 

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

Builtin operator nCr gives the number of combinations.

{{out}}

<pre>

Builtin function.

 

 

=={{header|TXR}}==

nCk is a built-in function, along with the one for permutations, nPk:

 

 

 

=={{header|UNIX Shell}}==

 

n=5;

k=3;

binomial_coefficient=$(expr $n_factorial \/ $k_factorial \* 1 \/ $n_minus_k_factorial )

 

 

=={{header|Ursala}}==

A function for computing binomial coefficients (<code>choose</code>) is included in a standard library, but if it weren't, it could be defined in one of the following ways, starting from the most idiomatic.

 

The standard library functions <code>quotient</code>, <code>product</code> and <code>predecessor</code> pertain to natural numbers in the obvious way.

* <code>choose</code> is defined using the recursive conditional combinator (<code>^?</code>) as a function taking a pair of numbers, with the predicate <code>~&ar</code> testing whether the number on the right side of the pair is non-zero.

* The product of these values is then divided (<code>quotient</code>) by the right side (<code>~&ar</code>) of the original argument and returned as the result.

Here is a less efficient implementation more closely following the formula above.

* <code>choose</code> is defined as the <code>quotient</code> of the results of a pair (<code>^</code>) of functions.

* The left function contributing to the quotient is the <code>factorial</code> of the left side (<code>@l</code>) of the argument, which is assumed to be a pair of natural numbers. The <code>factorial</code> function is provided in a standard library.

* A composition (<code>+</code>) of this function with the <code>product</code> function effects the multiplication of the two factorials, to complete the other input to the quotient.

Here is an equivalent implementation using pattern matching, dummy variables, and only the apply-to-both (<code>~~</code>) operator.

test program:

 

{{Out}}

<pre><10,118264581564861424></pre>

 

=={{header|VBScript}}==

binomial = factorial(n)/(factorial(n-k)*factorial(k))

End Function

'calling the function

WScript.StdOut.Write "the binomial coefficient of 5 and 3 = " & binomial(5,3)

 

{{Out}}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

 

var binomial = Fn.new { |n, k|

for (k in 0..n) System.write(Fmt.d(5, binomial.call(n, k)))

System.print()

 

{{out}}

 

=={{header|XPL0}}==

 

func Binomial(N, K);

CrLf(0);

];

 

{{Out}}

</pre>

 

=={{header|zkl}}==

Using 64 bit ints:

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|BBC_BASIC}}

20 LET r=1: LET d=n-k

30 IF d>k THEN LET k=d: LET d=n-k

80 GO TO 40

90 PRINT r