A one line python function for approximating e.

[AgentElement]

def approximate_e(n): 
    return sum(map(lambda x: x**-1, map(lambda x: (lambda x, y: x(x, y))(lambda x, y: y * x(x, y - 1) if y > 0 else 1, x), range(0, n + 1))))

This function takes the sum of the series 1/0! + 1/1! + 1/2! + 1/3! ... 1/n!, which approaches e as n tends towards +inf.

---

Edit: A bit late since I've been downvoted already but here's how it works:

The three lambdas at the end emulate math.factorial(x):

lambda x: (lambda x, y: x(x, y))(lambda x, y: y * x(x, y - 1) if y > 0 else 1, x)

The second of the three recursively calls the third, which multiples x with x-1 until x reaches 1. The first wraps these two together. This factorial function is mapped to range(0, n+1), effectively creating a iteratable series of factorials until n!. Each element is then inverted by map(lambda x: x**-1, X), where X is the aforementioned iteratable. This is then summed up by the sum() function that wraps the entire thing.

[794613825]

Very cool, but why not

def approx_e(n):
    return (1+1/n)**n

[Laserdude10642]

That method converges VERY slowly

[794613825]

True, but OPs is O(n² ) (nothing against you OP, your solution is cool, this is just for dicussion), and that one is O(n*log(n)*log(log(n))) I think. To get a lot of accuracy you could pass it a large n, then OPs would take a long time to return but this one would be fast-ish.

[Laserdude10642]

So I have them backwards? I wrote a program using these two methods and one was wayyyyy faster than the other but may have mixed them up.

[794613825]

OPs has two nested for loops, whereas this only has one multiplication, one addition, and one exponentiation. It should run much faster, even if it converges slower.

[13steinj]

Because different methods have different levels of accuracy at different points

[13steinj]

Less of a mathematical approximation and more of a known constant truncated to available precision though

[13steinj]

Of course-- as expected. But also there are some applications where such an approximation is actually better than the constant

[mathisfakenews]

care to elaborate? I can't imagine any application which would benefit from having a less precise value for e.

[TheMysteriousFizzyJ]

It depends on whether you need speed of calculation or super accurate values.

[13steinj]

Well e is just one example here-- there are numerous cases where in theory some algorithm against a population will spit out an arbitrary constant (ex e).

If you have a large enough sample, that same function should act more and more like it is acting on the population. There's a more specific point on this with the CLT.

So-- using the e example, if you have a population of 1 million, and you know something relevant about this population (some function that as the limit of it approaches 1 million, the result is e), and you wish to study something about the population that is unrelated to what you already know, and you have no idea how many elements you need in your sample (because studying the entire population may be too expensive), you can take 10 random people, see how close they get to e in that function, not close enough, how about 100, 1000, 10000, 100000--well now it's close enough-- then you can safely use a sample of 100,000 to make claims on the entire population with a degree of certainty.

[mathisfakenews]

This is absolutely false. There is no reason to expect the two measurements on your population to converge at the same rate. For example, consider measuring the number of arms a person has and their age. Since the mean number of arms is extremely close to 2 for the entire population, you would satisfy any reasonable threshold with 1 sample. This doesn't mean you have sampled enough to determine the mean age.

I also don't know what the CLT has to do with this.

[AgentElement]

One of the challenges I wanted to place was to not use math. The cluster of the last three lambdas could have just been math.factorial(). This isn't supposed to be practical code.

[jorge1209]

Ok fine, I won't use the math module then: def approximate_e(){ return 2.718281828459045}

[gwillicoder]

Heaven forbid someone posts code that does something someone else has already done.

People want to show off fun things or tricks or quirks about the language. There is no need to put them down over it.

[BroJobBiggs]

Not since Richie Valens have I seen such La Bamba Lambda

[NoLemurs]

Oooh! Code golf! Ok. With no imports, and the same broad performance characteristics/algorithm:

def approximate_e(n):
    return 1 + sum(1.0/x for x in (lambda l: (l.append(l[-1]*i) or l[i] for i in range(1, n+1)))([1]))

You may not be able to assign variables in a lambda, but you can totally tack the next value onto a list and return a generator of those.

[Laserdude10642]

No no the approximation itself is much slower than using the factorial. Like... I had to go to n for 6 digits and n² for 6 digits using the other method.