Rosetta Code

Lah numbers: Difference between revisions

Page Discussion

Lah numbers (view source)

Revision as of 09:19, 23 March 2024

18,184 bytes added ,  2 months ago
added RPL
(added RPL)
 
(22 intermediate revisions by 16 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}}==
Line 92 ⟶ 140:
{{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.
<langsyntaxhighlight 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 #
Line 138 ⟶ 186:
OD;
print( ( "maximum Lah number for n = 100: ", whole( max 100, 0 ), newline ) )
END</langsyntaxhighlight>
{{out}}
<pre>
Line 162 ⟶ 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 216 ⟶ 264:
end for_k
end for_n
end.</langsyntaxhighlight>
{{out}}
<pre>
Line 238 ⟶ 286:
=={{header|Arturo}}==
 
<langsyntaxhighlight lang="rebol">factorial: function [n]-> product 1..n
 
lah: function [n,k][
Line 248 ⟶ 296:
]
 
print @["n/k"] ++ map to [:string] 01..12 's -> pad s 10
print repeat "-" 146136
loop 01..12 'x [
print @[pad to :string x 3] ++ map to [:string] map 01..12 'y -> lah x y 's -> pad s 10
]</langsyntaxhighlight>
 
{{out}}
 
<pre>n/k 0 1 2 3 4 5 6 7 8 9 10 11 12
--------------------------------------------------------------------------------------------------------------------------------------------------
01 1 0 0 0 0 0 0 0 0 0 0 0 0
12 02 1 0 0 0 0 0 0 0 0 0 0 0
23 06 26 1 0 0 0 0 0 0 0 0 0 0
34 24 0 36 6 612 1 0 0 0 0 0 0 0 0 0
45 120 0 240 24 120 36 1220 1 0 0 0 0 0 0 0 0
56 720 0 1800 120 1200 240 300 120 2030 1 0 0 0 0 0 0 0
67 5040 0 15120 720 12600 1800 4200 1200 630 300 3042 1 0 0 0 0 0 0
78 40320 0 141120 141120 5040 58800 15120 11760 12600 1176 4200 630 4256 1 0 0 0 0 0
89 362880 1451520 0 1693440 40320 846720 141120 211680 141120 28224 58800 2016 11760 1176 5672 1 0 0 0 0
10 9 3628800 16329600 21772800 0 12700800 3628803810240 1451520 635040 1693440 60480 846720 2116803240 28224 2016 7290 1 0 0 0
1011 39916800 199584000 299376000 199584000 0 69854400 3628800 13970880 16329600 1663200 21772800 12700800 118800 3810240 4950 635040 60480 3240 90110 1 0 0
1112 479001600 2634508800 4390848000 3293136000 1317254400 307359360 0 43908480 39916800 1995840003920400 299376000 199584000 217800 69854400 13970880 7260 1663200 118800 4950 110132 1 0 </pre>
12 0 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 305 ⟶ 352:
return (factorial(n) * factorial(n-1)) / (factorial(k) * factorial(k-1)) / factorial(n-k)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 331 ⟶ 378:
 
The last line builds a table where the rows represent <code>n</code> and columns represent <code>k</code>.
<langsyntaxhighlight lang="bqn">F ← (≥⟜0)◶⟨0,×´1+↕⟩
Lah ← {
𝕨 𝕊 0: 0;
Line 340 ⟶ 387:
}
 
•Show Lah⌜˜↕12</langsyntaxhighlight><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
Line 353 ⟶ 400:
0 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1 0
0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1
┘</langsyntaxhighlight>
[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 395 ⟶ 442:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 415 ⟶ 462:
=={{header|C sharp|C#}}==
{{trans|D}}
<langsyntaxhighlight lang="csharp">using System;
using System.Linq;
using System.Numerics;
Line 458 ⟶ 505:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>0 1
Line 479 ⟶ 526:
=={{header|C++}}==
{{libheader|GMP}}
<langsyntaxhighlight lang="cpp">// Reference: https://en.wikipedia.org/wiki/Lah_number#Identities_and_relations
 
#include <algorithm>
Line 532 ⟶ 579:
std::cout << max << '\n';
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 556 ⟶ 603:
=={{header|D}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="d">import std.algorithm : map;
import std.bigint;
import std.range;
Line 610 ⟶ 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 630 ⟶ 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 664 ⟶ 799:
 
"Maximum value from the 100 _ lah row:" print
100 [0,b] [ 100 swap lah ] map supremum .</langsyntaxhighlight>
{{out}}
<pre>
Line 688 ⟶ 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 722 ⟶ 857:
next k
print outstr
next n</langsyntaxhighlight>
{{out}}
<pre>
Line 746 ⟶ 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 814 ⟶ 971:
fmt.Println(max)
fmt.Printf("which has %d digits.\n", len(max.String()))
}</langsyntaxhighlight>
 
{{out}}
Line 841 ⟶ 998:
=={{header|Haskell}}==
{{trans|Python}}
<langsyntaxhighlight lang="haskell">import Text.Printf (printf)
import Control.Monad (when)
Line 870 ⟶ 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 892 ⟶ 1,049:
 
=={{header|J}}==
<syntaxhighlight lang="j">
<lang J>
NB. use: k lah n
lah=: ! :(!&<: * %&!~)&x: NB. `%~' is shorter than `*inv'
Line 910 ⟶ 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 945 ⟶ 1,102:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">
import java.math.BigInteger;
import java.util.HashMap;
Line 1,003 ⟶ 1,160:
 
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,031 ⟶ 1,188:
but gojq is required to produce the precise maximum value.
 
<langsyntaxhighlight lang="jq">## Generic functions
 
def factorial: reduce range(2;.+1) as $i (1; . * $i);
Line 1,059 ⟶ 1,216:
 
def lah($n; $k): lah($n;$k;false);
</syntaxhighlight>
</lang>
'''The task'''
<langsyntaxhighlight lang="jq">def printlahtable($kmax):
def pad: lpad(12);
reduce range(0;$kmax+1) as $k ("n/k"|lpad(4); . + ($k|pad)),
Line 1,075 ⟶ 1,232:
 
task
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,098 ⟶ 1,255:
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">using Combinatorics
 
function lah(n::Integer, k::Integer, signed=false)
Line 1,130 ⟶ 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 1,152 ⟶ 1,309:
=={{header|Kotlin}}==
{{trans|Perl}}
<langsyntaxhighlight lang="scala">import java.math.BigInteger
 
fun factorial(n: BigInteger): BigInteger {
Line 1,191 ⟶ 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,213 ⟶ 1,370:
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">ClearAll[Lah]
Lah[n_?Positive, 0] := 0
Lah[0, k_?Positive] := 0
Line 1,220 ⟶ 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,238 ⟶ 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,270 ⟶ 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,293 ⟶ 1,466:
{{libheader|ntheory}}
{{trans|Raku}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,321 ⟶ 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,345 ⟶ 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,388 ⟶ 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,412 ⟶ 1,585:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(de fact (N)
(if (=0 N)
1
Line 1,436 ⟶ 1,609:
(prinl "Maximum value from the L(100, *) row:")
(maxi '((N) (lah 100 N)) (range 0 100))
(prinl @@)</langsyntaxhighlight>
{{out}}
<pre>
Line 1,459 ⟶ 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,502 ⟶ 1,675:
writeln('Maximum value of L(n,k) where n = 100:'),
max_unsigned_lah_number(100, M),
writeln(M).</langsyntaxhighlight>
 
{{out}}
Line 1,524 ⟶ 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):
def lah(n, k):
if k == 1:
return factorial(n)
Line 1,542 ⟶ 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)
 
 
main()</lang>
if __name__ == '__main__':
main()</syntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 1,583 ⟶ 1,754:
=={{header|Quackery}}==
 
<langsyntaxhighlight Quackerylang="quackery"> [ table ] is ! ( n --> n )
1
101 times
Line 1,628 ⟶ 1,799:
[ 100 i^ lah
2dup < iff nip else drop ]
echo</langsyntaxhighlight>
 
{{out}}
Line 1,649 ⟶ 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,654 ⟶ 1,877:
{{works with|Rakudo|2019.07.1}}
 
<syntaxhighlight lang="raku" perl6line>constant @factorial = 1, |[\*] 1..*;
 
sub Lah (Int \n, Int \k) {
Line 1,677 ⟶ 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,702 ⟶ 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,742 ⟶ 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,764 ⟶ 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,790 ⟶ 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,811 ⟶ 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,834 ⟶ 2,198:
say "\nMaximum value from the L(#{n}, *) row:"
say { lah(n, _) }.map(^n).max
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,861 ⟶ 2,225:
{{trans|Kotlin}}
 
<langsyntaxhighlight lang="swift">import BigInt
import Foundation
 
Line 1,915 ⟶ 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,938 ⟶ 2,302:
 
=={{header|Tcl}}==
<langsyntaxhighlight Tcllang="tcl">proc prod {from to} {
set r 1
if {$from <= $to} {
Line 2,016 ⟶ 2,380:
puts "([string length $maxv] digits, k=$maxk)"
}
main </langsyntaxhighlight>
{{out}}
<pre style="font-size:83%">Unsigned Lah numbers L(n,k):
Line 2,035 ⟶ 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 2,091 ⟶ 2,507:
End Sub 'Main
 
Main() </langsyntaxhighlight>
{{out}}
<pre>
Line 2,112 ⟶ 2,528:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<langsyntaxhighlight lang="vbnet">Imports System.Numerics
 
Module Module1
Line 2,168 ⟶ 2,584:
End Sub
 
End Module</langsyntaxhighlight>
{{out}}
<pre>Unsigned Lah numbers: L(n, k):
Line 2,188 ⟶ 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,210 ⟶ 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,238 ⟶ 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,304 ⟶ 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,324 ⟶ 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,150

edits

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