Lah numbers: Difference between revisions

{{trans|Python}}

I k == 1

R factorial(n)

print("\nMaximum value from the L(100, *) row:")

V maxVal = max((0.<100).map(a -> lah(100, a)))

{{out}}

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

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 #

OD;

print( ( "maximum Lah number for n = 100: ", whole( max 100, 0 ), newline ) )

{{out}}

<pre>

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

end for_k

end for_n

{{out}}

<pre>

=={{header|Arturo}}==

lah: function [n,k][

loop 1..12 'x [

print @[pad to :string x 3] ++ map to [:string] map 1..12 'y -> lah x y 's -> pad s 10

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f LAH_NUMBERS.AWK

# converted from C

return (factorial(n) * factorial(n-1)) / (factorial(k) * factorial(k-1)) / factorial(n-k)

}

{{out}}

<pre>

The last line builds a table where the rows represent <code>n</code> and columns represent <code>k</code>.

Lah ← {

𝕨 𝕊 0: 0;

}

╵ 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 3628800 16329600 21772800 12700800 3810240 635040 60480 3240 90 1 0

0 39916800 199584000 299376000 199584000 69854400 13970880 1663200 118800 4950 110 1

[https://mlochbaum.github.io/BQN/try.html#code=RiDihpAgKOKJpeKfnDAp4pe24p+oMCzDl8K0MSvihpXin6kKTGFoIOKGkCB7CiAg8J2VqCDwnZWKIDA6IDA7CiAgMCDwnZWKIPCdlak6IDA7CiAg8J2VqCDwnZWKIDE6IEYg8J2VqDsKICBuIPCdlYogazoKICAobj1rKeKKkeKfqCgobiDDl+KXi0Ygbi0xKSDDtyBrIMOX4peLRiBrLTEpICgwPeKKoinil7bDt+KAvzAgRiBuLWssIDHin6kKfQoK4oCiU2hvdyBMYWjijJzLnOKGlTEy Try It!]

=={{header|C}}==

{{trans|D}}

#include <stdio.h>

return 0;

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

=={{header|C sharp|C#}}==

{{trans|D}}

using System.Linq;

using System.Numerics;

}

}

{{out}}

<pre>0 1

=={{header|C++}}==

{{libheader|GMP}}

#include <algorithm>

std::cout << max << '\n';

return 0;

{{out}}

=={{header|D}}==

{{trans|Kotlin}}

import std.bigint;

import std.range;

auto lambda = (int a) => lah(BigInt(100), BigInt(a));

writeln(iota(0, 100).map!lambda.max);

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

=={{header|Dyalect}}==

n is 0 ? 1 : (n^-1..<0).Fold(1, (acc, val) => acc * val)

(0..row).ForEach(i => lah(row, i) >> "{0,11}".Format >> print(terminator: ""))

print("")

{{out}}

=={{header|Factor}}==

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

kernel locals math math.factorials math.ranges prettyprint

sequences ;

"Maximum value from the 100 _ lah row:" print

{{out}}

<pre>

=={{header|FreeBASIC}}==

if n = 0 then return 1

return n*factorial(n-1)

next k

print outstr

{{out}}

<pre>

=={{header|Go}}==

import (

fmt.Println(max)

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

{{out}}

=={{header|Haskell}}==

{{trans|Python}}

import Control.Monad (when)

printf "\nMaximum value from the L(100, *) row:\n%d\n"

(maximum $ lah 100 <$> ([0..100] :: [Integer]))

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

=={{header|J}}==

NB. use: k lah n

lah=: ! :(!&<: * %&!~)&x: NB. `%~' is shorter than `*inv'

extend_precision =: x: Monad

wordy_lah =: ((combinations but_1st decrement) times (into but_1st factorial))but_1st extend_precision Dyad

<pre>

lah&>~table~>:i.12

=={{header|Java}}==

import java.math.BigInteger;

import java.util.HashMap;

}

{{out}}

but gojq is required to produce the precise maximum value.

def factorial: reduce range(2;.+1) as $i (1; . * $i);

def lah($n; $k): lah($n;$k;false);

'''The task'''

def pad: lpad(12);

reduce range(0;$kmax+1) as $k ("n/k"|lpad(4); . + ($k|pad)),

task

{{out}}

<pre>

=={{header|Julia}}==

function lah(n::Integer, k::Integer, signed=false)

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

=={{header|Kotlin}}==

{{trans|Perl}}

fun factorial(n: BigInteger): BigInteger {

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):

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

Lah[n_?Positive, 0] := 0

Lah[0, k_?Positive] := 0

Lah[n_, k_] := (-1)^n (n! ((n - 1)!))/((k! ((k - 1)!)) ((n - k)!))

Table[Lah[i, j], {i, 0, 12}, {j, 0, 12}] // Grid

{{out}}

<pre>1 0 0 0 0 0 0 0 0 0 0 0 0

{{trans|Julia}}

{{libheader|bignum}}

import bignum

let val = lah(n, k)

if val > maxval: maxval = val

{{out}}

{{libheader|ntheory}}

{{trans|Raku}}

use warnings;

use feature 'say';

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

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

{{libheader|Phix/mpfr}}

{{trans|Go}}

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

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

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nThe maximum 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>

=={{header|PicoLisp}}==

(if (=0 N)

1

(prinl "Maximum value from the L(100, *) row:")

(maxi '((N) (lah 100 N)) (range 0 100))

{{out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

:- dynamic unsigned_lah_number_cache/3.

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

max_unsigned_lah_number(100, M),

{{out}}

=={{header|Python}}==

if n == 0:

return 1

print maxVal

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

=={{header|Quackery}}==

1

101 times

[ 100 i^ lah

2dup < iff nip else drop ]

{{out}}

=={{header|R}}==

if (n == k)

Table

{{out}}

{{works with|Rakudo|2019.07.1}}

sub Lah (Int \n, Int \k) {

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

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

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.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

!: parse arg z; if !.z\==. then return !.z; !=1; do f=2 to z; !=!*f; end; !.z=!; return !

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ruby}}==

Works with Ruby 3.0 (end-less method; end-less and begin-less range).

def lah(n, k)

puts "\nMaximum value from the L(100, *) row:";

puts (1..100).map{|a| lah(100,a)}.max

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

=={{header|Scheme}}==

{{works with|Chez Scheme}}

(define lah

(lambda (n k)

(let ((val (lah 100 k)))

(when (> val max) (set! max val))))

{{out}}

<pre>The Unsigned Lah numbers L(n, k) up to L(12, 12):

=={{header|Sidef}}==

stirling3(n, k)

#binomial(n-1, k-1) * n!/k! # alternative formula

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

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

{{out}}

<pre>

{{trans|Kotlin}}

import Foundation

let maxLah = (0...100).map({ lah(n: BigInt(100), k: BigInt($0)) }).max()!

{{out}}

=={{header|Tcl}}==

set r 1

if {$from <= $to} {

puts "([string length $maxv] digits, k=$maxk)"

}

{{out}}

<pre style="font-size:83%">Unsigned Lah numbers L(n,k):

=={{header|VBScript}}==

{{trans|Visual Basic .NET}}

Function F(i,n)

End Sub 'Main

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Module Module1

End Sub

{{out}}

<pre>Unsigned Lah numbers: L(n, k):

=={{header|Vlang}}==

{{trans|go}}

fn main() {

println("which has ${max.str().len} digits.")

}

{{out}}

=={{header|Wren}}==

{{libheader|Wren-fmt}}

var fact = Fn.new { |n|

for (k in 0..n) System.write("%(Fmt.d(10, lah.call(n, k))) ")

System.print()

{{out}}

=={{header|Vala}}==

uint64 res = 1;

if (n == 0) return res;

print("\n");

}

{{out}}

<pre style="font-size:83%">Unsigned Lah numbers: L(n, k):

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

foreach row in ([0..N]){

println("%3d".fmt(row), [0..row].pump(String, lah.fp(row), fmt));

{{out}}

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

</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));

{{out}}

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