Factorial

Factorial  计算阶乘

In mathematics, the factorial of a non-negative integer n, denoted by n!, is the product of all positive integers less than or equal to n. For example: 5! = 5 * 4 * 3 * 2 * 1 = 120. By convention the value of 0! is 1.

Write a function to calculate factorial for a given input. If input is below 0 or above 12 throw an exception of type ArgumentOutOfRangeException (C#) or IllegalArgumentException (Java).

More details about factorial can be found here: http://en.wikipedia.org/wiki/Factorial

刚开始没有注意题目的提示，可以直接判断大于12，就溢出了。想到了使用checked关键字来检查是否溢出。

https://msdn.microsoft.com/zh-cn/library/74b4xzyw.aspx   checked关键字的用法

public static class Kata
    {
        public static int Factorial(int n)
        {
            try
            {
                return Recursion(n);
            }
            catch
            {
                throw;
            }
        }

        public static int Recursion(int n)
        {
            if (n < )
            {
                throw new ArgumentOutOfRangeException();
            }
            try
            {

                int factorial = ;
                if (n >= )
                {
                    checked
                    {
                        factorial = n * Recursion(n - );
                    }
                }
                return factorial;
            }
            catch
            {
                throw new ArgumentOutOfRangeException();
            }
        }
    }

其他人的解法：

递归计算

public static int Factorial(int n)
  {
    if(n <  || n > )
      throw new ArgumentOutOfRangeException();
    return n >  ? n * Factorial(n - ) : ;
  }

using System;
using System.Linq;

public static class Kata
{
  public static int Factorial(int n)
  {
    if(n <  || n > ) throw new ArgumentOutOfRangeException();

    return Enumerable.Range(, n).Aggregate(, (x,y) => x * y);
  }
}

需要注意的是

public static TAccumulate Aggregate<TSource, TAccumulate>(
this IEnumerable<TSource> source,
TAccumulate seed,
Func<TAccumulate, TSource, TAccumulate> func
)

Type Parameters

TSource

The type of the elements of source.  源数据中的数据的类型

TAccumulate

The type of the accumulator value.  累加器的值的类型

Parameters

source

Type: System.Collections.Generic.IEnumerable<TSource>

An IEnumerable<T> to aggregate over.     //源数据

seed

Type: TAccumulate

The initial accumulator value.    累加器的初始值

func

Type: System.Func<TAccumulate, TSource, TAccumulate>

An accumulator function to be invoked on each element.   每一个元素调用的累加器函数

Return Value

Type: TAccumulate
The final accumulator value.    返回值是累加器的最终值

https://msdn.microsoft.com/zh-cn/library/bb549218(v=vs.110).aspx

The Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) method
makes it simple to perform a calculation over a sequence of values.

此方法使得在一个序列上进行计算变得简单

This method works by calling func one time for each element in source.

此方法的通过让序列中的每个元素都会调用一次func委托来工作。

Each time func is called, Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) passes both the element from the sequence and an aggregated value (as the first argument to func).

每一次调用委托的时候，此方法传递序列中的当前元素以及累加值(累加值是作为fun中的第一个参数的)

The value of the seed parameter is used as the initial aggregate value.

seed参数作为累计值的初始值

The result of func replaces the previous aggregated value. Aggregate<TSource, TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate, TSource, TAccumulate>) returns the final result of func.

func委托的返回值，会替代之前的累计值。  此方法返回func委托的最终结果

To simplify common aggregation operations, the standard query operators also include a general purpose count method, Count, and four numeric aggregation methods, namely Min, Max, Sum, and Average.

为了简化通用的聚合操作，标准查询操作符也包含了一个通过计数方法Count，此外，还有4个数值聚合方法，名为Min，Max，Sum和Average。

最后分析一下

Enumerable.Range(1, n).Aggregate(1, (x,y) => x * y)

Enumerable.Range(1, n)通过这个获取1到n的序列

Aggregate(1, (x,y) => x * y)其中1作为累加值的初始值  lambda表达式中的第一个参数表示的就是累加值，然后将x*y的值替换掉累加值，并作为下一次调用的x传入

遍历1到n

1     x=1,y=1   x=1*1;

2     x=1,y=2  x= 1*2;

3     x=2,y=3  x= 2*3

特别需要注意的是，当n=0的时候；Enumerable.Range(1, 0)中一个元素也没有，直接返回了累加器的初始值1