How can I make this code faster in Python?

Question

input_numbers=list(map(int,input().split()))
sum_number=0

def my_gen(a):
    i=0
    while i <= a:
        yield i
        i += 1

for i in my_gen(input_numbers[0]):
    sum_number += i**input_numbers[1]

print(sum_number%1000000009)

I tried not using generator, but it was too slow. so, tried again with generator and it was slow too.

How can I make this faster?//

More information: My scoring bot is saying Time out. and (1<=input_numbers[0]<=1,000,000,000) (1<=input_numbers[1]<=50)

& Numpy cant be used

Well, you can substitute your `my_gen()` function with `range()` to get started. — MattDMo, Jan 01 '21 at 00:21
Why do you think looping over integers is the bottleneck here? The thing you should try to optimize is the repeated exponentiation. Your `my_gen` simply reimplements `range` poorly. — tripleee, Jan 01 '21 at 00:24
You should probably mention in your question what your code is supposed to do. — khelwood, Jan 01 '21 at 01:02
What do you mean by "faster"? Do you have some test case that proves that this doesn't perform well enough to meet your requirements? — EJoshuaS - Stand with Ukraine, Jan 01 '21 at 01:14
@EJoshuaS-ReinstateMonica yes. I'm studying algorithm and.scoring bot give me 3 correct over 5. 2 is because of Time out. — elon jeong, Jan 01 '21 at 03:47
What did the discussion on leetcode say? I'm pretty sure this is a problem there. — David Ehrmann, Jan 01 '21 at 04:14
@khelwood it's justkind of leetcode thing. I have to get ```sum_number%1000000009``` — elon jeong, Jan 01 '21 at 05:09

Alain T. · Answer 1 · 2021-01-02T21:29:02.450

You can use Faulhaber's formula which will only require a loop over the power value (rather than the billion numbers from 0 to N).

from fractions import Fraction
from functools import lru_cache
@lru_cache()
def bernoulli(n,result=True): # optimized version
    A = [Fraction(1,n+1)]
    for j,b in enumerate(bernoulli(n-1,False) if n else []):
        A.append((n-j)*(b-A[-1]))
    return A[-1] if result else A

@lru_cache()
def comb(n,r):
    return 1 if not r else comb(n,r-1)*(n-r+1)//r

def powerSum(N,P):
    result = sum(comb(P+1,j) * bernoulli(j) * N**(P+1-j) for j in range(P+1))
    return (result / (P+1)).numerator

output:

powerSum(100,3) # 25502500

sum(i**3 for i in range(100+1)) # 25502500 (proof)

powerSum(1000000000,50)%1000000009 
# 265558322 in 0.016 seconds on my laptop

sum(i**50 for i in range(1000000000+1))%1000000009 
# 265558322 (proof in 16.5 minutes)

I wrote a version [using ints modulo 1000000009 instead of fractions](https://preview.tinyurl.com/y77dyqew) now, seems to be about 15 times faster on that large case (see benchmark results near the bottom there). — Kelly Bundy, Jan 02 '21 at 22:07

score 0 · Accepted Answer · answered Jan 01 '21 at 04:13

The code is slow because you're taking large exponents of large numbers. But the final output doesn't require the full sum, just the modulo. So you can apply basic modular arithmetic to keep the numbers in your calculation smaller while getting the same final answer.

score 0 · Answer 3 · answered Jan 04 '21 at 09:25

0

This is the bad part of problem: https://projecteuler.net/problem=429 But the good parts is to solve it yourself.

answered Jan 04 '21 at 09:25

Glauco

1,385
2
10
20

How can I make this code faster in Python?

3 Answers3