Rosetta Code

Lah numbers: Difference between revisions

Page Discussion

Lah numbers (view source)

Revision as of 09:19, 23 March 2024

30,064 bytes added ,  2 months ago
added RPL
m (Updated description and link for Fōrmulæ solution)
(added RPL)
 
(27 intermediate revisions by 18 users not shown)
Line 40:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F lah(BigInt n, BigInt k)
I k == 1
R factorial(n)
Line 64:
print("\nMaximum value from the L(100, *) row:")
V maxVal = max((0.<100).map(a -> lah(100, a)))
print(maxVal)</langsyntaxhighlight>
 
{{out}}
Line 87:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000
</pre>
 
=={{header|ABC}}==
<syntaxhighlight lang="abc">HOW TO RETURN fac n:
PUT 1 IN result
FOR i IN {1..n}: PUT result*i IN result
RETURN result
 
HOW TO RETURN n lah k:
SELECT:
n=k: RETURN 1
n=0 OR k=0: RETURN 0
k=1: RETURN fac n
ELSE: RETURN (((fac n)*fac(n-1)) / ((fac k)*fac(k-1)) )/ fac(n-k)
 
HOW TO SHOW LAH TABLE UP TO N nmax:
FOR n IN {0..nmax}:
FOR k IN {0..n}:
WRITE (n lah k)>>11
WRITE /
 
HOW TO RETURN max.lah.number n:
PUT 0 IN max
FOR k IN {0..n}:
PUT n lah k IN cur
IF cur>max: PUT cur IN max
RETURN max
 
 
SHOW LAH TABLE UP TO N 12
WRITE /
WRITE "Maximum value where n=100:"/
WRITE max.lah.number 100/</syntaxhighlight>
{{out}}
<pre> 0 1
0 2 1
0 6 6 1
0 24 36 12 1
0 120 240 120 20 1
0 720 1800 1200 300 30 1
0 5040 15120 12600 4200 630 42 1
0 40320 141120 141120 58800 11760 1176 56 1
0 362880 1451520 1693440 846720 211680 28224 2016 72 1
0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
 
Maximum value where n=100:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
{{Trans|ALGOL W}}
Uses Algol 68G's LONG LONG INT which has programmer-specifiable precision, so can find Lah numbers with n = 100 and need not use the scaling "trick" used by the Algol W sample.
<syntaxhighlight lang="algol68">BEGIN # calculate Lah numbers upto L( 12, 12 ) #
PR precision 400 PR # set the precision for LONG LONG INT #
# returns Lah Number L( n, k ), f must be a table of factorials to at least n #
PROC lah = ( INT n, k, []LONG LONG INT f )LONG LONG INT:
IF n = k THEN 1
ELIF n = 0 OR k = 0 THEN 0
ELIF k = 1 THEN f[ n ]
ELIF k > n THEN 0
ELSE
# general case: ( n! * ( n - 1 )! ) / ( k! * ( k - 1 )! ) / ( n - k )! #
# we re-arrange the above to: #
# ( n! / k! ) -- t1 #
# * ( ( n - 1 )! / ( k - 1 )! ) -- t2 #
# / ( n - k )! #
LONG LONG INT t1 = f[ n ] OVER f[ k ];
LONG LONG INT t2 = f[ n - 1 ] OVER f[ k - 1 ];
( t1 * t2 ) OVER f[ n - k ]
FI # lah # ;
INT max n = 100; # max n for Lah Numbers #
INT max display = 12; # max n to display L( n, k ) values #
# table of factorials up to max n #
[ 1 : max n ]LONG LONG INT factorial;
BEGIN
LONG LONG INT f := 1;
FOR i TO UPB factorial DO factorial[ i ] := f *:= i OD
END;
# show the Lah numbers #
print( ( "Unsigned Lah numbers", newline ) );
print( ( "n/k 0" ) );
FOR i FROM 1 TO max display DO print( ( whole( i, -11 ) ) ) OD;
print( ( newline ) );
FOR n FROM 0 TO max display DO
print( ( whole( n, -2 ) ) );
print( ( whole( lah( n, 0, factorial ), -4 ) ) );
FOR k FROM 1 TO n DO
print( ( whole( lah( n, k, factorial ), -11 ) ) )
OD;
print( ( newline ) )
OD;
# maximum value of a Lah number for n = 100 #
LONG LONG INT max 100 := 0;
FOR k FROM 0 TO 100 DO
LONG LONG INT lah n k = lah( 100, k, factorial );
IF lah n k > max 100 THEN max 100 := lah n k FI
OD;
print( ( "maximum Lah number for n = 100: ", whole( max 100, 0 ), newline ) )
END</syntaxhighlight>
{{out}}
<pre>
Unsigned Lah numbers
n/k 0 1 2 3 4 5 6 7 8 9 10 11 12
0 1
1 0 1
2 0 2 1
3 0 6 6 1
4 0 24 36 12 1
5 0 120 240 120 20 1
6 0 720 1800 1200 300 30 1
7 0 5040 15120 12600 4200 630 42 1
8 0 40320 141120 141120 58800 11760 1176 56 1
9 0 362880 1451520 1693440 846720 211680 28224 2016 72 1
10 0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
11 0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
maximum Lah number for n = 100: 44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
=={{header|ALGOL W}}==
Line 92 ⟶ 210:
<br>
As L(12,2), L(12,3) and L(12,4) are too large for signed 32 bit integers, this sample scales the result by an appropriate power of 10 to enable the table to be printed up to L(12,12). Luckily, the problematic L(12,k) values all have at least 2 trailing zeros.
<langsyntaxhighlight lang="algolw">begin % calculate Lah numbers upto L( 12, 12 ) %
% sets lahNumber to L( n, k ), lahScale is returned as the power of 10 %
% lahNumber should be multiplied by %
Line 146 ⟶ 264:
end for_k
end for_n
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 165 ⟶ 283:
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">factorial: function [n]-> product 1..n
 
lah: function [n,k][
if k=1 -> return factorial n
if k=n -> return 1
if k>n -> return 0
if or? k<1 n<1 -> return 0
return (((factorial n)*factorial n-1) / ((factorial k) * factorial k-1)) / factorial n-k
]
 
print @["n/k"] ++ map to [:string] 1..12 's -> pad s 10
print repeat "-" 136
loop 1..12 'x [
print @[pad to :string x 3] ++ map to [:string] map 1..12 'y -> lah x y 's -> pad s 10
]</syntaxhighlight>
 
{{out}}
 
<pre>n/k 1 2 3 4 5 6 7 8 9 10 11 12
----------------------------------------------------------------------------------------------------------------------------------------
1 1 0 0 0 0 0 0 0 0 0 0 0
2 2 1 0 0 0 0 0 0 0 0 0 0
3 6 6 1 0 0 0 0 0 0 0 0 0
4 24 36 12 1 0 0 0 0 0 0 0 0
5 120 240 120 20 1 0 0 0 0 0 0 0
6 720 1800 1200 300 30 1 0 0 0 0 0 0
7 5040 15120 12600 4200 630 42 1 0 0 0 0 0
8 40320 141120 141120 58800 11760 1176 56 1 0 0 0 0
9 362880 1451520 1693440 846720 211680 28224 2016 72 1 0 0 0
10 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1 0 0
11 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1 0
12 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f LAH_NUMBERS.AWK
# converted from C
Line 199 ⟶ 352:
return (factorial(n) * factorial(n-1)) / (factorial(k) * factorial(k-1)) / factorial(n-k)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 218 ⟶ 371:
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
</pre>
 
=={{header|BQN}}==
<code>F</code> is a function that computes the factorial of a number. It returns 0 for negative numbers.
 
<code>Lah</code> computes the lah function, called as <code>n Lah k</code>.
 
The last line builds a table where the rows represent <code>n</code> and columns represent <code>k</code>.
<syntaxhighlight lang="bqn">F ← (≥⟜0)◶⟨0,×´1+↕⟩
Lah ← {
𝕨 𝕊 0: 0;
0 𝕊 𝕩: 0;
𝕨 𝕊 1: F 𝕨;
n 𝕊 k:
(n=k)⊑⟨((n ×○F n-1) ÷ k ×○F k-1) (0=⊢)◶÷‿0 F n-k, 1⟩
}
 
•Show Lah⌜˜↕12</syntaxhighlight><syntaxhighlight lang="text">┌─
╵ 0 0 0 0 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0 0 0
0 2 1 0 0 0 0 0 0 0 0 0
0 6 6 1 0 0 0 0 0 0 0 0
0 24 36 12 1 0 0 0 0 0 0 0
0 120 240 120 20 1 0 0 0 0 0 0
0 720 1800 1200 300 30 1 0 0 0 0 0
0 5040 15120 12600 4200 630 42 1 0 0 0 0
0 40320 141120 141120 58800 11760 1176 56 1 0 0 0
0 362880 1451520 1693440 846720 211680 28224 2016 72 1 0 0
0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1 0
0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
┘</syntaxhighlight>
[https://mlochbaum.github.io/BQN/try.html#code=RiDihpAgKOKJpeKfnDAp4pe24p+oMCzDl8K0MSvihpXin6kKTGFoIOKGkCB7CiAg8J2VqCDwnZWKIDA6IDA7CiAgMCDwnZWKIPCdlak6IDA7CiAg8J2VqCDwnZWKIDE6IEYg8J2VqDsKICBuIPCdlYogazoKICAobj1rKeKKkeKfqCgobiDDl+KXi0Ygbi0xKSDDtyBrIMOX4peLRiBrLTEpICgwPeKKoinil7bDt+KAvzAgRiBuLWssIDHin6kKfQoK4oCiU2hvdyBMYWjijJzLnOKGlTEy Try It!]
 
=={{header|C}}==
{{trans|D}}
<langsyntaxhighlight lang="c">#include <stdint.h>
#include <stdio.h>
 
Line 258 ⟶ 442:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 278 ⟶ 462:
=={{header|C sharp|C#}}==
{{trans|D}}
<langsyntaxhighlight lang="csharp">using System;
using System.Linq;
using System.Numerics;
Line 321 ⟶ 505:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>0 1
Line 342 ⟶ 526:
=={{header|C++}}==
{{libheader|GMP}}
<langsyntaxhighlight lang="cpp">// Reference: https://en.wikipedia.org/wiki/Lah_number#Identities_and_relations
 
#include <algorithm>
Line 395 ⟶ 579:
std::cout << max << '\n';
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 419 ⟶ 603:
=={{header|D}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="d">import std.algorithm : map;
import std.bigint;
import std.range;
Line 473 ⟶ 657:
auto lambda = (int a) => lah(BigInt(100), BigInt(a));
writeln(iota(0, 100).map!lambda.max);
}</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 493 ⟶ 677:
Maximum value from the L(100, *) row:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
=={{header|Dyalect}}==
 
<syntaxhighlight lang="dyalect">func fact(n) =>
n is 0 ? 1 : (n^-1..<0).Fold(1, (acc, val) => acc * val)
 
func lah(n, k) {
return fact(n) when k is 1
return 1 when k == n
return 0 when k > n || k < 1 || n < 1
(fact(n) * fact(n - 1)) / (fact(k) * fact(k - 1)) / fact(n - k)
}
 
print("Unsigned Lah numbers: L(n, k):");
print("n/k ", terminator: "");
(0..12).ForEach(i => i >> "{0,10} ".Format >> print(terminator: ""))
print("")
(0..12).ForEach(row => {
row >> "{0,-3}".Format >> print(terminator: "")
(0..row).ForEach(i => lah(row, i) >> "{0,11}".Format >> print(terminator: ""))
print("")
})</syntaxhighlight>
 
{{out}}
 
<pre>Unsigned Lah numbers: L(n, k):
n/k 0 1 2 3 4 5 6 7 8 9 10 11 12
0 1
1 0 1
2 0 2 1
3 0 6 6 1
4 0 24 36 12 1
5 0 120 240 120 20 1
6 0 720 1800 1200 300 30 1
7 0 5040 15120 12600 4200 630 42 1
8 0 40320 141120 141120 58800 11760 1176 56 1
9 0 362880 1451520 1693440 846720 211680 28224 2016 72 1
10 0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
11 0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1</pre>
 
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
func fac n .
r = 1
for i = 2 to n
r *= i
.
return r
.
print 0
print "0 1"
for n = 2 to 12
write 0 & " " & fac n & " "
for k = 2 to n - 1
write fac n * fac (n - 1) / (fac k * fac (k - 1)) / fac (n - k) & " "
.
print 1 & " "
.
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<syntaxhighlight lang="fsharp">
// Lah numbers. Nigel Galloway: January 3rd., 2023
let fact(n:int)=let rec fact=function n when n=0I->1I |n->n*fact(n-1I) in fact(bigint n)
let rec lah=function (_,0)|(0,_)->0I |(n,1)->fact n |(n,g) when n=g->1I |(n,g)->((fact n)*(fact(n-1)))/((fact g)*(fact(g-1)))/(fact(n-g))
for n in {0..12} do (for g in {0..n} do printf $"%A{lah(n,g)} "); printfn ""
printfn $"\n\n%A{seq{for n in 1..99->lah(100,n)}|>Seq.max}"
</syntaxhighlight>
{{out}}
<pre>
0
0 1
0 2 1
0 6 6 1
0 24 36 12 1
0 120 240 120 20 1
0 720 1800 1200 300 30 1
0 5040 15120 12600 4200 630 42 1
0 40320 141120 141120 58800 11760 1176 56 1
0 362880 1451520 1693440 846720 211680 28224 2016 72 1
0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
 
 
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000
</pre>
 
=={{header|Factor}}==
{{works with|Factor|0.99 development version 2019-07-10}}
<langsyntaxhighlight lang="factor">USING: combinators combinators.short-circuit formatting infix io
kernel locals math math.factorials math.ranges prettyprint
sequences ;
Line 527 ⟶ 799:
 
"Maximum value from the 100 _ lah row:" print
100 [0,b] [ 100 swap lah ] map supremum .</langsyntaxhighlight>
{{out}}
<pre>
Line 551 ⟶ 823:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight FreeBASIClang="freebasic">function factorial( n as uinteger ) as ulongint
if n = 0 then return 1
return n*factorial(n-1)
Line 585 ⟶ 857:
next k
print outstr
next n</langsyntaxhighlight>
{{out}}
<pre>
Line 609 ⟶ 881:
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Lah_numbers}}
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation &mdash;i.e. XML, JSON&mdash; they are intended for storage and transfer purposes more than visualization and edition.
 
'''Solution'''
Programs in Fōrmulæ are created/edited online in its [https://formulae.org website], However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.
 
The following function reduces to the Lah number n, k
In '''[https://formulae.org/?example=Lah_numbers this]''' page you can see the program(s) related to this task and their results.
 
If you want a unsigned Lah number, use 1 as factor. If you want a signed Lah number, use -1 as factor.
 
[[File:Fōrmulæ - Lah numbers 01.png]]
 
'''Case 1. Using the routine, generate and show a table showing the signed Lah numbers, L(n, k), up to L(12, 12)'''
 
[[File:Fōrmulæ - Lah numbers 02.png]]
 
[[File:Fōrmulæ - Lah numbers 03.png]]
 
'''Case 2. Using the routine, generate and show a table showing the unsigned Lah numbers, L(n, k), up to L(12, 12)'''
 
[[File:Fōrmulæ - Lah numbers 04.png]]
 
[[File:Fōrmulæ - Lah numbers 05.png]]
 
'''Case 3. If your language supports large integers, find and show the maximum value of unsigned L(n, k) where n ≤ 100'''
 
[[File:Fōrmulæ - Lah numbers 06.png]]
 
[[File:Fōrmulæ - Lah numbers 07.png]]
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 677 ⟶ 971:
fmt.Println(max)
fmt.Printf("which has %d digits.\n", len(max.String()))
}</langsyntaxhighlight>
 
{{out}}
Line 704 ⟶ 998:
=={{header|Haskell}}==
{{trans|Python}}
<langsyntaxhighlight lang="haskell">import Text.Printf (printf)
import Control.Monad (when)
Line 733 ⟶ 1,027:
printf "\nMaximum value from the L(100, *) row:\n%d\n"
(maximum $ lah 100 <$> ([0..100] :: [Integer]))
where zeroToTwelve = [0..12]</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 755 ⟶ 1,049:
 
=={{header|J}}==
<syntaxhighlight lang="j">
<lang J>
NB. use: k lah n
lah=: ! :(!&<: * %&!~)&x: NB. `%~' is shorter than `*inv'
Line 773 ⟶ 1,067:
extend_precision =: x: Monad
wordy_lah =: ((combinations but_1st decrement) times (into but_1st factorial))but_1st extend_precision Dyad
</syntaxhighlight>
</lang>
<pre>
lah&>~table~>:i.12
Line 808 ⟶ 1,102:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">
import java.math.BigInteger;
import java.util.HashMap;
Line 866 ⟶ 1,160:
 
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 889 ⟶ 1,183:
</pre>
 
=={{header|jq}}==
 
The table can be produced by either jq or gojq (the Go implementation of jq),
but gojq is required to produce the precise maximum value.
 
<syntaxhighlight lang="jq">## Generic functions
 
def factorial: reduce range(2;.+1) as $i (1; . * $i);
 
# nCk assuming n >= k
def binomial($n; $k):
if $k > $n / 2 then binomial($n; $n-$k)
else (reduce range($k+1; $n+1) as $i (1; . * $i)) as $numerator
| reduce range(1;1+$n-$k) as $i ($numerator; . / $i)
end;
 
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;
 
def max(s): reduce s as $x (-infinite; if $x > . then $x else . end);
 
def lah($n; $k; $signed):
if $n == $k then 1
elif $n == 0 or $k == 0 or $k > $n then 0
elif $k == 1 then $n|factorial
else
(binomial($n; $k) * binomial($n - 1; $k - 1) * (($n - $k)|factorial)) as $unsignedvalue
| if $signed and ($n % 1 == 1)
then -$unsignedvalue
else $unsignedvalue
end
end;
 
def lah($n; $k): lah($n;$k;false);
</syntaxhighlight>
'''The task'''
<syntaxhighlight lang="jq">def printlahtable($kmax):
def pad: lpad(12);
reduce range(0;$kmax+1) as $k ("n/k"|lpad(4); . + ($k|pad)),
(range(0; $kmax+1) as $n
| reduce range(0;$n+1) as $k ($n|lpad(4);
. + (lah($n; $k) | pad)) ) ;
 
def task:
"Unsigned Lah numbers up to n==12",
printlahtable(12), "",
"The maxiumum of lah(100, _) is: \(max( lah(100; range(0;101)) ))"
;
 
task
</syntaxhighlight>
{{out}}
<pre>
Unsigned Lah numbers up to n==12
n/k 0 1 2 3 4 5 6 7 8 9 10 11 12
0 1
1 0 1
2 0 2 1
3 0 6 6 1
4 0 24 36 12 1
5 0 120 240 120 20 1
6 0 720 1800 1200 300 30 1
7 0 5040 15120 12600 4200 630 42 1
8 0 40320 141120 141120 58800 11760 1176 56 1
9 0 362880 1451520 1693440 846720 211680 28224 2016 72 1
10 0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
11 0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
 
The maxiumum of lah(100, _) is: 44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000
</pre>
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Combinatorics
 
function lah(n::Integer, k::Integer, signed=false)
Line 922 ⟶ 1,287:
 
println("\nThe maxiumum of lah(100, _) is: ", maximum(k -> lah(BigInt(100), BigInt(k)), 1:100))
</langsyntaxhighlight>{{out}}
<pre>
0 1 2 3 4 5 6 7 8 9 10 11 12
Line 944 ⟶ 1,309:
=={{header|Kotlin}}==
{{trans|Perl}}
<langsyntaxhighlight lang="scala">import java.math.BigInteger
 
fun factorial(n: BigInteger): BigInteger {
Line 983 ⟶ 1,348:
println("\nMaximum value from the L(100, *) row:")
println((0..100).map { lah(BigInteger.valueOf(100.toLong()), BigInteger.valueOf(it.toLong())) }.max())
}</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,005 ⟶ 1,370:
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">ClearAll[Lah]
Lah[n_?Positive, 0] := 0
Lah[0, k_?Positive] := 0
Line 1,012 ⟶ 1,377:
Lah[n_, k_] := (-1)^n (n! ((n - 1)!))/((k! ((k - 1)!)) ((n - k)!))
Table[Lah[i, j], {i, 0, 12}, {j, 0, 12}] // Grid
Max[Lah[100, Range[0, 100]]]</langsyntaxhighlight>
{{out}}
<pre>1 0 0 0 0 0 0 0 0 0 0 0 0
Line 1,030 ⟶ 1,395:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
/* Function that returns a row of Lah triangle */
lah(n):=append([0],makelist((binomial(n,k)*(n-1)!)/(k-1)!,k,1,n))$
 
/* Test cases */
block(makelist(lah(i),i,0,12),table_form(%%));
</syntaxhighlight>
[[File:LahTriangleMaxima.png|thumb|center]]
<syntaxhighlight lang="maxima">
lmax(lah(100));
</syntaxhighlight>
{{out}}
<pre>
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000
</pre>
 
=={{header|Nim}}==
{{trans|Julia}}
{{libheader|bignum}}
<langsyntaxhighlight Nimlang="nim">import math, strutils
import bignum
 
Line 1,062 ⟶ 1,443:
let val = lah(n, k)
if val > maxval: maxval = val
echo "\nThe maximum value of lah(100, k) is ", maxval</langsyntaxhighlight>
 
{{out}}
Line 1,085 ⟶ 1,466:
{{libheader|ntheory}}
{{trans|Raku}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,113 ⟶ 1,494:
 
say "\nMaximum value from the L(100, *) row:";
say max map { Lah(100,$_) } 0..100;</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,137 ⟶ 1,518:
{{libheader|Phix/mpfr}}
{{trans|Go}}
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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>
Line 1,180 ⟶ 1,561:
<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 l(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>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,204 ⟶ 1,585:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de fact (N)
(if (=0 N)
1
Line 1,228 ⟶ 1,609:
(prinl "Maximum value from the L(100, *) row:")
(maxi '((N) (lah 100 N)) (range 0 100))
(prinl @@)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,251 ⟶ 1,632:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<langsyntaxhighlight lang="prolog">% Reference: https://en.wikipedia.org/wiki/Lah_number#Identities_and_relations
 
:- dynamic unsigned_lah_number_cache/3.
Line 1,294 ⟶ 1,675:
writeln('Maximum value of L(n,k) where n = 100:'),
max_unsigned_lah_number(100, M),
writeln(M).</langsyntaxhighlight>
 
{{out}}
Line 1,316 ⟶ 1,697:
 
=={{header|Python}}==
<syntaxhighlight lang="python">from math import (comb,
<lang python>def factorial(n):
if n == 0: factorial)
 
return 1
res = 1
while n > 0:
res *= n
n -= 1
return res
 
def lah(n, k):
if k == 1:
return factorial(n)
Line 1,334 ⟶ 1,710:
if k < 1 or n < 1:
return 0
return (factorialcomb(n, k) * factorial(n - 1)) / (factorial(k) */ factorial(k - 1)) / factorial(n - k)
 
 
def main():
print ("Unsigned Lah numbers: L(n, k):")
print ("n/k ", end='\t')
for i in xrangerange(13):
print ("%11d" % i, end='\t')
print()
for row in xrangerange(13):
print ("%-4d" % row, end='\t')
for i in xrangerange(row + 1):
l = lah(row, i)
print ("%11d" % l, end='\t')
print()
print ("\nMaximum value from the L(100, *) row:")
maxValmax_val = max([lah(100, a) for a in xrangerange(100)])
print maxVal(max_val)
 
 
if __name__ == '__main__':
main()</lang>
main()</syntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,375 ⟶ 1,754:
=={{header|Quackery}}==
 
<langsyntaxhighlight Quackerylang="quackery"> [ table ] is ! ( n --> n )
1
101 times
Line 1,420 ⟶ 1,799:
[ 100 i^ lah
2dup < iff nip else drop ]
echo</langsyntaxhighlight>
 
{{out}}
Line 1,441 ⟶ 1,820:
 
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
 
=={{header|R}}==
<syntaxhighlight lang="r">Lah_numbers <- function(n, k, type = "unsigned") {
if (n == k)
return(1)
if (n == 0 | k == 0)
return(0)
if (k == 1)
return(factorial(n))
if (k > n)
return(NA)
if (type == "unsigned")
return((factorial(n) * factorial(n - 1)) / (factorial(k) * factorial(k - 1)) / factorial(n - k))
if (type == "signed")
return(-1 ** n * (factorial(n) * factorial(n - 1)) / (factorial(k) * factorial(k - 1)) / factorial(n - k))
}
 
#demo
Table <- matrix(0 , 13, 13, dimnames = list(0:12, 0:12))
 
for (n in 0:12) {
for (k in 0:12) {
Table[n + 1, k + 1] <- Lah_numbers(n, k, type = "unsigned")
}
}
 
Table
</syntaxhighlight>
{{out}}
<pre>
0 1 2 3 4 5 6 7 8 9 10 11 12
0 1 0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 NA NA NA NA NA NA NA NA NA NA NA
2 0 2 1 NA NA NA NA NA NA NA NA NA NA
3 0 6 6 1 NA NA NA NA NA NA NA NA NA
4 0 24 36 12 1 NA NA NA NA NA NA NA NA
5 0 120 240 120 20 1 NA NA NA NA NA NA NA
6 0 720 1800 1200 300 30 1 NA NA NA NA NA NA
7 0 5040 15120 12600 4200 630 42 1 NA NA NA NA NA
8 0 40320 141120 141120 58800 11760 1176 56 1 NA NA NA NA
9 0 362880 1451520 1693440 846720 211680 28224 2016 72 1 NA NA NA
10 0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1 NA NA
11 0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1 NA
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1</pre>
 
=={{header|Raku}}==
Line 1,446 ⟶ 1,877:
{{works with|Rakudo|2019.07.1}}
 
<syntaxhighlight lang="raku" perl6line>constant @factorial = 1, |[\*] 1..*;
 
sub Lah (Int \n, Int \k) {
Line 1,469 ⟶ 1,900:
 
say "\nMaximum value from the L(100, *) row:";
say (^100).map( { Lah 100, $_ } ).max;</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,494 ⟶ 1,925:
 
Also, code was added to use memoization of the factorial calculations.
<langsyntaxhighlight lang="rexx">/*REXX pgm computes & display (unsigned) Stirling numbers of the 3rd kind (Lah numbers).*/
parse arg lim . /*obtain optional argument from the CL.*/
if lim=='' | lim=="," then lim= 12 /*Not specified? Then use the default.*/
Line 1,534 ⟶ 1,965:
/*──────────────────────────────────────────────────────────────────────────────────────*/
!: parse arg z; if !.z\==. then return !.z; !=1; do f=2 to z; !=!*f; end; !.z=!; return !
maxer: max#.k= max(max#.k, @.n.k); max#.b= max(max#.b, @.n.k); return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre>
Line 1,556 ⟶ 1,987:
The maximum value (which has 164 decimal digits):
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000
</pre>
 
=={{header|RPL}}==
'''Using local variables'''
« → n k
« '''CASE'''
n k == '''THEN''' 1 '''END'''
n k * NOT '''THEN''' 0 '''END'''
k 1 == '''THEN''' n FACT '''END'''
n 1 - k - 1 COMB n FACT * k FACT /
'''END'''
» » '<span style="color:blue">ULAH</span>' STO
'''Using the stack'''
« '''CASE'''
DUP2 == '''THEN''' DROP2 1 '''END'''
DUP2 * NOT '''THEN''' * '''END'''
DUP 1 == '''THEN''' DROP FACT '''END'''
DUP2 1 - SWAP 1 - SWAP COMB ROT FACT * SWAP FACT /
'''END'''
» '<span style="color:blue">ULAH</span>' STO
 
« { 12 12 } 0 CON
1 12 '''FOR''' n
1 n '''FOR''' k
n k 2 →LIST n k <span style="color:blue">ULAH</span> PUT
'''NEXT NEXT'''
» '<span style="color:blue">TASK</span>' STO
{{out}}
<pre>
1: [[ 1 0 0 0 0 0 0 0 0 0 0 0 ]
[ 2 1 0 0 0 0 0 0 0 0 0 0 ]
[ 6 6 1 0 0 0 0 0 0 0 0 0 ]
[ 24 36 12 1 0 0 0 0 0 0 0 0 ]
[ 120 240 120 20 1 0 0 0 0 0 0 0 ]
[ 720 1800 1200 300 30 1 0 0 0 0 0 0 ]
[ 5040 15120 12600 4200 630 42 1 0 0 0 0 0 ]
[ 40320 141120 141120 58800 11760 1176 56 1 0 0 0 0 ]
[ 362880 1451520 1693440 846720 211680 28224 2016 72 1 0 0 0 ]
[ 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1 0 0 ]
[ 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1 0 ]
[ 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1 ]]
</pre>
 
=={{header|Ruby}}==
Works with Ruby 3.0 (end-less method; end-less and begin-less range).
<langsyntaxhighlight lang="ruby">def fact(n) = n.zero? ? 1 : 1.upto(n).inject(&:*)
 
def lah(n, k)
Line 1,582 ⟶ 2,054:
puts "\nMaximum value from the L(100, *) row:";
puts (1..100).map{|a| lah(100,a)}.max
</syntaxhighlight>
</lang>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,603 ⟶ 2,075:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000
</pre>
 
=={{header|Scheme}}==
{{works with|Chez Scheme}}
<syntaxhighlight lang="scheme">; Compute the Unsigned Lah number L(n, k).
(define lah
(lambda (n k)
(/ (/ (* (fact n) (fact (1- n))) (* (fact k) (fact (1- k)))) (fact (- n k)))))
 
; Procedure to compute factorial.
(define fact
(lambda (n)
(if (<= n 0)
1
(* n (fact (1- n))))))
 
; Generate a table of the Unsigned Lah numbers L(n, k) up to L(12, 12).
(printf "The Unsigned Lah numbers L(n, k) up to L(12, 12):~%")
(printf "n\\k~10d" 1)
(do ((k 2 (1+ k)))
((> k 12))
(printf " ~10d" k))
(newline)
(do ((n 1 (1+ n)))
((> n 12))
(printf "~2d" n)
(do ((k 1 (1+ k)))
((> k n))
(printf " ~10d" (lah n k)))
(newline))
 
; Find the maximum value of L(n, k) where n = 100.
(printf "~%The maximum value of L(n, k) where n = 100:~%")
(let ((max 0))
(do ((k 1 (1+ k)))
((> k 100))
(let ((val (lah 100 k)))
(when (> val max) (set! max val))))
(printf "~d~%" max))</syntaxhighlight>
{{out}}
<pre>The Unsigned Lah numbers L(n, k) up to L(12, 12):
n\k 1 2 3 4 5 6 7 8 9 10 11 12
1 1
2 2 1
3 6 6 1
4 24 36 12 1
5 120 240 120 20 1
6 720 1800 1200 300 30 1
7 5040 15120 12600 4200 630 42 1
8 40320 141120 141120 58800 11760 1176 56 1
9 362880 1451520 1693440 846720 211680 28224 2016 72 1
10 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
11 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
12 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
 
The maximum value of L(n, k) where n = 100:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
=={{header|SETL}}==
<syntaxhighlight lang="setl">program lah_numbers;
loop for n in [0..12] do
loop for k in [0..n] do
nprint(lpad(str lah(n,k), 11));
end loop;
print;
end loop;
 
print("Maximum value for lah(100,k):");
print(max/[lah(100,k) : k in [1..100]]);
 
op fac(n);
return */{1..n};
end op;
 
proc lah(n,k);
case of
(n=k): return 1;
(n=0 or k=0): return 0;
(k=1): return fac n;
else return (fac n*fac (n-1)) div
(fac k*fac (k-1)) div
fac (n-k);
end case;
end proc;
end program;</syntaxhighlight>
{{out}}
<pre> 1
0 1
0 2 1
0 6 6 1
0 24 36 12 1
0 120 240 120 20 1
0 720 1800 1200 300 30 1
0 5040 15120 12600 4200 630 42 1
0 40320 141120 141120 58800 11760 1176 56 1
0 362880 1451520 1693440 846720 211680 28224 2016 72 1
0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
Maximum value for lah(100,k):
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func lah(n, k) {
stirling3(n, k)
#binomial(n-1, k-1) * n!/k! # alternative formula
Line 1,626 ⟶ 2,198:
say "\nMaximum value from the L(#{n}, *) row:"
say { lah(n, _) }.map(^n).max
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,653 ⟶ 2,225:
{{trans|Kotlin}}
 
<langsyntaxhighlight lang="swift">import BigInt
import Foundation
 
Line 1,707 ⟶ 2,279:
let maxLah = (0...100).map({ lah(n: BigInt(100), k: BigInt($0)) }).max()!
 
print("Maximum value from the L(100, *) row: \(maxLah)")</langsyntaxhighlight>
 
{{out}}
Line 1,730 ⟶ 2,302:
 
=={{header|Tcl}}==
<langsyntaxhighlight Tcllang="tcl">proc prod {from to} {
set r 1
if {$from <= $to} {
Line 1,808 ⟶ 2,380:
puts "([string length $maxv] digits, k=$maxk)"
}
main </langsyntaxhighlight>
{{out}}
<pre style="font-size:83%">Unsigned Lah numbers L(n,k):
Line 1,827 ⟶ 2,399:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000
(164 digits, k=10)
</pre>
 
=={{header|Vala}}==
<syntaxhighlight lang="vala">uint64 factorial(uint8 n) {
uint64 res = 1;
if (n == 0) return res;
while (n > 0) res *= n--;
return res;
}
 
uint64 lah(uint8 n, uint8 k) {
if (k == 1) return factorial(n);
if (k == n) return 1;
if (k > n) return 0;
if (k < 1 || n < 1) return 0;
return (factorial(n) * factorial(n - 1)) / (factorial(k) * factorial(k - 1)) / factorial(n - k);
}
 
void main() {
uint8 row, i;
print("Unsigned Lah numbers: L(n, k):\n");
print("n/k ");
for (i = 0; i < 13; i++) {
print("%10d ", i);
}
print("\n");
for (row = 0; row < 13; row++) {
print("%-3d", row);
for (i = 0; i < row + 1; i++) {
uint64 l = lah(row, i);
print("%11lld", l);
}
print("\n");
}
}</syntaxhighlight>
{{out}}
<pre style="font-size:83%">Unsigned Lah numbers: L(n, k):
n/k 0 1 2 3 4 5 6 7 8 9 10 11 12
0 1
1 0 1
2 0 2 1
3 0 6 6 1
4 0 24 36 12 1
5 0 120 240 120 20 1
6 0 720 1800 1200 300 30 1
7 0 5040 15120 12600 4200 630 42 1
8 0 40320 141120 141120 58800 11760 1176 56 1
9 0 362880 1451520 1693440 846720 211680 28224 2016 72 1
10 0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1
11 0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
</pre>
 
=={{header|VBScript}}==
{{trans|Visual Basic .NET}}
<langsyntaxhighlight lang="vb">' Lah numbers - VBScript - 04/02/2021
 
Function F(i,n)
Line 1,883 ⟶ 2,507:
End Sub 'Main
 
Main() </langsyntaxhighlight>
{{out}}
<pre>
Line 1,904 ⟶ 2,528:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<langsyntaxhighlight lang="vbnet">Imports System.Numerics
 
Module Module1
Line 1,960 ⟶ 2,584:
End Sub
 
End Module</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,980 ⟶ 2,604:
Maximum value from the L(100, *) row:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
 
=={{header|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">import math.big
 
fn main() {
limit := 100
last := 12
unsigned := true
mut l := [][]big.Integer{len: limit+1}
for n := 0; n <= limit; n++ {
l[n] = []big.Integer{len: limit+1}
for k := 0; k <= limit; k++ {
l[n][k] = big.zero_int
}
l[n][n]= big.integer_from_int(1)
if n != 1 {
l[n][1]= big.integer_from_int(n).factorial()
}
}
mut t := big.zero_int
for n := 1; n <= limit; n++ {
for k := 1; k <= n; k++ {
t = l[n][1] * l[n-1][1]
t /= l[k][1]
t /= l[k-1][1]
t /= l[n-k][1]
l[n][k] = t
if !unsigned && (n%2 == 1) {
l[n][k] = l[n][k].neg()
}
}
}
println("Unsigned Lah numbers: l(n, k):")
print("n/k")
for i := 0; i <= last; i++ {
print("${i:10} ")
}
print("\n--")
for i := 0; i <= last; i++ {
print("-----------")
}
println('')
for n := 0; n <= last; n++ {
print("${n:2} ")
for k := 0; k <= n; k++ {
print("${l[n][k]:10} ")
}
println('')
}
println("\nMaximum value from the l(100, *) row:")
mut max := l[limit][0]
for k := 1; k <= limit; k++ {
if l[limit][k] > max {
max = l[limit][k]
}
}
println(max)
println("which has ${max.str().len} digits.")
}
</syntaxhighlight>
 
{{out}}
<pre>Same as Go output</pre>
 
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Fmt
 
var fact = Fn.new { |n|
Line 2,002 ⟶ 2,690:
System.print("Unsigned Lah numbers: l(n, k):")
System.write("n/k")
for (i in 0..12) SystemFmt.write("%(Fmt.d(10$10d ", i)) ")
System.print("\n" + "-" * 145)
for (n in 0..12) {
SystemFmt.write("%(Fmt.d(2$2d ", n)) ")
for (k in 0..n) SystemFmt.write("%(Fmt.d(10$10d ", lah.call(n, k))) ")
System.print()
}</langsyntaxhighlight>
 
{{out}}
Line 2,030 ⟶ 2,718:
</pre>
 
=={{header|ValaXPL0}}==
{{trans|C}}
<lang Vala>uint64 factorial(uint8 n) {
<syntaxhighlight lang "XPL0">func real Factorial(N);
uint64 res = 1;
real N, Res;
if (n == 0) return res;
[Res:= 1.;
while (n > 0) res *= n--;
if N = 0. then return resRes;
while N > 0. do [Res:= Res*N; N:= N-1.];
}
return Res;
];
 
func real Lah(N, K);
uint64 lah(uint8 n, uint8 k) {
real N, K;
if (k == 1) return factorial(n);
[if (kK == n)1. then return 1Factorial(N);
if K if= (kN > n) then return 01.;
if (kK <> 1N || n < 1)then return 0.;
if K < 1. or N < 1. then return 0.;
return (factorial(n) * factorial(n - 1)) / (factorial(k) * factorial(k - 1)) / factorial(n - k);
return (Factorial(N) * Factorial(N-1.)) / (Factorial(K) * Factorial(K-1.)) /
}
Factorial(N-K);
];
 
int Row, I;
void main() {
[Text(0, "Unsigned Lah numbers: L(N,K):"); CrLf(0);
uint8 row, i;
Text(0, "N/K");
Format(11, 0);
print("Unsigned Lah numbers: L(n, k):\n");
for I:= 0 to 12 do RlOut(0, float(I));
print("n/k ");
CrLf(0);
for (i = 0; i < 13; i++) {
for Row:= 0 to 12 do
print("%10d ", i);
[Format(3, 0); RlOut(0, float(Row));
}
for I:= 0 to Row do
print("\n");
[Format(11, 0); RlOut(0, Lah(float(Row), float(I)))];
for (row = 0; row < 13; row++) {
printCrLf("%-3d", row0);
]
for (i = 0; i < row + 1; i++) {
]</syntaxhighlight>
uint64 l = lah(row, i);
print("%11lld", l);
}
print("\n");
}
}</lang>
{{out}}
<pre style="font-size:8366%">Unsigned Lah numbers: L(n, k):
Unsigned Lah numbers: L(N,K):
n/k 0 1 2 3 4 5 6 7 8 9 10 11 12
N/K 0 1 2 3 4 5 6 7 8 9 10 11 12
0 1
1 0 1
2 1 0 2 1
3 2 0 6 62 1
4 3 0 24 6 36 126 1
5 4 0 120 24 240 36 120 2012 1
6 5 0 720120 1800 240 1200 120 300 3020 1
7 6 0 5040 720 15120 1800 12600 1200 4200 300 630 4230 1
8 7 0 40320 5040 141120 15120 141120 12600 58800 4200 11760 630 1176 5642 1
9 8 0 362880 40320 1451520 141120 1693440 141120 846720 58800 211680 11760 28224 1176 2016 7256 1
10 9 0 3628800 362880 16329600 1451520 21772800 1693440 12700800 3810240846720 635040211680 6048028224 32402016 9072 1
11 10 0 39916800 3628800 16329600 19958400021772800 299376000 12700800 199584000 698544003810240 13970880 635040 1663200 60480 118800 3240 4950 11090 1
12 11 0 479001600 263450880039916800 199584000 299376000 4390848000 3293136000199584000 1317254400 30735936069854400 4390848013970880 39204001663200 217800118800 72604950 132110 1
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
</pre>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">fcn lah(n,k,fact=fcn(n){ [1..n].reduce('*,1) }){
if(n==k) return(1);
if(k==1) return(fact(n));
if(n<1 or k<1) return(0);
(fact(n)*fact(n - 1)) /(fact(k)*fact(k - 1)) /fact(n - k)
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">// calculate entire table (quick), find max, find num digits in max
N,mx := 12, [1..N].apply(fcn(n){ [1..n].apply(lah.fp(n)) }).flatten() : (0).max(_);
fmt:="%%%dd".fmt("%d".fmt(mx.numDigits + 1)).fmt; // "%9d".fmt
Line 2,096 ⟶ 2,784:
foreach row in ([0..N]){
println("%3d".fmt(row), [0..row].pump(String, lah.fp(row), fmt));
}</langsyntaxhighlight>
{{out}}
<pre style="font-size:83%">
Line 2,116 ⟶ 2,804:
</pre>
{{libheader|GMP}} GNU Multiple Precision Arithmetic Library
<langsyntaxhighlight lang="zkl">var [const] BI=Import("zklBigNum"); // libGMP
N=100;
L100:=[1..N].apply(lah.fpM("101",BI(N),fcn(n){ BI(n).factorial() }))
.reduce(fcn(m,n){ m.max(n) });
println("Maximum value from the L(%d, *) row (%d digits):".fmt(N,L100.numDigits));
println(L100);</langsyntaxhighlight>
{{out}}
<pre style="font-size:83%">
Aerobar
1,151

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/292716...362476"