Left factorials

Left factorials, $!n$ , may refer to either subfactorials or to factorial sums; the same notation can be confusingly seen used for the two different definitions.

Sometimes, subfactorials (also known as derangements) use any of the notations:

!n`
$!n'$
n¡

This Rosetta Code task will be using this formula for left factorial:

!n=\sum _{k=0}^{n-1}k!

where

$!0=0$
Task

Display the left factorials for:

zero through ten (inclusive)
20 through 110 (inclusive) by tens

Display the length (in decimal digits) of the left factorials for:

1,000, 2,000 through 10,000 (inclusive), by thousands.

Also see

The OEIS entry: A003422 left factorials
The MathWorld entry: left factorial
The MathWorld entry: factorial sums
The MathWorld entry: subfactorial
The Rosetta Code entry: permutations/derangements (subfactorials)

Bracmat

Translation of: D

<lang bracmat>( ( leftFact

 =   result factorial i
   .   0:?result
     & 1:?factorial
     & 0:?i
     &   whl
       ' ( !i+1:~>!arg:?i
         & !factorial+!result:?result
         & !factorial*!i:?factorial
         )
     & !result
 )

& ( iterate

 =   from to step c fun
   .   !arg:(?from.?to.?step.?fun)
     & !from+-1*!step:?from
     & !step:?c
     &   whl
       ' ( !step+!from:~>!to:?from
         & !fun$(leftFact$!from)
         )
     & 
 )

& out$"First 11 left factorials:" & iterate$(0.10.1.out) & out$" 20 through 110 (inclusive) by tens:" & iterate$(20.110.10.out) & out$" Digits in 1,000 through 10,000 by thousands:" & iterate

 $ ( 1000
   . 10000
   . 1000
   . (=L.@(!arg:? [?L)&out$!L)
   )

)</lang>

Output:

First 11 left factorials:
0
1
2
4
10
34
154
874
5914
46234
409114

20 through 110 (inclusive) by tens:
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

Digits in 1,000 through 10,000 by thousands:
2565
5733
9128
12670
16322
20062
23875
27749
31678
35656

C

Library: GMP

include <stdio.h>
include <stdlib.h>
include <string.h>
include <gmp.h>

void mpz_left_fac_ui(mpz_t rop, unsigned long op) {

   mpz_t t1;
   mpz_init_set_ui(t1, 1);
   mpz_set_ui(rop, 0);

   size_t i;
   for (i = 1; i <= op; ++i) {
       mpz_add(rop, rop, t1);
       mpz_mul_ui(t1, t1, i);
   }

   mpz_clear(t1);

}

size_t mpz_digitcount(mpz_t op) {

   /* mpz_sizeinbase can not be trusted to give accurate base 10 length */
   char *t    = mpz_get_str(NULL, 10, op);
   size_t ret = strlen(t);
   free(t);
   return ret;

}

int main(void) {

   mpz_t t;
   mpz_init(t);
   size_t i;

   for (i = 0; i <= 110; ++i) {
       if (i <= 10 || i % 10 == 0) {
           mpz_left_fac_ui(t, i);
           gmp_printf("!%u = %Zd\n", i, t);
       }
   }

   for (i = 1000; i <= 10000; i += 1000) {
       mpz_left_fac_ui(t, i);
       printf("!%u has %u digits\n", i, mpz_digitcount(t));
   }

   mpz_clear(t);
   return 0;

} </lang>

Output:

!0 = 0
!1 = 1
!2 = 2
!3 = 4
!4 = 10
!5 = 34
!6 = 154
!7 = 874
!8 = 5914
!9 = 46234
!10 = 409114
!20 = 128425485935180314
!30 = 9157958657951075573395300940314
!40 = 20935051082417771847631371547939998232420940314
!50 = 620960027832821612639424806694551108812720525606160920420940314
!60 = 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70 = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80 = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
!90 = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
!100 = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
!110 = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
!1000 has 2565 digits
!2000 has 5733 digits
!3000 has 9128 digits
!4000 has 12670 digits
!5000 has 16322 digits
!6000 has 20062 digits
!7000 has 23875 digits
!8000 has 27749 digits
!9000 has 31678 digits
!10000 has 35656 digits

Common Lisp

<lang lisp> (defun fact (n)

 (reduce #'* (loop for i from 1 to n collect i)))

(defun left-fac (n)

 (reduce #'+ (loop for i below n collect (fact i))))

(format t "0 -> 10~&") (format t "~a~&" (loop for i upto 10 collect (left-fac i))) (format t "20 -> 110 by 10~&") (format t "~{~a~&~}" (loop for i from 20 upto 110 by 10 collect (left-fac i))) (format t "1000 -> 10000 by 1000~&") (format t "~{~a digits~&~}" (loop for i from 1000 upto 10000 by 1000 collect (length (format nil "~a" (left-fac i))))) </lang>

Output:

0 -> 10
(0 1 2 4 10 34 154 874 5914 46234 409114)
20 -> 110 by 10
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
1000 -> 10000 by 1000
2565 digits
5733 digits
9128 digits
12670 digits
16322 digits
20062 digits
23875 digits
27749 digits
31678 digits
35656 digits

D

<lang d>import std.stdio, std.bigint, std.range, std.algorithm, std.conv;

BigInt leftFact(in uint n) pure nothrow /*@safe*/ {

   BigInt result = 0, factorial = 1;
   foreach (immutable i; 1 .. n + 1) {
       result += factorial;
       factorial *= i;
   }
   return result;

}

void main() {

   writeln("First 11 left factorials:\n", 11.iota.map!leftFact);
   writefln("\n20 through 110 (inclusive) by tens:\n%(%s\n%)",
            iota(20, 111, 10).map!leftFact);
   writefln("\nDigits in 1,000 through 10,000 by thousands:\n%s",
            iota(1_000, 10_001, 1_000).map!(i => i.leftFact.text.length));

}</lang>

Output:

First 11 left factorials:
[0, 1, 2, 4, 10, 34, 154, 874, 5914, 46234, 409114]

20 through 110 (inclusive) by tens:
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

Digits in 1,000 through 10,000 by thousands:
[2565, 5733, 9128, 12670, 16322, 20062, 23875, 27749, 31678, 35656]

EchoLisp

We use the 'bigint' library and memoization : (remember 'function). <lang lisp> (lib 'bigint) (define (!n n) (if (zero? n) 0 (+ (!n (1- n)) (factorial (1- n))))) (remember '!n) </lang> Output: <lang lisp> (for ((n 11)) (printf "!n(%d) = %d" n (!n n))) (for ((n (in-range 20 120 10))) (printf "!n(%d) = %d" n (!n n))) !n(0) = 0 !n(1) = 1 !n(2) = 2 !n(3) = 4 !n(4) = 10 !n(5) = 34 !n(6) = 154 !n(7) = 874 !n(8) = 5914 !n(9) = 46234 !n(10) = 409114 !n(20) = 128425485935180314 !n(30) = 9157958657951075573395300940314 !n(40) = 20935051082417771847631371547939998232420940314 !n(50) = 620960027832821612639424806694551108812720525606160920420940314 !n(60) = 141074930726669571000530822087000522211656242116439949000980378746128920420940314 !n(70) = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314 !n(80) = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314 !n(90) = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314 !n(100) = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314 !n(110) = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

Compute !n: 5 seconds

(for ((n (in-range 1000 10001 500))) (!n n) (writeln n))

Display results: 12 seconds

(for ((n (in-range 1000 10001 1000))) (printf "Digits of !n(%d) = %d" n (number-length (!n n)))) Digits of !n(1000) = 2565 Digits of !n(2000) = 5733 Digits of !n(3000) = 9128 Digits of !n(4000) = 12670 Digits of !n(5000) = 16322 Digits of !n(6000) = 20062 Digits of !n(7000) = 23875 Digits of !n(8000) = 27749 Digits of !n(9000) = 31678 Digits of !n(10000) = 35656 </lang>

Go

<lang go>package main

import (

   "fmt"
   "math/big"

)

func main() {

   fmt.Print("!0 through !10: 0")
   one := big.NewInt(1)
   n := big.NewInt(1)
   f := big.NewInt(1)
   l := big.NewInt(1)
   next := func() { f.Mul(f, n); l.Add(l, f); n.Add(n, one) }
   for ; ; next() {
       fmt.Print(" ", l)
       if n.Int64() == 10 {
           break
       }
   }
   fmt.Println()
   for {
       for i := 0; i < 10; i++ {
           next()
       }
       fmt.Printf("!%d: %d\n", n, l)
       if n.Int64() == 110 {
           break
       }
   }
   fmt.Println("Lengths of !1000 through !10000 by thousands:")
   for i := 110; i < 1000; i++ {
       next()
   }
   for {
       fmt.Print(" ", len(l.String()))
       if n.Int64() == 10000 {
           break
       }
       for i := 0; i < 1000; i++ {
           next()
       }
   }
   fmt.Println()

}</lang>

Output:

!0 through !10: 0 1 2 4 10 34 154 874 5914 46234 409114
!20: 128425485935180314
!30: 9157958657951075573395300940314
!40: 20935051082417771847631371547939998232420940314
!50: 620960027832821612639424806694551108812720525606160920420940314
!60: 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70: 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80: 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
!90: 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
!100: 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
!110: 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
Lengths of !1000 through !10000 by thousands:
 2565 5733 9128 12670 16322 20062 23875 27749 31678 35656

Haskell

<lang haskell>fact :: [Integer] fact = scanl (*) 1 [1..]

leftFact :: [Integer] leftFact = scanl (+) 0 fact

main = do

      putStrLn "0 ~ 10:"
      putStrLn $ show $ map (\n -> leftFact !! n) [0..10]
      putStrLn ""

      putStrLn "20 ~ 110 by tens:"
      putStrLn $ unlines $ map show $ map (\n -> leftFact !! n) [20,30..110]
      putStrLn ""

      putStrLn "length of 1,000 ~ 10,000 by thousands:"
      putStrLn $ show $ map (\n -> length $ show $ leftFact !! n) [1000,2000..10000]
      putStrLn ""</lang>

Output:

0 ~ 10:
[0,1,2,4,10,34,154,874,5914,46234,409114]

20 ~ 110 by tens:
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314


length of 1,000 ~ 10,000 by thousands:
[2565,5733,9128,12670,16322,20062,23875,27749,31678,35656]

Icon and Unicon

Translation of: D

The following works in both languages: <lang>procedure main()

   every writes(lfact(0 | !10)," ")
   write()
   write()
   every write(lfact(20 to 110 by 10))
   write()
   every writes(*lfact(1000 to 10000 by 1000)," ")
   write()

end

procedure lfact(n)

   r := 0
   f := 1
   every (i := !n, r +:= .f, f *:= .i)
   return r

end</lang>

Output:

->lfact
0 1 2 4 10 34 154 874 5914 46234 409114 

128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

2565 5733 9128 12670 16322 20062 23875 27749 31678 35656 
->

J

This could be made more efficient (in terms of machine time), is there a practical application for this? The more efficient machine approach would require a more specialized interface or memory dedicated to caching.

<lang J>leftFact=: +/@:!@i."0</lang>

Task examples:

<lang J> (,. leftFact) i.11

10 409114

  (,. leftFact) 10*2+i.10x
20                                                                                                                                                                128425485935180314
30                                                                                                                                                   9157958657951075573395300940314
40                                                                                                                                   20935051082417771847631371547939998232420940314
50                                                                                                                   620960027832821612639424806694551108812720525606160920420940314
60                                                                                                 141074930726669571000530822087000522211656242116439949000980378746128920420940314
70                                                                               173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
80                                                             906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
90                                         16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314

100 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314 110 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

  (,. #@":@leftFact) 1000*1+i.10x
1000  2565
2000  5733
3000  9128
4000 12670
5000 16322
6000 20062
7000 23875
8000 27749
9000 31678

10000 35656</lang>

Java

<lang java>import java.math.BigInteger;

public class LeftFac{ public static BigInteger factorial(BigInteger n){ BigInteger ans = BigInteger.ONE; for(BigInteger x = BigInteger.ONE; x.compareTo(n) <= 0; x = x.add(BigInteger.ONE)){ ans = ans.multiply(x); } return ans; }

public static BigInteger leftFact(BigInteger n){ BigInteger ans = BigInteger.ZERO; for(BigInteger k = BigInteger.ZERO; k.compareTo(n.subtract(BigInteger.ONE)) <= 0; k = k.add(BigInteger.ONE)){ ans = ans.add(factorial(k)); } return ans; }

public static void main(String[] args){ for(int i = 0; i <= 10; i++){ System.out.println("!" + i + " = " + leftFact(BigInteger.valueOf(i))); }

for(int i = 20; i <= 110; i += 10){ System.out.println("!" + i + " = " + leftFact(BigInteger.valueOf(i))); }

for(int i = 1000; i <= 10000; i += 1000){ System.out.println("!" + i + " has " + leftFact(BigInteger.valueOf(i)).toString().length() + " digits"); } } }</lang>

Output:

!0 = 0
!1 = 1
!2 = 2
!3 = 4
!4 = 10
!5 = 34
!6 = 154
!7 = 874
!8 = 5914
!9 = 46234
!10 = 409114
!20 = 128425485935180314
!30 = 9157958657951075573395300940314
!40 = 20935051082417771847631371547939998232420940314
!50 = 620960027832821612639424806694551108812720525606160920420940314
!60 = 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70 = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80 = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
!90 = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
!100 = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
!110 = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
!1000 has 2565 digits
!2000 has 5733 digits
!3000 has 9128 digits
!4000 has 12670 digits
!5000 has 16322 digits
!6000 has 20062 digits
!7000 has 23875 digits
!8000 has 27749 digits
!9000 has 31678 digits
!10000 has 35656 digits

jq

jq currently only has builtin support for IEEE 64-bit numbers, so in this section we will first present the algorithm using the builtin arithmetic operators and then adapt it for use with the BigInt library at https://gist.github.com/pkoppstein/d06a123f30c033195841

Using builtin arithmetic: <lang jq>def left_factorial:

 reduce range(1; .+1) as $i
 # state: [i!, !i]
   ([1,0]; .[1] += .[0] | .[0] *= $i)
 | .[1];</lang>

Using BigInt.jq:

The BigInt library can be used with jq 1.4, but we will take this opportunity to showcase jq 1.5's support for importing such libraries as modules. If your jq does not have support for modules, add the BigInt.jq file, remove the 'import' statement and strip off the "BigInt::" prefix.

To compute the lengths of the decimal representation without having to recompute !n, we also define left_factorial_lengths(gap) to emit [n, ( !n|length) ] when n % gap == 0. <lang jq>import "BigInt" as BigInt;

integer input

def long_left_factorial:

 reduce range(1; .+1) as $i
 # state: [i!, !i]
   ( ["1", "0"];
     .[1] = BigInt::long_add(.[0]; .[1])
   | .[0] = BigInt::long_multiply(.[0]; $i | tostring) )
 | .[1];

input and gap should be integers

def long_left_factorial_lengths(gap):

 reduce range(1; .+1) as $i
 # state: [i!, !i, gap]
   (["1", "0", []];
   .[1] = BigInt::long_add(.[0]; .[1])
   | .[0] = BigInt::long_multiply(.[0]; $i|tostring)
   | (.[1] | tostring | length) as $lf
   | if $i % gap == 0 then .[2] += $i, $lf else . end)
 | .[2];</lang>

The specific tasks: <lang sh>((range(0;11), (range(2; 12) * 10)) | "\(.): \(long_left_factorial)"),

(10000 | long_left_factorial_lengths(1000) | .[] | "\(.[0]): length is \(.[1])")</lang>

Output:

(scrollable)

<lang sh>$ jq -r -n -L . -f Long_left_factorial.jq 0: 0 1: 1 2: 2 3: 4 4: 10 5: 34 6: 154 7: 874 8: 5914 9: 46234 10: 409114 20: 128425485935180314 30: 9157958657951075573395300940314 40: 20935051082417771847631371547939998232420940314 50: 620960027832821612639424806694551108812720525606160920420940314 60: 141074930726669571000530822087000522211656242116439949000980378746128920420940314 70: 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314 80: 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314 90: 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314 100: 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314 110: 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314 1000: length is 2565 2000: length is 5733 3000: length is 9128 4000: length is 12670 5000: length is 16322 6000: length is 20062 7000: length is 23875 8000: length is 27749 9000: length is 31678 10000: length is 35656</lang>

Julia

<lang java>leftfactorial(n::Integer) = n <= 0 ? zero(n) : sum(factorial, 0:n-1) @vectorize_1arg Integer leftfactorial</lang>

Output:

julia> leftfactorial(0:10)
[0,1,2,4,10,34,154,874,5914,46234,409114]

julia> leftfactorial(big(20:10:110))
[128425485935180314,9157958657951075573395300940314,20935051082417771847631371547939998232420940314,620960027832821612639424806694551108812720525606160920420940314,141074930726669571000530822087000522211656242116439949000980378746128920420940314,173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314,906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314,16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314,942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314,145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314]

julia> map(n -> length(digits(n)), leftfactorial(big(1000:1000:10000)))
[2565,5733,9128,12670,16322,20062,23875,27749,31678,35656]

Mathematica

<lang Mathematica>left[n_] := left[n] = Sum[k!, {k, 0, n - 1}] Print["left factorials 0 through 10:"] Print[left /@ Range[0, 10] // TableForm] Print["left factorials 20 through 110, by tens:"] Print[left /@ Range[20, 110, 10] // TableForm] Print["Digits in left factorials 1,000 through 10,000, by thousands:"] Print[Length[IntegerDigits[left[#]]] & /@ Range[1000, 10000, 1000] // TableForm]</lang>

Output:

left factorials 0 through 10:
0
1
2
4
10
34
154
874
5914
46234
409114

left factorials 20 through 110, by tens:
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

Digits in left factorials 1,000 through 10,000, by thousands:
2565
5733
9128
12670
16322
20062
23875
27749
31678
35656

Nim

Translation of: Python

<lang nim>import iterutils, bigints

proc lfact: iterator: BigInt =

 result = iterator: BigInt =
   yield 0.initBigInt
   var
     fact = 1.initBigInt
     sum = 0.initBigInt
     n = 1.initBigInt
   while true:
     sum += fact
     fact *= n
     n += 1
     yield sum

echo "first 11:\n " for i in lfact().slice(last = 10):

 echo "  ", i

echo "20 through 110 (inclusive) by tens:" for i in lfact().slice(20, 110, 10):

 echo "  ", i

echo "Digits in 1,000 through 10,000 (inclusive) by thousands:" for i in lfact().slice(1_000, 10_000, 1_000):

 echo "  ", ($i).len</lang>

Output:

first 11:
  0
  1
  2
  4
  10
  34
  154
  874
  5914
  46234
  409114
20 through 110 (inclusive) by tens:
  128425485935180314
  9157958657951075573395300940314
  20935051082417771847631371547939998232420940314
  620960027832821612639424806694551108812720525606160920420940314
  141074930726669571000530822087000522211656242116439949000980378746128920420940314
  173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
  906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
  16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
  942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
  145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
Digits in 1,000 through 10,000 (inclusive) by thousands:
  2565
  5733
  9128
  12670
  16322
  20062
  23875
  27749
  31678
  35656

Oforth

<lang Oforth>: leftFact { | i | 0 1 rot loop: i [ tuck + swap i * ] drop }</lang>

Output:

>seqFrom(0, 10) map(#leftFact) println
[0, 1, 2, 4, 10, 34, 154, 874, 5914, 46234, 409114]

>seqFrom(2, 11) apply(#[ 10 * leftFact println ])
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

>seq(10) map(#[ 1000 * leftFact asString size ]) println
[2565, 5733, 9128, 12670, 16322, 20062, 23875, 27749, 31678, 35656]

PARI/GP

<lang parigp>lf(n)=sum(k=0,n-1,k!); apply(lf, [0..10]) apply(lf, 10*[2..11]) forstep(n=1000,1e4,1000,print1(#digits(lf(n))", "))</lang>

Output:

%1 = [0, 1, 2, 4, 10, 34, 154, 874, 5914, 46234, 409114]
%2 = [128425485935180314, 9157958657951075573395300940314, 20935051082417771847631371547939998232420940314, 620960027832821612639424806694551108812720525606160920420940314, 141074930726669571000530822087000522211656242116439949000980378746128920420940314, 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314, 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314, 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314, 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314, 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314]
2565, 5733, 9128, 12670, 16322, 20062, 23875, 27749, 31678, 35656,

Perl

By caching the last used factorial and left factorial values, I avoid needless recomputation. By only retaining the most recently used values, instead of all past values, I avoid the need to store twenty thousand enormous numbers.

If performance is a concern, this will run over 100x faster by replacing the line "use bigint" with "use Math::GMP qw/:constant/" (after installing that module).

<lang perl>#!perl use 5.010; use strict; use warnings; use bigint;

sub leftfact { my ($n) = @_; state $cached = 0; state $factorial = 1; state $leftfact = 0; if( $n < $cached ) { ($cached, $factorial, $leftfact) = (0, 1, 0); } while( $n > $cached ) { $leftfact += $factorial; $factorial *= ++$cached; } return $leftfact; }

printf "!%d = %s\n", $_, leftfact($_) for 0 .. 10, map $_*10, 2..11; printf "!%d has %d digits.\n", $_, length leftfact($_) for map $_*1000, 1..10;

</lang>

Since I copied the printf format strings from the perl6 implementation, the output from the code above is identical to the output of the perl6 code.

Perl 6

Perl 6 doesn't have a built in factorial function, so the first two lines implement postfix ! factorial. The newly implemented factorial function is used to implement left factorial using a prefix ! in the next two lines. Note that this redefines the core prefix ! (not) function. The last two lines are display code for the various sub task requirements.

<lang perl6>multi sub postfix:<!> (0) { 1 }; multi sub postfix:<!> ($n) { [*] 1 .. $n }; multi sub prefix:<!> (0) { 0 }; multi sub prefix:<!> ($k) { [+] (^$k).map: { $_! } }

printf "!%d = %s\n", $_, !$_ for ^11, 20, 30 ... 110; printf "!%d has %d digits.\n", $_, (!$_).chars for 1000, 2000 ... 10000;</lang>

Output:

!0  = 0
!1  = 1
!2  = 2
!3  = 4
!4  = 10
!5  = 34
!6  = 154
!7  = 874
!8  = 5914
!9  = 46234
!10  = 409114
!20  = 128425485935180314
!30  = 9157958657951075573395300940314
!40  = 20935051082417771847631371547939998232420940314
!50  = 620960027832821612639424806694551108812720525606160920420940314
!60  = 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70  = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80  = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
!90  = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
!100  = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
!110  = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
!1000 has 2565 digits.
!2000 has 5733 digits.
!3000 has 9128 digits.
!4000 has 12670 digits.
!5000 has 16322 digits.
!6000 has 20062 digits.
!7000 has 23875 digits.
!8000 has 27749 digits.
!9000 has 31678 digits.
!10000 has 35656 digits.

While the code above seems like a pretty decent "mathematical" way to write this, it's far from efficient, since it's recalculating every factorial many times for each individual left factorial, not to mention for each subsequent left factorial, so it's something like an O(N^3) algorithm, not even counting the sizes of the numbers as one of the dimensions. In Perl 6, a more idiomatic way is to write these functions as constant "triangular reduction" sequences; this works in O(N)-ish time because the sequences never have to recalculate a prior result: <lang perl6>constant fact = 1, [\*] 1..*; constant leftfact = 0, [\+] fact;

printf "!%d = %s\n", $_, leftfact[$_] for 0 ... 10, 20 ... 110; printf "!%d has %d digits.\n", $_, leftfact[$_].chars for 1000, 2000 ... 10000;</lang> Note that we just use subscripting on the list rather than an explicit function call to retrieve the desired values. If you time these two solutions, the second will run about 280 times faster than the first.

In this case, since we aren't actually interested in the factorials, we could have just combined the two definitions into one: <lang perl6>constant leftfact = 0, [\+] 1, [\*] 1..*;</lang> (No significant difference in run time.)

PicoLisp

<lang PicoLisp>(de n! (N)

      (cache '(NIL) N
         (if (> 2 N) 1

(* N (n! (dec N))))))

(de !n (Num)

 (if (= Num 0) 1
     (sum n! (range 0 (dec Num)))))

(de pril (List) (mapcar 'println List))

(prinl "0-10") (pril (mapcar '!n (range 0 10))) (prinl "20 - 110") (pril (mapcar '!n (range 20 110 10))) (prinl "length of 1000 - 10000") (pril (mapcar 'length (mapcar '!n (range 1000 10000 1000)))) </lang>

Output:

PL/I

<lang PL/I>lf: procedure (n) returns (fixed decimal (31) );

  declare n fixed binary;
  declare (s, f) fixed (31);
  declare (i, j) fixed;

  s = 0;
  do i = n-1 to 0 by -1;
     f = 1;
     do j = i to 1 by -1;
        f = f * j;
     end;
     s = s + f;
  end;
  return (s);

end lf;

  declare n fixed binary;

  do n = 0 to 10, 20 to 30;
     put skip list ('Left factorial of ' || n || '=' || lf(n) );
  end;

end left_factorials;</lang>

Output:

Left factorial of         0=                                 0 
Left factorial of         1=                                 1 
Left factorial of         2=                                 2 
Left factorial of         3=                                 4 
Left factorial of         4=                                10 
Left factorial of         5=                                34 
Left factorial of         6=                               154 
Left factorial of         7=                               874 
Left factorial of         8=                              5914 
Left factorial of         9=                             46234 
Left factorial of        10=                            409114 
Left factorial of        20=                128425485935180314 
Left factorial of        21=               2561327494111820314 
Left factorial of        22=              53652269665821260314 
Left factorial of        23=            1177652997443428940314 
Left factorial of        24=           27029669736328405580314 
Left factorial of        25=          647478071469567844940314 
Left factorial of        26=        16158688114800553828940314 
Left factorial of        27=       419450149241406189412940314 
Left factorial of        28=     11308319599659758350180940314 
Left factorial of        29=    316196664211373618851684940314 
Left factorial of        30=   9157958657951075573395300940314

PowerShell

Works with: PowerShell version 4.0

<lang PowerShell> function left-factorial ([BigInt]$n) {

   [BigInt]$k, [BigInt]$fact = ([BigInt]::Zero), ([BigInt]::One)
   [BigInt]$lfact = ([BigInt]::Zero)
   while($k -lt $n){        
       if($k -gt ([BigInt]::Zero)) {
           $fact = [BigInt]::Multiply($fact, $k)
           $lfact = [BigInt]::Add($lfact, $fact)
       } else {
           $lfact = ([BigInt]::One)
       }
       $k = [BigInt]::Add($k, [BigInt]::One)
   }
   $lfact

} 0..9 | foreach{

   "!$_ = $(left-factorial $_)"

} for($i = 10; $i -le 110; $i += 10) {

   "!$i = $(left-factorial $i)"

} for($i = 1000; $i -le 10000; $i += 1000) {

   $digits = [BigInt]::Log10($(left-factorial $i)) 
   $digits = [Math]::Floor($digits) + 1
   if($i -ne 0) {"!$i has $digits digits"}
   else {"!$i has $digits digit"}

} </lang> Output:

!0 = 0
!1 = 1
!2 = 2
!3 = 4
!4 = 10
!5 = 34
!6 = 154
!7 = 874
!8 = 5914
!9 = 46234
!10 = 409114
!20 = 128425485935180314
!30 = 9157958657951075573395300940314
!40 = 20935051082417771847631371547939998232420940314
!50 = 620960027832821612639424806694551108812720525606160920420940314
!60 = 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70 = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80 = 9060895879876953465345168046502906376940248300119563651843276746197520942896963148820085319918409223365289204
20940314
!90 = 1669557007262421076703416768839462336073351516357586413634591033592403996240486951022572307223584266878750799
3136908442336528920420940314
!100 = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203
520208889371641659121356556442336528920420940314
!110 = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337
422204397431927131629058103519228197429698252556442336528920420940314
!1000 has 2565 digits
!2000 has 5733 digits
!3000 has 9128 digits
!4000 has 12670 digits
!5000 has 16322 digits
!6000 has 20062 digits
!7000 has 23875 digits
!8000 has 27749 digits
!9000 has 31678 digits
!10000 has 35656 digits

Python

<lang python>from itertools import islice

def lfact():

   yield 0
   fact, summ, n = 1, 0, 1 
   while 1:
       fact, summ, n = fact*n, summ + fact, n + 1
       yield summ

print('first 11:\n %r' % [lf for i, lf in zip(range(11), lfact())]) print('20 through 110 (inclusive) by tens:') for lf in islice(lfact(), 20, 111, 10):

   print(lf)

print('Digits in 1,000 through 10,000 (inclusive) by thousands:\n %r'

     % [len(str(lf)) for lf in islice(lfact(), 1000, 10001, 1000)] )</lang>

Output:

first 11:
  [0, 1, 2, 4, 10, 34, 154, 874, 5914, 46234, 409114]
20 through 110 (inclusive) by tens:
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
Digits in 1,000 through 10,000 (inclusive) by thousands:
  [2565, 5733, 9128, 12670, 16322, 20062, 23875, 27749, 31678, 35656]

Racket

<lang racket>#lang racket (define ! (let ((rv# (make-hash))) (λ (n) (hash-ref! rv# n (λ () (if (= n 0) 1 (* n (! (- n 1)))))))))

(define (!n n)

 ;; note that in-range n is from 0 to n-1 inclusive
 (for/sum ((k (in-range n))) (! k)))

(define (dnl. s) (for-each displayln s)) (dnl

 "Display the left factorials for:"
 "zero through ten (inclusive)"
 (pretty-format (for/list ((i (in-range 0 (add1 10)))) (!n i)))
 "20 through 110 (inclusive) by tens"
 (pretty-format (for/list ((i (in-range 20 (add1 110) 10))) (!n i)))
 "Display the length (in decimal digits) of the left factorials for:"
 "1,000, 2,000 through 10,000 (inclusive), by thousands."
 (pretty-format (for/list ((i (in-range 1000 10001 1000))) (add1 (order-of-magnitude (!n i))))))</lang>

Output:

Display the left factorials for:
zero through ten (inclusive)
'(0 1 2 4 10 34 154 874 5914 46234 409114)
20 through 110 (inclusive) by tens
'(128425485935180314
  9157958657951075573395300940314
  20935051082417771847631371547939998232420940314
  620960027832821612639424806694551108812720525606160920420940314
  141074930726669571000530822087000522211656242116439949000980378746128920420940314
  173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
  906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
  16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
  942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
  145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314)
Display the length (in decimal digits) of the left factorials for:
1,000, 2,000 through 10,000 (inclusive), by thousands.
'(2565 5733 9128 12670 16322 20062 23875 27749 31678 35656)

REXX

<lang rexx>/*REXX pgm computes/shows the left factorial (or width) of N (or range).*/ parse arg bot top inc . /*obtain optional args from C.L. */ if bot== then bot=1 /*BOT defined? Then use default.*/ td= bot<0 /*if BOT < 0, only show # digs.*/ bot=abs(bot) /*use the |bot| for the DO loop.*/ if top== then top=bot /* " " top " " " " */ if inc= then inc=1 /* " " inc " " " " */ @='left ! of ' /*a literal used in the display. */ w=length(H) /*width of largest number request*/

          do j=bot  to top  by inc    /*traipse through  #'s requested.*/
          if td  then say @ right(j,w)  " ───► "  length(L!(j)) ' digits'
                 else say @ right(j,w)  " ───► "  L!(j)
          end   /*j*/                  /* [↑]  show either L! or #digits*/

exit /*stick a fork in it, we're done.*/ /*──────────────────────────────────L! subroutine───────────────────────*/ L!: procedure; parse arg x .; if x<3 then return x; s=4 /*shortcuts.*/ !=2; do f=3 to x-1 /*compute L! for all numbers───►X*/

        !=!*f                         /*compute intermediate factorial.*/
        if pos(.,!)\==0 then numeric digits digits()*1.5%1 /*bump digs.*/
        s=s+!                         /*add the factorial ───► L!  sum.*/
        end   /*f*/                   /* [↑]  handles gi-hugeic numbers*/

return s /*return the sum (L!) to invoker.*/</lang>

Output:

when using the input

0 10

left ! of   0  ───►  0
left ! of   1  ───►  1
left ! of   2  ───►  2
left ! of   3  ───►  4
left ! of   4  ───►  10
left ! of   5  ───►  34
left ! of   6  ───►  154
left ! of   7  ───►  874
left ! of   8  ───►  5914
left ! of   9  ───►  46234
left ! of  10  ───►  409114

Output:

when using the input

20 110 10

left ! of   20  ───►  128425485935180314
left ! of   30  ───►  9157958657951075573395300940314
left ! of   40  ───►  20935051082417771847631371547939998232420940314
left ! of   50  ───►  620960027832821612639424806694551108812720525606160920420940314
left ! of   60  ───►  141074930726669571000530822087000522211656242116439949000980378746128920420940314
left ! of   70  ───►  173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
left ! of   80  ───►  906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
left ! of   90  ───►  16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
left ! of  100  ───►  942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
left ! of  110  ───►  145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

Output:

when using the input

-1000 10000 1000

left ! of   1000  ───►  2565  digits
left ! of   2000  ───►  5733  digits
left ! of   3000  ───►  9128  digits
left ! of   4000  ───►  12670  digits
left ! of   5000  ───►  16322  digits
left ! of   6000  ───►  20062  digits
left ! of   7000  ───►  23875  digits
left ! of   8000  ───►  27749  digits
left ! of   9000  ───►  31678  digits
left ! of  10000  ───►  35656  digits

Ruby

Works with: Ruby version 1.9.3+

<lang ruby>left_fact = Enumerator.new do |y|

 n, f, lf = 0, 1, 0
 loop do
   y  << lf #yield left_factorial
   n  += 1
   lf += f
   f  *= n
 end

end</lang>

Works with: Ruby version 2.1+

<lang ruby>left_fact = Enumerator.new do |y|

 f, lf = 1, 0
 1.step do |n|
   y  << lf #yield left_factorial
   lf += f
   f  *= n
 end

end</lang> Test: <lang ruby>tens = 20.step(110, 10) thousands = 1000.step(10_000, 1000)

10001.times do |n|

 lf = left_fact.next
 case n
 when 0..10, *tens
   puts "!#{n} = #{lf}"
 when *thousands
   puts "!#{n} has #{lf.to_s.size} digits"
 end

end</lang>

Output:

!0 = 0
!1 = 1
!2 = 2
!3 = 4
!4 = 10
!5 = 34
!6 = 154
!7 = 874
!8 = 5914
!9 = 46234
!10 = 409114
!20 = 128425485935180314
!30 = 9157958657951075573395300940314
!40 = 20935051082417771847631371547939998232420940314
!50 = 620960027832821612639424806694551108812720525606160920420940314
!60 = 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70 = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80 = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
!90 = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
!100 = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
!110 = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
!1000 has 2565 digits
!2000 has 5733 digits
!3000 has 9128 digits
!4000 has 12670 digits
!5000 has 16322 digits
!6000 has 20062 digits
!7000 has 23875 digits
!8000 has 27749 digits
!9000 has 31678 digits
!10000 has 35656 digits

Run BASIC

<lang Runbasic>a = lftFct(0,10,1) a = lftFct(20,110,10) a = lftFct(1000,10000,1000)

function lftFct(f,t,s) print :print "------ From ";f;" --To-> ";t;" Step ";s;" -------" for i = f to t step s lftFct = 1 fct = 1 for j = 1 to i-1 fct = fct * j lftFct = lftFct + fct next j if i >= 1000 then print i;" ";len(str$(lftFct));" "digits" else print i;" ";lftFct end if next i end function</lang>Output:

------ From 0 --To-> 10 Step 1 -------
0 1
1 1
2 2
3 4
4 10
5 34
6 154
7 874
8 5914
9 46234
10 409114

------ From 20 --To-> 110 Step 10 -------
20 128425485935180314
30 9157958657951075573395300940314
40 20935051082417771847631371547939998232420940314
50 620960027832821612639424806694551108812720525606160920420940314
60 141074930726669571000530822087000522211656242116439949000980378746128920420940314
70 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
80 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
90 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
100 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
110 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

------ From 1000 --To-> 10000 Step 1000 -------
1000 2565 digits
2000 5733 digits
3000 9128 digits
4000 12670 digits
5000 16322 digits
6000 20062 digits
7000 23875 digits
8000 27749 digits
9000 31678 digits
10000 35656 digits

Scala

<lang scala>object LeftFactorial extends App {

 // this part isn't really necessary, it just shows off Scala's ability
 // to match the mathematical syntax: !n
 implicit class RichInt(n:Int) {
   def unary_!() = factorial.take(n).sum
 }

 val factorial: Stream[BigInt] = 1 #:: factorial.zip(Stream.from(1)).map(n => n._2 * factorial(n._2 - 1))

 for (n <- (0 to 10) ++
           (20 to 110 by 10);
      value = !n) {
   println(s"!${n} = ${value}")
 }
 for (n <- 1000 to 10000 by 1000;
      length = (!n).toString.length) {
   println(s"length !${n} = ${length}")
 }

} </lang>

Output:

!0 = 0
!1 = 1
!2 = 2
!3 = 4
!4 = 10
!5 = 34
!6 = 154
!7 = 874
!8 = 5914
!9 = 46234
!10 = 409114
!20 = 128425485935180314
!30 = 9157958657951075573395300940314
!40 = 20935051082417771847631371547939998232420940314
!50 = 620960027832821612639424806694551108812720525606160920420940314
!60 = 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70 = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80 = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
!90 = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
!100 = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
!110 = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
length !1000 = 2565
length !2000 = 5733
length !3000 = 9128
length !4000 = 12670
length !5000 = 16322
length !6000 = 20062
length !7000 = 23875
length !8000 = 27749
length !9000 = 31678
length !10000 = 35656

Seed7

<lang seed7>$ include "seed7_05.s7i";

 include "bigint.s7i";

const func bigInteger: leftFact (in integer: n) is func

 result
   var bigInteger: leftFact is 0_;
 local
   var bigInteger: factorial is 1_;
   var integer: i is 0;
 begin
   for i range 1 to n do
     leftFact +:= factorial;
     factorial *:= bigInteger conv i;
   end for;
 end func;

const proc: main is func

 local
   var integer: n is 0;
 begin
   writeln("First 11 left factorials:");
   for n range 0 to 10 do
     write(" " <& leftFact(n));
   end for;
   writeln;
   writeln("20 through 110 (inclusive) by tens:");
   for n range 20 to 110 step 10 do
     writeln(leftFact(n));
   end for;
   writeln;
   writeln("Digits in 1,000 through 10,000 by thousands:");
   for n range 1000 to 10000 step 1000 do
     writeln(length(str(leftFact(n))));
   end for;
   writeln;
 end func;</lang>

Output:

First 11 left factorials:
 0 1 2 4 10 34 154 874 5914 46234 409114
20 through 110 (inclusive) by tens:
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

Digits in 1,000 through 10,000 by thousands:
2565
5733
9128
12670
16322
20062
23875
27749
31678
35656

Tcl

<lang tcl>proc leftfact {n} {

   set s 0
   for {set i [set f 1]} {$i <= $n} {incr i} {

incr s $f set f [expr {$f * $i}]

   }
   return $s

}

for {set i 0} {$i <= 110} {incr i [expr {$i>9?10:1}]} {

   puts "!$i = [leftfact $i]"

} for {set i 1000} {$i <= 10000} {incr i 1000} {

   puts "!$i has [string length [leftfact $i]] digits"

}</lang>

Output:

!0 = 0
!1 = 1
!2 = 2
!3 = 4
!4 = 10
!5 = 34
!6 = 154
!7 = 874
!8 = 5914
!9 = 46234
!10 = 409114
!20 = 128425485935180314
!30 = 9157958657951075573395300940314
!40 = 20935051082417771847631371547939998232420940314
!50 = 620960027832821612639424806694551108812720525606160920420940314
!60 = 141074930726669571000530822087000522211656242116439949000980378746128920420940314
!70 = 173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
!80 = 906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
!90 = 16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
!100 = 942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
!110 = 145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314
!1000 has 2565 digits
!2000 has 5733 digits
!3000 has 9128 digits
!4000 has 12670 digits
!5000 has 16322 digits
!6000 has 20062 digits
!7000 has 23875 digits
!8000 has 27749 digits
!9000 has 31678 digits
!10000 has 35656 digits

zkl

Translation of: D

<lang zkl>var BN=Import("zklBigNum");

fcn leftFact(n){

  [1..n].reduce(fcn(p,n,rf){ p+=rf.value; rf.set(rf.value*n); p },
     BN(0),Ref(BN(1)));

}</lang> <lang zkl>println("First 11 left factorials:\n", [0..10].apply(leftFact)); lfs:=[20..111,10].apply(leftFact); println(("\n20 through 110 (inclusive) by tens:\n" + "%d\n"*lfs.len()).fmt(lfs.xplode()));

println("Digits in 1,000 through 10,000 by thousands:\n",

    [0d1_000..0d10_000, 1000].pump(List,fcn(n){leftFact(n).toString().len()}));</lang>

Output:

First 11 left factorials:
L(0,1,2,4,10,34,154,874,5914,46234,409114)

20 through 110 (inclusive) by tens:
128425485935180314
9157958657951075573395300940314
20935051082417771847631371547939998232420940314
620960027832821612639424806694551108812720525606160920420940314
141074930726669571000530822087000522211656242116439949000980378746128920420940314
173639511802987526699717162409282876065556519849603157850853034644815111221599509216528920420940314
906089587987695346534516804650290637694024830011956365184327674619752094289696314882008531991840922336528920420940314
16695570072624210767034167688394623360733515163575864136345910335924039962404869510225723072235842668787507993136908442336528920420940314
942786239765826579160595268206839381354754349601050974345395410407078230249590414458830117442618180732911203520208889371641659121356556442336528920420940314
145722981061585297004706728001906071948635199234860720988658042536179281328615541936083296163475394237524337422204397431927131629058103519228197429698252556442336528920420940314

Digits in 1,000 through 10,000 by thousands:
L(2565,5733,9128,12670,16322,20062,23875,27749,31678,35656)