Left factorials,   !n,   may refer to either   subfactorials   or to   factorial sums;

the same notation can be confusingly seen being used for the two different definitions.

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

     !n`   
     !n  
     n¡  


(It may not be visually obvious, but the last example uses an upside-down exclamation mark.)



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


   



!
n
=

∑

k
=
0


n
−
1


k
!


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




 where


   



!
0
=
0


{\displaystyle !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   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


Related task

   permutations/derangements (subfactorials)


import BigInt
 
func factorial<T: BinaryInteger>(_ n: T) -> T {
  guard n != 0 else {
    return 1
  }
 
  return stride(from: n, to: 0, by: -1).reduce(1, *)
}
 
prefix func ! <T: BinaryInteger>(n: T) -> T {
  guard n != 0 else {
    return 0
  }
 
  return stride(from: 0, to: n, by: 1).lazy.map(factorial).reduce(0, +)
}
 
for i in 0...10 {
  print("!\(i) = \(!i)")
}
 
print()
 
for i in stride(from: BigInt(20), through: 110, by: 10) {
  print("!\(i) = \(!i)")
}
 
print()
 
print("!1000 = \((!BigInt(1000)).description.count) digit number")
 
print()
 
for i in stride(from: BigInt(2000), through: 10_000, by: 1000) {
  print("!\(i) = \((!i).description.count) digit number")
}