题目8：找出这个1000位数字中连续13个数字乘积的最大值

<url>http://canadianpharmaciesrxbest.com/|pharmacy online</url>, <url>http://canadianonlinepharmacygen.com/|canadian drugstore online</url>, <url>http://canadianpharmaciesdiscount.com/|discount pharmacy</url>, <url>http://canadianpharmacieslink.com/|ed meds online</url>

refracted_ray

题目中的1000位数字怎么复制进代码啊，不让复制啊

refracted_ray

a=7316717653 # 10位数
a_s=str(a) # 转换为字符串
a_list=list(a_s) # 转换为列表
b=[] # a_list的每个项转换为数值的列表
for i in a_list:
        j=int(i)
        b.append(j)

c=[] # 存储m以及对应的b[k]
for k in range(2,10):
        m=b[k]*b[k-1]*b[k-2]
        c.append((m,k))
c.sort(reverse=True) # 以m的大小为准，从大到小排列

"""
c[0][0]=m，c[0][1]=k
"""
print ('%d=%d*%d*%d'%(c[0][0],b[c[0][1]],b[c[0][1]-1],b[c[0][1]-2]))

1000位数和10位数无本质区别，这里为了方便，只取本题1000位数的前10位，求连续3个数乘积的最大值

结果是210=7*6*5

塔利班

b="7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"

index=0
m=0
for i in range(989):
    c=b[i:i+13]
    if '0' in c:
        continue
    t=eval('*'.join(list(c)))
    if t>m:
        m=t
        index=i

print('目标字符串',m,'：最大结果',b[index:index+13])

山有扶苏啊

def find_max(x):
    i = 0
    result = []
    while i <= len(str(x)) - 13:
        s = 1
        for t in str(x)[i : i+13]:
            s = s * int(t)
        i += 1
        result.append(s)  
    print(max(result))

find_max(7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450)
            

答案是23514624000
做之前试了一下采集的数据数量，看来数学不大好

cupbbboom

# 实现求一个1000位数字组成的数中
# 连续13位数乘积最大的序列及其乘积

str_a = '''
73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450
'''
import re
str_a = re.sub('\n','',str_a)
result =[]
x = 0 
while x < len(str_a) - 11:
        l = str_a[x:x+13]
        y = 0
        
        if '0' not in l:  # 跳过包含0的
                z = 1
                while y < len(l):
                        z *= int(l[y])
                        y += 1
                result.append(z)
        x += 1
print(max(result))

23514624000

愿你

#include <stdio.h>
typedef unsigned long long  ull;
main()
{
        char a[1000]={"7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"};
        ull max,i,j,t;
        j=0,max=0;
        for(i=0;i<987;i++)
        {
                t=1;
                j=0;
                while(j<13)
                {
                        t=t*(a[i+j]-48);
                        j++;
                }
                if(t>max)
                {
                        max=t;
                }
        }
        printf("%ull", max);
}

不知道为什么我答案算错了

王小召

运行结果：('5576689664895', 23514624000)

                               
登录/注册后可看大图

def get_max(tar):
    slice_str = []
    str_val = []
    str_range = len(tar)

    for i in range(str_range):
        if i <= str_range - 13 and "0" not in str_t[i:(i+13)]:
            result = 0
            for x in range(2, 10):
                result += (str_t[i:(i+13)].count(str(x)))*x
            slice_str.append(str_t[i:(i + 13)])
            str_val.append(result)
    target = slice_str[str_val.index(max(str_val))]
    result = 1
    for each in target:
        result *= int(each)

    return target, result

str_t = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843" \
        "8586156078911294949545950173795833195285320880551112540698747158523863050715693290963295227443043557" \
        "6689664895044524452316173185640309871112172238311362229893423380308135336276614282806444486645238749" \
        "3035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776" \
        "6572733300105336788122023542180975125454059475224352584907711670556013604839586446706324415722155397" \
        "5369781797784617406495514929086256932197846862248283972241375657056057490261407972968652414535100474" \
        "8216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586" \
        "1786645835912456652947654568284891288314260769004224219022671055626321111109370544217506941658960408" \
        "0719840385096245544436298123098787992724428490918884580156166097919133875499200524063689912560717606" \
        "0588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"

print(get_max(str_t))

永恒的蓝色梦想

Python

from math import prod
num = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'
print(max(prod(map(int, num[i - 13 : i])) for i in range(13, len(num))))

1666194196

#include <stdio.h>
void main(){
        //73167176531330624919225119674426574742355349194934
        //96983520312774506326239578318016984801869478851843
        //85861560789112949495459501737958331952853208805511
        //12540698747158523863050715693290963295227443043557
        //66896648950445244523161731856403098711121722383113
        //62229893423380308135336276614282806444486645238749
        //30358907296290491560440772390713810515859307960866
        //70172427121883998797908792274921901699720888093776
        //65727333001053367881220235421809751254540594752243
        //52584907711670556013604839586446706324415722155397
        //53697817977846174064955149290862569321978468622482
        //83972241375657056057490261407972968652414535100474
        //82166370484403199890008895243450658541227588666881
        //16427171479924442928230863465674813919123162824586
        //17866458359124566529476545682848912883142607690042
        //24219022671055626321111109370544217506941658960408
        //07198403850962455444362981230987879927244284909188
        //84580156166097919133875499200524063689912560717606
        //05886116467109405077541002256983155200055935729725
        //71636269561882670428252483600823257530420752963450
        //在这个 1000位正整数中，连续4个数字的最大乘积是 9 × 9 × 8 × 9 = 5832。
        //找出这个 1000位正整数中乘积最大的连续13个数字。它们的乘积是多少？
       
        char a[]={"7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450"};
        int i;
        long long max=0;
        for(i=0;i<1000;i++){
                int j;
                long long chengji = 1;
               
                if(i<=987){//i<=987  j<987+13
                        for(j=i;j<13+i;j++){ //j:0-3 1-4 2-5...996-999
                                chengji*=a[j]-48;  //四个数一组的乘积 （数组定义的是 char类型 里面的数是字符 字符 0的 ASCII码值-48=0...）
                        }
                        if(chengji>max){//比较找出乘积最大的值
                                max=chengji;
                        }
                }
        }
        printf("max=%lld\n",max);
}

foxiangzun

首先，这么长的一段数字里，有 0
其次，将这个数字阵列以 13 个为一个单位来切割，分配到不同的列表中
最后，在列表中没有 0 的前提下，相加的最大值就是相乘的最大值

有了以上三条思路，那么接下来就方便多了，代码如下：

numStr = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'
list1 = []
numDict = {}
for i in range(987) :
        list1 = [int(j) for j in list(numStr[i: i + 13])]
        if 0 not in list1 :
                numDict[sum(list1)] = list1
sorted(numDict)
print(max(numDict), numDict[max(numDict)])

最终运行起来，只花费 0.0135s，结果是：85 [9, 7, 5, 3, 6, 9, 7, 8, 1, 7, 9, 7, 7]

永恒的蓝色梦想

foxiangzun 发表于 2019-11-5 19:47
首先，这么长的一段数字里，有 0
其次，将这个数字阵列以 13 个为一个单位来切割，分配到不同的列表中
最 ...

最后，在列表中没有 0 的前提下，相加的最大值就是相乘的最大值

所以你错了

foxiangzun

永恒的蓝色梦想 发表于 2020-5-2 16:26
所以你错了

确实错了。。1 在这个序列中，也会拉低最终的乘积值，所以 1 也不能在里面。。修改后的代码如下：

numStr = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'
list1 = []
numDict = {}
for i in range(987) :
        list1 = [int(j) for j in list(numStr[i: i + 13])]
        if 0 not in list1 and 1 not in list1 :
                numDict[sum(list1)] = list1
sorted(numDict)
print(max(numDict), numDict[max(numDict)])
flag = 1
for i in numDict[max(numDict)] :
    flag *= i
print(flag)

永恒的蓝色梦想

foxiangzun 发表于 2020-5-3 09:26
确实错了。。1 在这个序列中，也会拉低最终的乘积值，所以 1 也不能在里面。。修改后的代码如下：

根本就不是这么回事，3和8，5和5 ，哪对和大？哪对积大？你的思路本身就是错误的

foxiangzun

永恒的蓝色梦想 发表于 2020-5-3 09:41
根本就不是这么回事，3和8，5和5 ，哪对和大？哪对积大？你的思路本身就是错误的

所以这里必须全部剖成 13 个一组的数，然后算出它们的乘积，最后再来比较结果么。。感觉这样好费内存的说

永恒的蓝色梦想

foxiangzun 发表于 2020-5-3 21:47
所以这里必须全部剖成 13 个一组的数，然后算出它们的乘积，最后再来比较结果么。。感觉这样好费内存的说 ...

是的。
可能你对内存没什么概念，这点内存啥也算不上

leon0149

max = 23514624000
0.000 s

#include <stdio.h>
#include <time.h>

long long mul = 1;

int ToString(char num){
    int n = ((int)num) - 48;
    return n;
}

int main(void)
{
    clock_t start, finish;
    double duration;
    char num[1000] = "7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
    int n;
    long long max = 0;

    start = clock();
    for (int j = 0;j < 1000 - 13;) {
        for (int i = j; i < j + 13; ++i) {
            if (num[i] != '0') {
                n = ToString(num[i]);
                mul = mul * n;
            }
            else {
                j = i + 1;
                goto here;
            }
        }
        max = max > mul ? max : mul;

        mul = 1;
        j ++;
        continue;
        here:
        mul = 1;
    }
    finish = clock();

    printf("max = %lld\n", max);
    duration = (double )(finish - start) / CLOCKS_PER_SEC;
    printf("%.3f s", duration);
    return 0;
}

yhhpf

num = '7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'
num1 = []
for i in range(len(num) - 12):
    value = 1
    for a in range(13):
        value *= int(num[i+a])
    num1.append(value)
print(max(num1))

快是很快...但，感觉解法太简单了0 0？

4444567

sn='7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450'
list1 = []
dict1 = {}
for i in range(0,989):
    k = 1
    for n in sn[i:i+13]:
        if int(n) == 0:
            break
        else:
            k = k * int(n)
     
    list1.append(k) 
    dict1[i] = k
    
def get_value(i,k):#根据字典的值来查找键
    for i,k in dict1.items():
        if k == max(list1):
            print('所求数中连续的13位数字是：%s' % sn[i:i+13])

get_value(i,k) 
print('最大乘积为：%s' % max(list1))
    

有马_冬巳

'''找出以下这个 1000 位的整数中连续 13 个数字的最大乘积。'''

Renum = "73167176531330624919225119674426574742355349194934"\
        "96983520312774506326239578318016984801869478851843"\
        "85861560789112949495459501737958331952853208805511"\
        "12540698747158523863050715693290963295227443043557"\
        "66896648950445244523161731856403098711121722383113"\
        "62229893423380308135336276614282806444486645238749"\
        "30358907296290491560440772390713810515859307960866"\
        "70172427121883998797908792274921901699720888093776"\
        "65727333001053367881220235421809751254540594752243"\
        "52584907711670556013604839586446706324415722155397"\
        "53697817977846174064955149290862569321978468622482"\
        "83972241375657056057490261407972968652414535100474"\
        "82166370484403199890008895243450658541227588666881"\
        "16427171479924442928230863465674813919123162824586"\
        "17866458359124566529476545682848912883142607690042"\
        "24219022671055626321111109370544217506941658960408"\
        "07198403850962455444362981230987879927244284909188"\
        "84580156166097919133875499200524063689912560717606"\
        "05886116467109405077541002256983155200055935729725"\
        "71636269561882670428252483600823257530420752963450"

def maxproduct(chain_num):
    start_position=0
    end_position=chain_num
    max_product = 0
    while end_position <= len(Renum)-1:
        product = 1
        for i in range(start_position, end_position):
            product *= int(Renum[i])
        if product > max_product:
            max_product = product
            num_chain = []
            for j in range(start_position,end_position):
                num_chain.append(Renum[j])
        start_position += 1
        end_position += 1
    print("这1000位数中连续%d个数字的最大乘积为%d" %(chain_num,max_product))
    print("这13个数字是:")
    print(num_chain)

start_maxproduct = time.time()
maxproduct(13)
time_maxproduct = time.time() - start_maxproduct
print("%f秒" %time_maxproduct)

这1000位数中连续13个数字的最大乘积为23514624000
这13个数字是:
['5', '5', '7', '6', '6', '8', '9', '6', '6', '4', '8', '9', '5']
0.002976秒