Computer Science @USC
Tried writing some one liners for few problems in Projecteuler . had a good time writing them.. sharing the same..
I have used some functional programming techniques which make programming a lot of fun
map(function, sequence) : calls function(item) for each of the sequence's items and returns a list of the return values.
This is equivalent to :
which is known as list comprehension.
which boils down to:
for element in [ '1', '2', '3' ]:
ints.append ( int( element) )
We just applied an int function to all the elements of a list which contained numbers as strings.
reduce(function, sequence) : returns a single value constructed by calling the (binary) function on the first two items of the sequence, then on the result and the next item, and so on. For example, to compute the sum of the numbers 1 through 10:
filter(function, sequence) returns a sequence consisting of those items from the sequence for which function(item) is true
if num % 2 == 0:
return True
return False
filter( is_even , [ 1, 2, 3, 4] ) - > [ 2, 4]
Lambda functions : are used to create anonymous functions, i.e. functions which do not have a name. They are used as follows.
Previously we saw filtering of elements using the is_even method, the same filter using lambda function would look like this:
One liners for some of the problems
This is super neat explanation of the concepts of functional programming capabilities of Python and a demonstration of how powerful this paradigm of programming can be maga. /me super likes this :)
But one thing maga, for problem 4, a mix of functional and non-functional approach might be multiple times faster than the purely functional approach. Some empirical data I collected:
Purely functional approach (Code from your post)
In [32]: %timeit max(filter( lambda x : str(x) == str(x)[::-1], reduce(list.__add__, [ [i * r for i in range(100,999)] for r in range(100,999) ] )))
1 loops, best of 3: 15.9 s per loop
Slightly more optimized version by mixing procedural programming with functional approach
In [34]: def pal_in_series(i):
....: for j in range(999, 99, -1):
....: x = i * j
....: if str(x) == str(x)[::-1]: return x
....:
In [35]: %timeit max(map(pal_in_series, range(999, 99, -1)))
1 loops, best of 3: 482 ms per loop
By optimizing it a bit more:
In [36]: def pal_in_series(i):
....: for j in range(i-1, 99, -1):
....: x = i * j
....: if str(x) == str(x)[::-1]: return x
....:
In [38]: %timeit max(map(pal_in_series, range(999, 99, -1)))
1 loops, best of 3: 266 ms per loop
I think it can be optimized more maga, if we use mathematical properties correctly. But this was just to demonstrate to others that why Python is one of "THE" most powerful language out there. These kinds of optimizations are not possible in purely functional or purely procedural or purely object oriented or whatever "purely" languages. Python makes it so powerful by combining the best of many worlds! And above all, this is done in such an expressive way so that it is so easy to write the code, and read and understand it by others!
Absolutely.. reduce(list.__add__, 2D list ) is taking most of the time.. flattening a list is quite a time consuming task. I agree with other optimizations that you have mentioned. I just figured out that one can use iterators in range objects even in list comprehension. I had assumed that i will not work when i wrote this :) but it works..
reduce(list.__add__, [ [ i * r for i in range( r+1, 1000) ] for r in range(100,1000) ])
One thing which makes me want to use python is: We tell python what to do and not how to do :)
PS: And I wasn't aware of this timeit.. very easy to time code.. Thanks.. :)
<quote>I just figured out that one can use iterators in range objects even in
list comprehension. I had assumed that i will not work when i wrote this
:) but it work</quote>
is pretty useful maga :)
<quote>One thing which makes me want to use python is: We tell python what to do and not how to do :)</quote>
is the best part of Python :)