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.

# show some Stirling numbers of the second kind #

 

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

END

{{out}}

<pre>

 

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

integer MAX_STIRLING;

MAX_STIRLING := 12;

end for_n

end

{{out}}

<pre>

 

=={{header|BASIC}}==

20 DIM S2(12,12),F(12)

30 FOR N=0 TO 12: READ F(N): NEXT N

140 NEXT N

150 DATA ##,##,#####,######,#######,########

{{out}}

<pre> 1

 

=={{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:

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

is available in the second part.

 

 

# Input: {computed} (the cache)

| .emit,

part2(100)

{{out}}

<pre>

 

=={{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:

 

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

{{out}}

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

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</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;">"\nThe maximum S2(100,k): %s\n"</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;">m100</span><span style="color: #0000FF;">)))</span>

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

=={{header|Quackery}}==

 

over size -

space swap of

0 100 times

[ 100 i^ 1+ s2 max ]

 

{{out}}

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

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

import "/fmt" for Fmt

 

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