Humble numbers: Difference between revisions

from itertools import count, groupby, islice

from math import floor, sqrt

def isHumble(x):

return all(8 > x for x in primeFactors(x))

return filter(isHumble, count(1))

for tpl in take(5)(

groupby(map(compose(len, str), humbles()))

# compose :: ((a -> a), ...) -> (a -> a)

def compose(*fs):

'''Composition, from right to left,

of a series of functions.

'''

return lambda x: reduce(

lambda a, f: f(a),

fs[::-1], x

)

# primeFactors :: Int -> [Int]

def primeFactors(n):

'''A list of the prime factors of n.

'''

def f(qr):

r = qr[1]

return step(r), 1 + r

def step(x):

return 1 + (x << 2) - ((x >> 1) << 1)

def go(x):

root = floor(sqrt(x))

def p(qr):

q = qr[0]

return root < q or 0 == (x % q)

q = until(p)(f)(

(2 if 0 == x % 2 else 3, 1)

)[0]

return [x] if q > root else [q] + go(x // q)

return go(n)

return lambda xs: list(islice(xs, n))

# until :: (a -> Bool) -> (a -> a) -> a -> a

def until(p):

'''The result of repeatedly applying f until p holds.

The initial seed value is x.

'''

def go(f, x):

v = x

while not p(v):

v = f(v)

return v

return lambda f: lambda x: go(f, x)

(5, 356)</pre>