Founder & CTO @SMERGERS & @wealthrox
Past - Dev Infra @Google · RF @NI · CS @USC

Currently
Founder & CTO @SMERGERS & @wealthrox
Previously
Dev Infra Intern @Google NYC RF @NI-WCDMA
Computer Science @USC
Contact
hey [at] krishnabharadwaj.info
07-Jun-2011

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.

map ( int, [ '1', '2', '3' ] )

This is equivalent to :

[ int ( x ) for x in [ '1' , '2' , '3' ] ]

which is known as list comprehension.

which boils down to:

ints = [ ]
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:

reduce( sum , range(1, 11))

filter(function, sequence) returns a sequence consisting of those items from the sequence for which function(item) is true

def is_even(num):
  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:

filter( lambda x: x% 2 == 0 , [ 1 , 2, 3 , 4] )

One liners for some of the problems


Note : Complexity of many of the solutions mentioned is bad.. This code was written to explore map, reduce, filter methods in python. If you think it can be improved ( by still maintaining the one line rule ), please leave a comment.

# Problem 1
"""Find the sum of all the multiples of 3 or 5 below 1000."""
sum( [ num for num in range(3,1000) if num % 3 == 0 or num % 5 == 0 ] )
# Problem 4
"""
A palindromic number reads the same both ways. The largest palindrome
made from the product of two 2-digit numbers is 9009 = 91 99.
Find the largest palindrome made from the product of two 3-digit numbers.
"""
print max(filter( lambda x : str(x) == str(x)[::-1],
reduce(list.__add__,
[ [i * r for i in range(100,1000)] for r in range(100,1000) ] )))
# Update : Figured out that we can create a 1-D list using nested loops like this:
print max(filter( lambda x : str(x) == str(x)[::-1],
[ i * r for i in range(100,1000) for r in range(100,1000) ] ))
# Problem 6
"""
The sum of the squares of the first ten natural numbers is,
1^2 + 2^2 + ... + 10^2 = 385
The square of the sum of the first ten natural numbers is,
(1 + 2 + ... + 10)^2 = 552 = 3025
Hence the difference between the sum of the squares of the first
ten natural numbers and the square of the sum is 3025 385 = 2640.
Find the difference between the sum of the squares of the
first one hundred natural numbers and the square of the sum.
"""
( sum ( range(1,101) ) ** 2) - sum([ x*x for x in range(1,101)] )
# Problem 8
"""
Find the greatest product of five consecutive
digits in the 1000-digit number.
"""
num = ''.join("""
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
""".split('\n') ) # weird way to read the data.
print max( [ reduce( lambda x, y: int(x) * int (y),
[c for c in (num[i : i + 5])] ) for i in range( len(num) - 5 ) ] )
# Problem 20
"""
n! means n (n 1) ... 3 2 1
For example, 10! = 10 9 ... 3 2 1 = 3628800,
and the sum of the digits in the number 10! is 3 + 6 + 2 + 8 + 8 + 0 + 0 = 27.
Find the sum of the digits in the number 100!
"""
sum( map ( int , [c for c in str( reduce( lambda x, y: x * y, range(1, 101) ) ) ] ))

madhusudancs June 7, 2011

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!

Krishna Bharadwaj June 8, 2011

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.. :)

madhusudancs June 8, 2011

<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 :)