我刚开始用lambda表达式和LINQ表达自我学习演奏。 我把简单的阶乘问题这一点。 与有些复杂场景，找到给出n个数字（不用其他使用递归循环）的阶乘。
下面的代码我试过了。 但是，这是行不通的。
public void FindFactorial(int range)
{
var res = Enumerable.Range(1, range).Select(x => Enumerable.Range(0, x).Where(y => (y > 1)).Select(y => y * (y-1)));
foreach (var outt in res)
Console.WriteLine(outt.ToString());
}
这是我所使用的程序
- Enumerable.Range（1，范围） -通过数字1到n循环。
- 选择每个数x，并再次循环它们高达x倍（而不是递归）
- 和选择号码，当：（Y =>（Y> 1））大于1，乘以与（Y-1）
我知道我搞砸了某个地方。 谁能告诉我什么是错的，任何其他可能的解决方案。
编辑：
我要去让这个线程开启一段时间......因为这是我对λ初始步骤..我发现所有的答案非常有用的信息。而它的将是有趣和很好的学习看到接近的不同的充方式这个问题。
目前没有递归 - 这就是问题所在。 你只是把数字的序列，并突出每个号码“本身*本身-1”。
写一个阶乘函数的简单和低效率的方法是：
Func<int, int> factorial = null; // Just so we can refer to it
factorial = x => x <= 1 ? 1 : x * factorial(x-1);
for (int i = 1; i <= range; i++)
{
Console.WriteLine(factorial(i));
}
通常，你再进入记忆化 ，以避免重复计算同样的事情。 你可能会喜欢读韦斯·戴尔的博客文章上这样的事情。
简单尽管这里没有递归：
public static int Factorial(this int count)
{
return count == 0
? 1
: Enumerable.Range(1, count).Aggregate((i, j) => i*j);
}
3.Factorial() == 6
只是为了继续对乔恩的答案，这里是你如何能memoize的阶乘的功能，这样你就不会再计算每一步的一切：
public Func<T, TResult> Memoize<T, TResult>(Func<T, TResult> func)
{
Dictionary<T, TResult> _resultsCache = new Dictionary<T, TResult>();
return (arg) =>
{
TResult result;
if (!_resultsCache.TryGetValue(arg, out result))
{
result = func(arg);
_resultsCache.Add(arg, result);
}
return result;
};
}
...
Func<int, int> factorial = null; // Just so we can refer to it
factorial = x => x <= 1 ? 1 : x * factorial(x-1);
var factorialMemoized = Memoize(factorial);
var res = Enumerable.Range(1, 10).Select(x => factorialMemoized(x));
foreach (var outt in res)
Console.WriteLine(outt.ToString());
编辑：其实上面的代码是不正确的，因为factorial调用factorial ，不factorialMemoized 。 这里有一个更好的版本：
Func<int, int> factorial = null; // Just so we can refer to it
Func<int, int> factorialMemoized = null;
factorial = x => x <= 1 ? 1 : x * factorialMemoized(x-1);
factorialMemoized = Memoize(factorial);
var res = Enumerable.Range(1, 10).Select(x => factorialMemoized(x));
foreach (var outt in res)
Console.WriteLine(outt.ToString());
与该代码， factorial被称为10倍，对55倍的以前版本
我试着拿出一些类似F＃的扫描功能，但失败了，因为我的LINQ是不是很强呢。
这里是我的怪物：
//this is similar to the folowing F# code:
//let result = [1..10] |> List.scan (fun acc n -> acc*n) 1
var result =
Enumerable.Range(1, 10)
.Aggregate(new List<int>(new[] { 1 }),
(acc, i) => {
acc.Add(i * acc.Last());
return acc;
}
);
foreach(var num in result) Console.WriteLine("{0}",num);
如果有人知道如果确实是在LINQ，我错过了F＃的扫描功能的等效，我会很感兴趣。
