Stirling numbers of the first kind: Difference between revisions

 

<br><br>

 

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

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

Uses the Algol 68G LONG LONG INT mode which provides large-precision integers. As the default number of digits is insufficient for the task, the maximum nunber of digits is specified by a pragmatic comment.

 

# specify the precision of LONG LONG INT, we need about 160 digits #

REF[,]SINT s1 = make s1( max stirling, FALSE );

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

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

FOR n FROM 0 TO max stirling DO

OD;

print( ( newline ) )

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

END

{{out}}

<pre>

Unsigned Stirling numbers of the first kind:

n

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

19710908747055261109287881673376044669240511161402863823515728791076863288440277983854056472903481625299174865860036734731122707870406148096000000000000000000

</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.functional;

import std.stdio;

}

}

{{out}}

<pre>Unsigned Stirling numbers of the first kind:

19710908747055261109287881673376044669240511161402863823515728791076863288440277983854056472903481625299174865860036734731122707870406148096000000000000000000

(158 digits, k = 5)</pre>

 

=={{header|Factor}}==

For example, <tt>x(x-1)(x-2) = x³ - 3x² + 2x</tt>. Taking the absolute values of the coefficients, the third row is <tt>(0) 2 3 1</tt>.

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

math.ranges prettyprint sequences ;

IN: rosetta-code.stirling-first

 

"Maximum value from 100th stirling row:" print

{{out}}

<pre>

 

=={{header|FreeBASIC}}==

dim as ubyte n, k

dim as string outstr

next k

print outstr

<pre>Signed Stirling numbers of the first kind

 

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

 

 

 

 

=={{header|Go}}==

 

import (

fmt.Println(max)

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

 

{{out}}

=={{header|Haskell}}==

Using library: data-memocombinators for memoization

import Data.List (groupBy)

import qualified Data.MemoCombinators as Memo

where

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

 

Or library: monad-memo for memoization.

 

import Text.Printf (printf)

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

(158 digits, k = 5)

</pre>

 

=={{header|Julia}}==

 

const s1cache = Dict()

printstirling1table(12)

println("\nThe maximum for stirling1(100, _) is:\n", maximum(k-> stirlings1(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>Unsigned Stirling numbers of the first kind:

19710908747055261109287881673376044669240511161402863823515728791076863288440277983854056472903481625299174865860036734731122707870406148096000000000000000000

(158 digits, k = 5)</pre>

 

=={{header|Nim}}==

A simple implementation using the recursive definition is enough to complete the task.

 

 

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

for k in 0..n:

stdout.write ($s1(n, k)).align(10)

 

{{out}}

{{libheader|bignum}}

 

import bignum

 

 

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

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use bigint;

 

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

{{out}}

<pre>Unsigned Stirling1 numbers of the first kind: S1(n, k):

{{libheader|Phix/mpfr}}

{{trans|Go}}

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

 

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

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

max_stirling1(100, M),

 

{{out}}

=={{header|PureBasic}}==

{{trans|FreeBasic}}

#MAX=12

#LZ=10

Next

Input()

{{out}}

<pre>Signed Stirling numbers of the first kind

=={{header|Python}}==

{{trans|Java}}

computed = {}

 

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

break

{{out}}

<pre>

19710908747055261109287881673376044669240511161402863823515728791076863288440277983854056472903481625299174865860036734731122707870406148096000000000000000000

(158 digits, k = 5)

</pre>

 

{{works with|Rakudo|2019.07.1}}

 

return 1 unless n || k;

return 0 unless n && k;

 

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

{{out}}

<pre>Unsigned Stirling numbers of the first kind: S1(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 right(r,wi) 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 158 decimal digits):

19710908747055261109287881673376044669240511161402863823515728791076863288440277983854056472903481625299174865860036734731122707870406148096000000000000000000

</pre>

 

=={{header|Ruby}}==

{{trans|D}}

def sterling1(n, k)

if n == 0 and k == 0 then

end

 

{{out}}

<pre>Unsigned Stirling numbers of the first kind:

 

=={{header|Sidef}}==

stirling(n, k).abs

}

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

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

{{out}}

<pre>

 

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

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

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

 

=={{header|Tcl}}==

This computes the unsigned Stirling numbers of the first kind.

Inspired by [[Stirling_numbers_of_the_second_kind#Tcl]], hence similar to [[#Java]].

if {$k == 0} {

return [expr {$n == 0}]

}

}

 

{{out}}

{{trans|Java}}{{libheader|Wren-big}}

{{libheader|Wren-fmt}}

 

var computed = {}

break

}

 

{{out}}

19710908747055261109287881673376044669240511161402863823515728791076863288440277983854056472903481625299174865860036734731122707870406148096000000000000000000

(158 digits, k = 5)

</pre>

 

=={{header|zkl}}==

{{trans|Raku}}

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

if(n==k==0) return(1);

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

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

N,mx := 12, [1..N].apply(fcn(n){ [1..n].apply(stirling1.fp(n)) : (0).max(_) }) : (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, stirling1.fp(row), fmt));

{{out}}

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

</pre>

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

N=100;

println("Maximum value from the S1(%d, *) row:".fmt(N));

[1..N].apply(stirling1.fp(BI(N)))

{{out}}

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