import random
import heapq
import benchmark
def nth_ele1(lst, n):
pivot = lst[0]
below = [s for s in lst if s < pivot]
above = [s for s in lst if s > pivot]
i, j = len(below), len(lst) - len(above)
if n < i : return nth_ele1(below, n)
if n >= j : return nth_ele1(above, n-j)
else: return pivot
def nth_ele2(lst, n):
return heapq.nlargest(n, lst)[-1]
if __name__ == '__main__':
lst = [2,2,2,2,2,2,2]
benchmark.rt(nth_ele1, lst,6)
benchmark.rt(nth_ele2, lst,6)
import benchmark
def hammingweight1(n):
count = 0
while n:
n &= n -1
count += 1
return count
def hammingweight2(n):
n = (n & 0x55555555) + ((n>>1) & 0x55555555)
n = (n & 0x33333333) + ((n>>2) & 0x33333333)
n = (n & 0x0f0f0f0f) + ((n>>4) & 0x0f0f0f0f)
n = (n & 0x00ff00ff) + ((n>>8) & 0x00ff00ff)
n = (n & 0x0000ffff) + ((n>>16) & 0x0000ffff)
return n
if __name__ == '__main__':
assert hammingweight1(111111143) == hammingweight2(111111143)
benchmark.rt(hammingweight1, 111111143)
benchmark.rt(hammingweight2, 111111143)
import itertools
import benchmark
# fast, but not take account to repeat element
def perm1(lst,n):
return itertools.permutations(lst,n)
# faster and not consider the repeat element
def perm2(lst, n):
if n == 0:
yield []
for i in range(len(lst)):
rest = lst[:i] + lst[i+1:]
for p in perm2(rest, n-1):
yield lst[i:i+1] + p
if __name__ == '__main__':
lst = [0,1,2,3,4,5,6,7,8,9]
benchmark.rt(perm1 , lst, len(lst))
benchmark.rt(perm2 , lst, len(lst))
if n % 2 == 0:
fibs[n] = ((2 * fib3((n / 2) - 1)) + fib3(n / 2)) * fib3(n / 2)
return fibs[n]
else:
fibs[n] = (fib3((n - 1) / 2) ** 2) + (fib3((n+1) / 2) ** 2)
return fibs[n]
def fib4(n): # write state, faster, same to tail recursion
a, b = 0, 1
for _ in xrange(n):
a, b = b, a + b
return a
def fib5(n): # tail recursive version
def fib_tail(end, a, b, start):
if end == start:
return a + b
else:
return fib_tail(end, b, a+b, start+1)
if( n == 1 or n == 2 ):
return 1
else:
return fib_tail(end, 1, 1, 3)
if __name__ == '__main__':
benchmark.rt(fib1, 20)
benchmark.rt(fib2, 100)
benchmark.rt(fib3, 100)
benchmark.rt(fib4, 1000)
benchmark.rt(fib4, 1000)
