Python 在10000位数字中查找13个相邻数字的最大乘积

似乎无法找出我的代码出了什么问题（Project Euler问题8）。我想在下面的10000位数字中找到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)

编辑：解决了！最大_乘积定义错误。。。它承担了最近的“当前产品”的价值，该价值恰好大于先前的产品，而不一定是最大的产品

正确，尽管不是超级高效的代码：

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

---

我没有检查您的方法不起作用的原因，但您可以通过以下方法轻松解决此问题：

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:

直接切片，因为您当前的代码似乎基于错误的计划，因此无法正常工作 --或者至少是一个我不完全理解的计划。这是另一种方式 考虑一下算法

假设我们有这个号码：

7316717

。我们正在寻找最大值 三个相邻数字的乘积。我们可以如下解决这个问题。我是 硬编码每个步骤的结果，但您应该能够编写Python 计算每个部分的代码

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

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

• 计算他们的产品：

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

• 找到它们的最大值

  answer = max(products)
  

---

我还没有检查您的代码，以何种方式它将无法工作

但解决问题的一个简单方法是，从输入数据中生成所有可能的切片，其中包含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

Maximum adjacent numbers product: 23514624000
Time taken: 4.34899330139 ms

---

下面是滑动窗口思想的一个实现，经过修改，它只适用于不包含零的字符串：

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

连续数字的最大乘积。精妙之处在于enumerate的工作方式。当您在

s[k://code>上使用
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
您可以使用如下列表理解来提高代码效率：

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"

输出：

# Best time
Solution: 23514624000   elapsed: 1.31226ms

Maximum adjacent numbers product: 23514624000
Time taken: 4.34899330139 ms

这个问题可能属于。为什么不在
0
上拆分，分别处理每一部分，每个部分的逻辑都要简单得多？另外，如果这是Python 3，您需要了解
/
与
/
之间的区别。您的代码以什么方式不工作？@Teodor:CR代表工作代码：请阅读。@martineau它给出了错误的答案：313528320.0而不是23514624000OP的方法是使用13位数的滑动窗口，通过乘以进入窗口的下一个数字，再除以离开窗口的数字来更新window@user3080953我懂了。好吧，这可能行得通，但可能很棘手，因为需要一些额外的逻辑来处理零：当一个人进入滑动窗口时，你的运行产品变成零（这很容易），但当零离开窗口时，你需要重新计算运行产品。窗口中可能有多个零。听起来我很容易犯错误。是的，伙计，很棒的解决方案，事实上你可以用islice和另一个map
max（map（lambda*x:reduce（operator.mul，x），*map（lambda x:islice（my_int_list，x，None），xrange（13））
或者这个：
max（reduce（mul，xs[i:i+13]，1）表示范围内的i（0，len（xs）-13+1））