I just started playing with lambdas and Linq expression for self learning. I took the simple factorial problem for this. with the little complex scenario where find the factorial for given n numbers (witout using recursive loops).
Below the code i tried. But this is not working.
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());
}
this is the procedure i used
- loop through the numbers 1 to n -- Enumerable.Range(1, range).
- select each number x and again loop them upto x times (instead of recursion)
- and select the numbers Where(y => (y > 1)) greater than 1 and multiply that with (y-1)
i know i messed up somewhere. can someone tell me whats wrong and any other possible solution.
EDIT:
i am going to let this thread open for some time... since this is my initial steps towards lambda.. i found all the answers very useful and informative.. And its going to be fun and great learning seeing the differnt ways of approaching this problem.
I tried to come up with something resembling F#'s scan function, but failed since my LINQ isn't very strong yet.
Here's my monstrosity:
If anyone knows if there actually is an equivalent of F#'s scan function in LINQ that I missed, I'd be very interested.
Currently there's no recursion - that's the problem. You're just taking a sequence of numbers, and projecting each number to "itself * itself-1".
The simple and inefficient way of writing a factorial function is:
Typically you then get into memoization to avoid having to repeatedly calculate the same thing. You might like to read Wes Dyer's blog post on this sort of thing.
Just to continue on Jon's answer, here's how you can memoize the factorial function so that you don't recompute everything at each step :
EDIT: actually the code above is not correct, because
factorial
callsfactorial
, notfactorialMemoized
. Here's a better version :With that code,
factorial
is called 10 times, against 55 times for the previous versionSimple although no recursion here: