查找10,000位數字中13個相鄰數字的最大乘積

Question

似乎無法弄清楚我的代碼有什么問題（Project Euler問題8）。 我想在下面的10,000位數字中找到13個相鄰數字的最大乘積，我的答案是錯誤的。

my_list = list('7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450')

for i in range(1000):
    my_list[i] = int(my_list[i])

previous_product = 1
for x in range(13):
  previous_product *= my_list[x]
current_product = previous_product*my_list[13]/my_list[0]

for i in range(1, 987):
  if current_product > previous_product:
    maximum_product = current_product
  previous_product = current_product
  if my_list[i]==0:
    current_product = 1
    for x in range(13):
      current_product *= my_list[i+x+1]
  else:
    current_product = previous_product*my_list[i+x+1]/my_list[i]

print(maximum_product)

編輯：解決了！ maximum_product的定義錯誤...它采用了最新“當前產品”的價值，該價值恰好大於以前的產品，不一定是最大的產品。

正確，盡管不是超級高效的代碼：

   my_list = list('7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450')

for i in range(1000):
    my_list[i] = int(my_list[i])

previous_product = 1
for x in range(13):
  previous_product *= my_list[x]
current_product = previous_product*my_list[13]/my_list[0]

large_products = []

for i in range(1, 987):
  if current_product > previous_product:
    large_products.append(current_product)
  previous_product = current_product
  if my_list[i]==0:
    current_product = 1
    for x in range(13):
      current_product *= my_list[i+x+1]
  else:
    current_product = previous_product*my_list[i+x+1]/my_list[i]

print(max(large_products))

Answer 1

我沒有檢查為什么你的方法不起作用，但你可以輕松解決這個問題：

import operator
from functools import reduce

my_int_list = [int(char) for char in my_list]

max(map(lambda *x: reduce(operator.mul, x), 
        my_int_list[0:], 
        my_int_list[1:], 
        my_int_list[2:], 
        my_int_list[3:], 
        my_int_list[4:], 
        my_int_list[5:], 
        my_int_list[6:], 
        my_int_list[7:], 
        my_int_list[8:], 
        my_int_list[9:], 
        my_int_list[10:], 
        my_int_list[11:], 
        my_int_list[12:]))

如果這占用了太多內存，您也可以使用itertools.islice而不是使用[idx:]直接切片。

Answer 2

以下是您的滑動窗口構思的實現，已修改，以便它僅適用於不包含零的字符串：

def max_product(s,k):
    s = [int(d) for d in s]
    p = 1
    for d in s[:k]:
        p *= d
    m = p
    for i,d in enumerate(s[k:]):
        p *= d
        p //= s[i]
        if p > m: m = p
    return p

在上面的s是一串長度至少為k的非零數字（在你的問題中k = 13 ）。 它返回k連續數字的最大乘積。 微妙的方式是枚舉作品。 當你在s[k:]上使用enumerate時，索引i從0開始 - 這正是你想要在第一次通過該循環時刪除的因子。

將此應用於

data = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'

首先拆分成不包含零的塊，並且長度至少為13位：

chunks = [s for s in data.split('0') if len(s) >= 13]

有24個這樣的塊。 要獲得總體最大值，只需占用每個塊的最大值：

print(max(max_product(s,13) for s in chunks))

確實打印23514624000

Answer 3

您當前的代碼無法正常工作，因為它似乎是基於錯誤的計划 - 或者至少是基於我不完全理解的計划。 這是考慮算法的另一種方式。

想象一下，我們有這個號碼： 7316717 。 我們正在尋找3個相鄰數字的最大乘積。 我們可以解決這個問題如下。 我正在對每一步的結果進行硬編碼，但您應該能夠編寫Python代碼來計算每個部分。

• 查找所有相鄰的3位數序列：

   seqs = [731, 316, 167, 671, 717] 

• 計算他們的產品：

   products = [21, 18, 42, 42, 49] 

• 找到他們的最大值

   answer = max(products) 

Answer 4

我沒有檢查你的代碼，以及它不起作用的方式。

但是解決問題的一種簡單方法是，從輸入數據中生成所有可能的切片，其中包含13個相鄰數字，然后找到其元素的乘積然后找到它們的最大乘積。

這是一種方法：

data = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'

def product(a):
    prod = 1
    for k in a:
        prod *= int(k)
    return prod

def max_adjacent_number(data, suit=13):
    return max(product(data[k:k+suit]) for k in range(len(data)) if '0' not in data[k:k+suit])


from time import time
start = time()
val = max_adjacent_number(data)
elapsed = time() - start
print("Solution: {0} \telapsed: {1:.5f}ms".format(val, elapsed*1000))

輸出：

# Best time
Solution: 23514624000   elapsed: 1.31226ms

Answer 5

您可以使用列表解析來提高代碼效率，如下所示：

import time
n = str(x) #x is the long number
a = time.time()
result = max(reduce(lambda x, y: x * y, map(int, n[i:i+13])) for i in xrange(len(n)-12) if '0' not in n[i:i+13])
b = time.time()
print "Maximum adjacent numbers product: %d" % result
print "Time taken:", (b-a)*1000, "ms"

輸出：

Maximum adjacent numbers product: 23514624000
Time taken: 4.34899330139 ms