Stirling numbers of the second kind: Difference between revisions

 

<br>

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses the LONG LONG INT mode of Algol 68g which allows large precision integers. As the default precision of LONG LONG INT is too small, the precision is specified via a pragmatic comment.

 

# specify the precision of LONG LONG INT, somewhat under 160 digits are #

FOR n FROM 0 TO max n - 1 DO

FOR k FROM 1 TO n DO

OD

OD;

print( ( "Stirling numbers of the second kind:", newline ) );

print( ( " k" ) );

print( ( newline, " n", newline ) );

FOR n FROM 0 TO max stirling DO

print( ( whole( n, -2 ) ) );

FOR k FROM 0 TO n DO

OD;

print( ( newline ) )

print( ( whole( max 100, 0 ), newline ) )

END

{{out}}

<pre>

Stirling numbers of the second kind:

n

Maximum Stirling number of the second kind with n = 100:

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

</pre>

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

stirling_cache_destroy(&sc);

return 0;

 

{{out}}

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

{{libheader|GMP}}

#include <iomanip>

#include <iostream>

std::cout << max << '\n';

return 0;

 

{{out}}

=={{header|D}}==

{{trans|Java}}

import std.conv;

import std.functional;

}

}

{{out}}

<pre>Stirling numbers of the second kind:

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

(115 digits, k = 28)</pre>

 

=={{header|Factor}}==

{{works with|Factor|0.99 development version 2019-07-10}}

math.extras prettyprint sequences ;

RENAME: stirling math.extras => (stirling)

 

"Maximum value from the 100 _ stirling row:" print

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

dim as ubyte n, k

dim as string outstr

next k

print outstr

<pre>Stirling numbers of the second kind

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import (

fmt.Println(max)

fmt.Printf("which has %d digits.\n", len(max.String()))

 

{{out}}

</pre>

=={{header|Haskell}}==

import Data.List (groupBy)

import qualified Data.MemoCombinators as Memo

where

table :: [[(Int, Int)]]

{{out}}

<pre>n/k 0 1 2 3 4 5 6 7 8 9 10 11 12

 

=={{header|Java}}==

import java.math.BigInteger;

import java.util.HashMap;

 

}

 

{{out}}

12 0 1 2047 86526 611501 1379400 1323652 627396 159027 22275 1705 66 1

The maximum value of S2(100, k) =

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

(115 digits, k = 28)

 

=={{header|Julia}}==

 

const s2cache = Dict()

println("\nThe maximum for stirling2(100, _) is: ", maximum(k-> stirlings2(BigInt(100), BigInt(k)), 1:100))

 

<pre>

0 1 2 3 4 5 6 7 8 9 10 11 12

=={{header|Kotlin}}==

{{trans|Java}}

 

fun main() {

COMPUTED[key] = result

return result

{{out}}

<pre>Stirling numbers of the second kind:

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

(115 digits, k = 28)</pre>

 

=={{header|Perl}}==

use warnings;

use bigint;

 

say "\nMaximum value from the S2(100, *) row:";

{{out}}

<pre>Unsigned Stirling2 numbers of the second kind: S2(n, k):

{{libheader|Phix/mpfr}}

{{trans|Go}}

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

 

stirling2(N, N, 1):-!.

writeln('Maximum value of S2(n,k) where n = 100:'),

max_stirling2(100, M),

 

{{out}}

=={{header|Python}}==

{{trans|Java}}

computed = {}

 

print("{0}\n({1} digits, k = {2})\n".format(previous, len(str(previous)), k - 1))

break

{{out}}

<pre>

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

(115 digits, k = 28)

</pre>

 

{{works with|Rakudo|2019.07.1}}

 

((1,), { (0, |@^last) »+« (|(@^last »*« @^last.keys), 0) } … *)[n;k]

}

 

say "\nMaximum value from the S2(100, *) row:";

{{out}}

<pre>Stirling numbers of the second kind: S2(n, k):

=={{header|REXX}}==

Some extra code was added to minimize the displaying of the column widths.

parse arg lim . /*obtain optional argument from the CL.*/

if lim=='' | lim=="," then lim= 12 /*Not specified? Then use the default.*/

numeric digits max(9, 2*lim) /*(over) specify maximum number in grid*/

@.=

max#.= 0 /* [↓] calculate values for the grid. */

/* [↓] only show the maximum value ? */

do k=0 for lim+1 /*find max column width for each column*/

exit /*stick a fork in it, we're all done. */

end

 

{{out|output|text=&nbsp; when using the default input:}}

<pre>

</pre>

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> -100 </tt>}}

The maximum value (which has 115 decimal digits):

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

</pre>

 

=={{header|Sidef}}==

stirling2(n, k)

}

say "\nMaximum value from the S2(#{n}, *) row:"

say { S2(n, _) }.map(^n).max

{{out}}

<pre>

 

Alternatively, the '''S2(n,k)''' function can be defined as:

func S2(_, (0)) { 0 }

func S2((0), _) { 0 }

 

=={{header|Tcl}}==

 

{{trans|Java}}

set nk [list $n $k]

if {[info exists ::S2cache($nk)]} {

}

}

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|Java}}

 

Module Module1

End Sub

 

{{out}}

<pre>Stirling numbers of the second kind:

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

(115 digits, k = 28)</pre>

 

=={{header|zkl}}==

var seen=Dictionary(); // cache for recursion

if(n==k) return(1); // (0.0)==1

if(Void==(s2 := seen.find(z2))){ s2 = seen[z2] = stirling2(n-1,k-1) }

k*s1 + s2; // k is first to cast to BigInt (if using BigInts)

N,mx := 12, [1..N].apply(fcn(n){ [1..n].apply(stirling2.fp(n)) }).flatten() : (0).max(_);

fmt:="%%%dd".fmt("%d".fmt(mx.numDigits + 1)).fmt; // "%9d".fmt

foreach row in ([0..N]){

println("%3d".fmt(row), [0..row].pump(String, stirling2.fp(row), fmt));

{{out}}

<pre style="font-size:83%">

</pre>

{{libheader|GMP}} GNU Multiple Precision Arithmetic Library

N=100;

S2100:=[BI(2)..N].apply(stirling2.fp(BI(N))).reduce(fcn(m,n){ m.max(n) });

println("Maximum value from the S2(%d,*) row (%d digits):".fmt(N,S2100.numDigits));

{{out}}

<pre style="font-size:83%">