Stirling numbers of the second kind: Difference between revisions

{{trans|Python}}

 

 

F sterling2(n, k)

E

print("#.\n(#. digits, k = #.)\n".format(previous, String(previous).len, k - 1))

 

{{out}}

{{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|Nim}}==

As for Stirling numbers of first kind, a simple program using recursive definition is enough to solve the task when not using big numbers.

 

proc s2(n, k: Natural): Natural =

for k in 0..n:

stdout.write ($s2(n, k)).align(8)

 

{{out}}

Now, to solve the second part of the task, we have to use big numbers. As for Stirling numbers of first kind, we also use a cache to avoid to repeat multiple times the same computations.

{{libheader|bignum}}

import bignum

 

 

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

 

{{out}}

 

=={{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.*/

end /*c*/

say center(r, wgi) strip( substr($,2), 'T') /*display a single row of the grid. */

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

<pre>

The maximum value (which has 115 decimal digits):

7769730053598745155212806612787584787397878128370115840974992570102386086289805848025074822404843545178960761551674

</pre>

 

=={{header|Ruby}}==

 

 

def sterling2(n, k)

puts "\nMaximum value from the sterling2(100, k)";

puts (1..100).map{|a| sterling2(100,a)}.max

{{out}}<pre>Sterling2 numbers:

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

 

</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:

{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

 

var computed = {}

break

}

 

{{out}}

 

=={{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%">