Lah numbers: Difference between revisions
added RPL
No edit summary |
(added RPL) |
||
(30 intermediate revisions by 19 users not shown) | |||
Line 40:
{{trans|Python}}
<
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)</
{{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.
<
% 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.</
{{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">
# 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>
{{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}}
<
#include <stdio.h>
Line 258 ⟶ 442:
return 0;
}</
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 278 ⟶ 462:
=={{header|C sharp|C#}}==
{{trans|D}}
<
using System.Linq;
using System.Numerics;
Line 321 ⟶ 505:
}
}
}</
{{out}}
<pre>0 1
Line 342 ⟶ 526:
=={{header|C++}}==
{{libheader|GMP}}
<
#include <algorithm>
Line 395 ⟶ 579:
std::cout << max << '\n';
return 0;
}</
{{out}}
Line 419 ⟶ 603:
=={{header|D}}==
{{trans|Kotlin}}
<
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);
}</
{{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}}
<
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 .</
{{out}}
<pre>
Line 551 ⟶ 823:
=={{header|FreeBASIC}}==
<
if n = 0 then return 1
return n*factorial(n-1)
Line 585 ⟶ 857:
next k
print outstr
next n</
{{out}}
<pre>
Line 609 ⟶ 881:
=={{header|Fōrmulæ}}==
'''Solution'''
The following function reduces to the Lah number n, k
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}}==
<
import (
Line 677 ⟶ 971:
fmt.Println(max)
fmt.Printf("which has %d digits.\n", len(max.String()))
}</
{{out}}
Line 704 ⟶ 998:
=={{header|Haskell}}==
{{trans|Python}}
<
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]</
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 755 ⟶ 1,049:
=={{header|J}}==
<syntaxhighlight 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>
<pre>
lah&>~table~>:i.12
Line 808 ⟶ 1,102:
=={{header|Java}}==
<
import java.math.BigInteger;
import java.util.HashMap;
Line 866 ⟶ 1,160:
}
</syntaxhighlight>
{{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}}==
<
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))
</
<pre>
0 1 2 3 4 5 6 7 8 9 10 11 12
Line 944 ⟶ 1,309:
=={{header|Kotlin}}==
{{trans|Perl}}
<
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())
}</
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,005 ⟶ 1,370:
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
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]]]</
{{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}}
<
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</
{{out}}
Line 1,085 ⟶ 1,466:
{{libheader|ntheory}}
{{trans|Raku}}
<
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;</
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,137 ⟶ 1,518:
{{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>
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>
<!--</
{{out}}
<pre>
Line 1,204 ⟶ 1,585:
=={{header|PicoLisp}}==
<
(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 @@)</
{{out}}
<pre>
Line 1,251 ⟶ 1,632:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<
:- 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).</
{{out}}
Line 1,316 ⟶ 1,697:
=={{header|Python}}==
<syntaxhighlight lang="python">from math import (comb,
def lah(n, k):
if k == 1:
return factorial(n)
Line 1,334 ⟶ 1,710:
if k < 1 or n < 1:
return 0
return
def main():
print
print
for i in
print
print()
for row in
print
for i in
l = lah(row, i)
print
print()
print
print
if __name__ == '__main__':
main()</syntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,372 ⟶ 1,751:
Maximum value from the L(100, *) row:
44519005448993144810881324947684737529186447692709328597242209638906324913313742508392928375354932241404408343800007105650554669129521241784320000000000000000000000</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ table ] is ! ( n --> n )
1
101 times
[ dup ' ! put
i^ 1+ * ]
drop
[ 2dup = iff [ 2drop 1 ] done
2dup * 0 = iff * done
dup 1 = iff [ drop ! ] done
2dup - ! unrot
dup !
swap 1 - ! *
swap dup !
swap 1 - ! *
swap /
swap / ] is lah ( n --> n )
[ dip number$
over size -
space swap of
swap join echo$ ] is justify ( n n --> )
[ table ] is colwidth ( n --> n )
13 times
[ 12 i^ lah number$
size 2 + ' colwidth put ]
say " k| "
13 times
[ i^ dup colwidth justify ] cr
say " n |"
char - 115 of echo$ cr
13 times
[ i^ dup
dup 2 justify say " | "
1+ times
[ dup i^ lah
i^ colwidth justify ]
drop cr ]
cr
0
101 times
[ 100 i^ lah
2dup < iff nip else drop ]
echo</syntaxhighlight>
{{out}}
<pre> k| 0 1 2 3 4 5 6 7 8 9 10 11 12
n |-------------------------------------------------------------------------------------------------------------------
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
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,377 ⟶ 1,877:
{{works with|Rakudo|2019.07.1}}
<syntaxhighlight lang="raku"
sub Lah (Int \n, Int \k) {
Line 1,400 ⟶ 1,900:
say "\nMaximum value from the L(100, *) row:";
say (^100).map( { Lah 100, $_ } ).max;</
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,425 ⟶ 1,925:
Also, code was added to use memoization of the factorial calculations.
<
parse arg lim . /*obtain optional argument from the CL.*/
if lim=='' | lim=="," then lim= 12 /*Not specified? Then use the default.*/
Line 1,465 ⟶ 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</
{{out|output|text= when using the default input:}}
<pre>
Line 1,487 ⟶ 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).
<
def lah(n, k)
Line 1,513 ⟶ 2,054:
puts "\nMaximum value from the L(100, *) row:";
puts (1..100).map{|a| lah(100,a)}.max
</syntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,534 ⟶ 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}}==
<
stirling3(n, k)
#binomial(n-1, k-1) * n!/k! # alternative formula
Line 1,557 ⟶ 2,198:
say "\nMaximum value from the L(#{n}, *) row:"
say { lah(n, _) }.map(^n).max
}</
{{out}}
<pre>
Line 1,584 ⟶ 2,225:
{{trans|Kotlin}}
<
import Foundation
Line 1,638 ⟶ 2,279:
let maxLah = (0...100).map({ lah(n: BigInt(100), k: BigInt($0)) }).max()!
print("Maximum value from the L(100, *) row: \(maxLah)")</
{{out}}
Line 1,661 ⟶ 2,302:
=={{header|Tcl}}==
<
set r 1
if {$from <= $to} {
Line 1,739 ⟶ 2,380:
puts "([string length $maxv] digits, k=$maxk)"
}
main </
{{out}}
<pre style="font-size:83%">Unsigned Lah numbers L(n,k):
Line 1,758 ⟶ 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}}
<
Function F(i,n)
Line 1,814 ⟶ 2,507:
End Sub 'Main
Main() </
{{out}}
<pre>
Line 1,835 ⟶ 2,528:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Module Module1
Line 1,891 ⟶ 2,584:
End Sub
End Module</
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,911 ⟶ 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}}
<
var fact = Fn.new { |n|
Line 1,933 ⟶ 2,690:
System.print("Unsigned Lah numbers: l(n, k):")
System.write("n/k")
for (i in 0..12)
System.print("\n" + "-" * 145)
for (n in 0..12) {
for (k in 0..n)
System.print()
}</
{{out}}
Line 1,961 ⟶ 2,718:
</pre>
=={{header|
{{trans|C}}
<syntaxhighlight lang "XPL0">func real Factorial(N);
real N, Res;
[Res:= 1.;
if N = 0. then return
while N > 0. do [Res:= Res*N; N:= N-1.];
return Res;
];
func real Lah(N, K);
real N, K;
if K
if K < 1. or N < 1. then return 0.;
return (Factorial(N) * Factorial(N-1.)) / (Factorial(K) * Factorial(K-1.)) /
Factorial(N-K);
];
int Row, I;
[Text(0, "Unsigned Lah numbers: L(N,K):"); CrLf(0);
Text(0, "N/K");
Format(11, 0);
for I:= 0 to 12 do RlOut(0, float(I));
CrLf(0);
for Row:= 0 to 12 do
[Format(3, 0); RlOut(0, float(Row));
for I:= 0 to Row do
[Format(11, 0); RlOut(0, Lah(float(Row), float(I)))];
]
]</syntaxhighlight>
{{out}}
<pre style="font-size:
Unsigned Lah numbers: L(N,K):
N/K 0 1 2 3 4 5 6 7 8 9 10 11 12
12 0 479001600 2634508800 4390848000 3293136000 1317254400 307359360 43908480 3920400 217800 7260 132 1
</pre>
=={{header|zkl}}==
<
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)
}</
<
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,027 ⟶ 2,784:
foreach row in ([0..N]){
println("%3d".fmt(row), [0..row].pump(String, lah.fp(row), fmt));
}</
{{out}}
<pre style="font-size:83%">
Line 2,047 ⟶ 2,804:
</pre>
{{libheader|GMP}} GNU Multiple Precision Arithmetic Library
<
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);</
{{out}}
<pre style="font-size:83%">
|