小练习：20160425 在20×20的网格中同一直线上四个数的最大乘积是多少？

冬雪雪冬 · 发表于 2016-4-25 09:36:23

马上注册，结交更多好友，享用更多功能^_^

您需要登录才可以下载或查看，没有账号？立即注册

x

本帖最后由冬雪雪冬于 2016-5-4 10:50 编辑

从现在开始我们要开展一批欧拉计划的习题练习。
其实在我们论坛中已有欧拉计划的板块，可能有些鱼油还没注意到。
什么是欧拉计划：http://bbs.fishc.com/thread-60405-1-1.html
我们欧拉板块现已给出了81道题，这批练习将从欧拉计划中选题。其实用python语言完成有很多的优势，可以更简洁更方便的实现。
如果大家有兴趣也可浏览欧拉的英文网站：https://projecteuler.net/archives
这里已经有了500余题，并且你每做对一题，就可以下载到参考答案的pdf文件，看看你的实现方法与参考答案有什么不同，以利于迅速提高自己的水平。

登录/注册后可看大图

好了言归正传，我们开始做小练习。

题目要求：
以python语言完成，如果是python2请注明。
程序以代码文字格式发帖。
题目比较简单，注重程序效率和创意。
答题在5.4 10：00前完成，其后将公开大家的答案，并评比成绩。
另程序和答案可以在网上搜到，希望大家独立完成。

题目：

在以下这个 20×20 的网格中，四个处于同一对角线上的相邻数字用红色标了出来：

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

这四个数字的乘积是：26 × 63 × 78 × 14 = 1788696.

在这个 20×20 网格中，处于任何方向上（上，下，左，右或者对角线）的四个相邻数字的乘积的最大值是多少？

奖励：
对所有完成程序并得出正确答案的将给予加分奖励，优秀的将额外加分。
在完成一批题目后，将根据每期的完成情况总评评出最佳，会有神秘大奖。

詹姆西 · 发表于 2016-4-25 16:03:34

本帖最后由詹姆西于 2016-4-25 16:05 编辑

效率很低，凑合看吧

詹姆西 · 发表于 2016-4-25 16:04:28

NUM='''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''
NUM=NUM.replace('\n',' ')
NUM=NUM.split(' ')
NUM=int_num(NUM)
COUNT=20

def int_num(num):                 #将列表字符串，整数化
    numlist=list()
    for i in range(len(num)):
        numlist.append(int(num[i]))
    return numlist
        
def max_list(alist):            #求单一列表乘积的最大值
    max_r=1
    if len(alist)<4:
        return(0)
    else:
        for i in range(0,len(alist)-3):
            mul=alist[i]*alist[i+1]*alist[i+2]*alist[i+3]
            if mul > max_r:
                max_r=mul
        return(max_r)

def list_r(num):        #将整个列表分割成小列表
    alist=list()
    for i in range(len(num)):
        m = i % COUNT
        if m == 0 :
            temp=list()
        temp.append(num[i])
        if m == COUNT-1:
            alist.append(temp)
    return(alist)



def list_d(num):        #将整个列表纵向分割成小列表
    alist=list()
    for i in range(COUNT):
        temp=list()
        for j in range(0,int(len(num)/COUNT)):
            temp.append(num[i+j*COUNT])
        alist.append(temp)
    return(alist)

def list_rd(num):         #将整个列表向右下方向分割成小列表
    alist=list()
    for i in range(COUNT):
        j=i
        temp=[num[i]]
        while j+COUNT+1 < len(num) and (j+COUNT+1)% COUNT !=0:
            temp.append(num[j+COUNT+1])
            j+=COUNT+1
        alist.append(temp)
    for i in range(COUNT,len(num),COUNT):
        j=i
        temp=[num[i]]
        while j+COUNT+1 < len(num) and (j+COUNT+1)%COUNT !=0:
            j+=COUNT+1
            temp.append(num[j])       
        alist.append(temp)      
    return(alist)
            
def list_lu(num):         #将整个列表向左上方向分割成小列表
    alist=list()
    for i in range(COUNT):
        j=i
        temp=[num[i]]
        while j +COUNT-1 <len(num) and (j+COUNT-1) % COUNT !=(COUNT-1):
            j+=COUNT-1
            temp.append(num[j])
        alist.append(temp)

    for i in range(COUNT*2-1,len(num),COUNT):
        j=i
        temp=[num[i]]
        while j+COUNT-1 <len(num) and (j+COUNT-1) %COUNT !=COUNT-1:
            j+=COUNT-1
            temp.append(num[j])
        alist.append(temp)
    return(alist)
        

def max_all(alist):
    temp=0
    for i in range(len(alist)):
        if temp<max_list(alist[i]):
            temp=max_list(alist[i])
    return(temp)
               

max_r=max_all(list_r(NUM))
max_d=max_all(list_d(NUM))
max_rd=max_all(list_rd(NUM))
max_lu=max_all(list_lu(NUM))
max_all=max(max_r,max_d,max_rd,max_lu)

print(max_all)

老忘 · 发表于 2016-4-25 18:39:06

想到应考虑去掉“00”上下左右相临为3位置再计算，但不知怎么入手，先整个全部计算的再说。

str_input='''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''
list_arrm=[]
list_arrm_rel=[]

for each in str_input.splitlines():
    list_arrm.append((each.split(' ')))

for i in range(0,17):
    for j in range(0,17):
        list_arrm_rel.append([int(list_arrm[i][j])*int(list_arrm[i+1][j+1])*int(list_arrm[i+2][j+2]),int(list_arrm[i+3][j+3]),int(list_arrm[i][j]),int(list_arrm[i+1][j+1]),int(list_arrm[i+2][j+2]),int(list_arrm[i+3][j+3])])

for i in range(0,17):
    for j in range(19,3,-1):
        list_arrm_rel.append([int(list_arrm[i][j])*int(list_arrm[i+1][j-1])*int(list_arrm[i+2][j-2])*int(list_arrm[i+3][j-3]),int(list_arrm[i][j]),int(list_arrm[i+1][j-1]),int(list_arrm[i+2][j-2]),int(list_arrm[i+3][j-3])])

for i in range(0,19):
    for j in range(0,17):
        list_arrm_rel.append([int(list_arrm[i][j])*int(list_arrm[i][j+1])*int(list_arrm[i][j+2])*int(list_arrm[i][j+3]),int(list_arrm[i][j]),int(list_arrm[i][j+1]),int(list_arrm[i][j+2]),int(list_arrm[i][j+3])])

for i in range(0,17):
    for j in range(0,19):
        list_arrm_rel.append([int(list_arrm[i][j])*int(list_arrm[i+1][j])*int(list_arrm[i+2][j])*int(list_arrm[i+3][j]),int(list_arrm[i][j]),int(list_arrm[i+1][j]),int(list_arrm[i+2][j]),int(list_arrm[i+3][j])])

print(max(list_arrm_rel)[:][0])

挥舞乾坤 · 发表于 2016-4-25 20:02:49

本帖最后由挥舞乾坤于 2016-4-25 20:07 编辑

data = '''
        08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
        49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
        81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
        52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
        22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
        24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
        32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
        67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
        24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
        21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
        78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
        16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
        86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
        19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
        04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
        88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
        04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
        20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
        20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
        01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
'''
data = data.split()
lst = []
for i in range(0, 20*20, 20):
        lst.append(list(map(int, data[i:i+20])))

r = set()
for x in range(20):
        for y in range(20):
                try:
                        r.add(lst[x][y] * lst[x][y+1] * lst[x][y+2] * lst[x][y+3])
                except IndexError:
                        pass
                try:
                        r.add(lst[x][y] * lst[x+1][y+1] * lst[x+2][y+2] * lst[x+3][y+3])
                except IndexError:
                        pass
                try:
                        r.add(lst[x][y] * lst[x+1][y] * lst[x+2][y] * lst[x+3][y])
                except IndexError:
                        pass
                try:
                        r.add(lst[x][y] * lst[x-1][y+1] * lst[x-2][y+2] * lst[x-3][y+3])
                except IndexError:
                        pass

print(max(r))

不够优雅,挺丑的

lingtingliushen · 发表于 2016-4-26 11:30:40

本帖最后由 lingtingliushen 于 2016-4-26 14:38 编辑

str = '''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48''';
a=[]
b=[]
i=0
result=0
s=0
t=0

for each in str.split():
    a.append(int(each))

for each1 in a:
    for i in range(0,20):
        b.append(a[i*20:(i+1)*20])

for j in range(0,17):
    for k in range(0,17):
        A1=b[j][k]*b[j+1][k+1]*b[j+2][k+2]*b[j+3][k+3]
        A2=b[j][k]*b[j][k+1]*b[j][k+2]*b[j][k+3]
        A3=b[j][k]*b[j+1][k]*b[j+2][k]*b[j+3][k]
        A4=b[j+3][k]*b[j+2][k+1]*b[j+1][k+2]*b[j][k+3]
        A5=max(A1,A2,A3,A4)
        if A5>result:
            result=A5


print(result)

lingtingliushen · 发表于 2016-4-26 11:31:13

lingtingliushen 发表于 2016-4-26 11:30

C:\Python34\python.exe C:/Users/guodongxue/PycharmProjects/untitled2/33.py
12 6 89 70600674

bacon6581 · 发表于 2016-4-26 12:23:17

本帖最后由 bacon6581 于 2016-4-26 13:00 编辑

num_str=[]

#20x20 Num -> num_str

for line in open('num.txt'):

    num_str.append(line.split())

num_int=[]

for i in range(0,len(num_str)):

    num_int_line=[]

    for j in range(0,len(num_str[i])):

        num_int_line.append(int(num_str[i][j]))

    num_int.append(num_int_line)

print(num_int)

# \multiply
result=0
result_max=0
list_max=[]

for i in range(0,17):

    for j in range(0,17):

        result=num_int[i][j] * num_int[i+1][j+1] *
 num_int[i+2][j+2] * num_int[i+3][j+3]
        if result > result_max:

            result_max=result

            list_max=num_int[i][j],num_int[i+1][j+1],num_int[i+2][j+2],num_int[i+3][j+3]

# /multiply

for i in range(3,17):

    for j in range(0,17):

        result=num_int[i][j] * num_int[i+1][j-1] * num_int[i+2][j-2] * num_int[i+3][j-3]
        if result > result_max:

            result_max=result

            list_max=num_int[i][j],num_int[i+1][j-1],num_int[i+2][j-2],num_int[i+3][j-3]


print("Max: {0}x{1}x{2}x{3}={4}".format(list_max[0],list_max[1],list_max[2],list_max[3],result_max))

树莓派上写的程序，拖回到台式机，再更改后缀，最后调整段落（这步可能存在误操作）
可能直接复制到python里会报错
------------------------------------------------------------------------------------
原来我的思路和第6楼差不多。不过第6楼代码比我简洁、清晰多了。
我原以为只是两条对角线上的四个数字相乘，没有把横着、竖着的考虑进去
在树莓派里修改了下代码，结果还是一样样的。
第6楼，应该没考虑到前4个竖列，横着相乘、竖着相乘的结果
如下图：红色的6楼已经考虑了，蓝色的6楼还没考虑
无标题.jpg

lingtingliushen · 发表于 2016-4-26 13:46:18

bacon6581 发表于 2016-4-26 12:23
树莓派上写的程序，拖回到台式机，再更改后缀，最后调整段落（这步可能存在误操作）
可能直接复制到py ...

str = '''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48''';
a=[]
b=[]
i=0
result=0
s=0
t=0

for each in str.split():
    a.append(int(each))

for each1 in a:
    for i in range(0,20):
        b.append(a[i*20:(i+1)*20])

for j in range(0,17):
    for k in range(0,17):
        A1=b[j][k]*b[j+1][k+1]*b[j+2][k+2]*b[j+3][k+3]
        A2=b[j][k]*b[j][k+1]*b[j][k+2]*b[j][k+3]
        A3=b[j][k]*b[j+1][k]*b[j+2][k]*b[j+3][k]
        A4=b[j+3][k]*b[j+2][k+1]*b[j+1][k+2]*b[j][k+3]
        A5=max(A1,A2,A3,A4)
        if A5>result:
            result=A5
            s=j
            t=k

print(s,t,b[s][t],result)
感谢你指出来了，改了一下

小剑剑 · 发表于 2016-4-26 18:59:32

raw_string='''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''
raw_string=raw_string.split('\n')
num_list=[]
for i in(raw_string):
    num_list.append(i.split())
for i in range(20):
    for ii in range(20):
        num_list[i][ii]=int(num_list[i][ii])
maxx=0
lenhang=len(num_list)
lenlie=len(num_list[0])
for i in range(lenhang):
    for ii in range(lenlie-3):
        su=sum(num_list[i][ii:ii+4])
        if maxx<su:
            maxx=su
for i in range(lenlie):
    for ii in range(lenhang-3):
        su=sum([iii [i] for iii in num_list[ii:ii+4]])
        if su>maxx:
            maxx=su
for i in range(lenhang-3):
    for ii in range(lenlie-3):
        su=sum([num_list[i+iii][ii+iii] for iii in range(4)])
        if su>maxx:
            maxx=su
for i in range(4,lenhang):
    for ii in range(0,lenlie-3):
        su=sum([num_list[i-iii][ii+iii] for iii in range(4)])

写得很丑，但是老师要我用c写五子棋，没时间多琢磨了

loyfee · 发表于 2016-4-26 23:29:23

def max_sum(f):
    sum = []
    for i in range(0,17):
        for j in range(0,17):
            f1 = f[20*(i+0)+j]*f[20*(i+0)+j+1]*f[20*(i+0)+j+2]*f[20*(i+0)+j+3]
            f2 = f[20*(i+1)+j]*f[20*(i+1)+j+1]*f[20*(i+1)+j+2]*f[20*(i+1)+j+3]
            f3 = f[20*(i+2)+j]*f[20*(i+2)+j+1]*f[20*(i+2)+j+2]*f[20*(i+2)+j+3]
            f4 = f[20*(i+3)+j]*f[20*(i+3)+j+1]*f[20*(i+3)+j+2]*f[20*(i+3)+j+3]
            h1 = f[20*i+j+0]*f[20*(i+1)+j+0]*f[20*(i+2)+j+0]*f[20*(i+3)+j+0]
            h2 = f[20*i+j+1]*f[20*(i+1)+j+1]*f[20*(i+2)+j+1]*f[20*(i+3)+j+1]
            h3 = f[20*i+j+2]*f[20*(i+1)+j+2]*f[20*(i+2)+j+2]*f[20*(i+3)+j+2]
            h4 = f[20*i+j+3]*f[20*(i+1)+j+3]*f[20*(i+2)+j+3]*f[20*(i+3)+j+3]
            p1 = f[20*(i+0)+j]*f[20*(i+1)+j+1]*f[20*(i+2)+j+2]*f[20*(i+3)+j+3]
            p2 = f[20*(i+3)+j]*f[20*(i+2)+j+1]*f[20*(i+1)+j+2]*f[20*(i+0)+j+3]
            list_lis = [f1,f2,f3,f4,h1,h2,h3,h4,p1,p2]
            res1 = max(list_lis)
            sum.append(res1)
    print(max(sum))

import time

flist = '''
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
'''
time_s = time.time()
flist = flist.split()
for i in range(0,400):
    flist[i] = int(flist[i])

max_sum(flist)
print(time.time() - time_s)

结果：70600674
用时：0.0792398452759

wangzhenas · 发表于 2016-4-27 01:36:36

data = '''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''

lst = [list(map(int,list(line.split(' ')))) for line in data.split('\n')]
size,maxi  = len(lst),0
for i in range(size-3):
    for j in range(size-3):
        maxi = max(maxi,lst[j][i]*lst[j][i+1]*lst[j][i+2]*lst[j][i+3],
                        lst[j][i]*lst[j+1][i]*lst[j+2][i]*lst[j+3][i],
                        lst[j][i]*lst[j+1][i+1]*lst[j+2][i+2]*lst[j+3][i+3],
                        lst[j+3][i]*lst[j+2][i+1]*lst[j+1][i+2]*lst[j][i+3])
print(maxi)

2012277033 · 发表于 2016-4-27 20:37:59

应为python才刚学不久，所以只能用一些刚学会的语句尝试，
我算了一下，两三秒左右出结果。

product=0#用于存放乘积
wangge="""08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48"""#把表格定义为分行字符串
a=wangge.splitlines()#将整个表格先切片成以行为元素的列表。
i=0
d=3
while i<len(a):#判断行当中的最大值
    while d<20:
        if product<int(a[i].split()[d])*int(a[i].split()[d-1])*int(a[i].split()[d-2])*int(a[i].split()[d-3]):
            product=int(a[i].split()[d])*int(a[i].split()[d-1])*int(a[i].split()[d-2])*int(a[i].split()[d-3])
        d+=1
    d=3
    i+=1
d=0
i=3
while d<len(a):#判断列的最大值
    while i<20:
        if product<int(a[i].split()[d])*int(a[i-1].split()[d])*int(a[i-2].split()[d])*int(a[i-3].split()[d]):
            product=int(a[i].split()[d])*int(a[i-1].split()[d])*int(a[i-2].split()[d])*int(a[i-3].split()[d])
        i+=1
    d+=1
    i=3
i=0
d=0
while d+3<len(a):#判断左上到右下对角线的最大
    while i+3<20:
        if product<int(a[i].split()[d])*int(a[i+1].split()[d+1])*int(a[i+2].split()[d+2])*int(a[i+3].split()[d+3]):
            product=int(a[i].split()[d])*int(a[i+1].split()[d+1])*int(a[i+2].split()[d+2])*int(a[i+3].split()[d+3])
        i+=1
    d+=1
    i=0
i=0
d=3
while d<len(a):#判断从右上到坐下的最大
    while i+3<20:
        if product<int(a[i].split()[d])*int(a[i+1].split()[d-1])*int(a[i+2].split()[d-2])*int(a[i+3].split()[d-3]):
            product=int(a[i].split()[d])*int(a[i+1].split()[d-1])*int(a[i+2].split()[d-2])*int(a[i+3].split()[d-3])
        i+=1
    d+=1
    i=0
print(product)

zooo · 发表于 2016-4-30 20:53:33

本帖最后由 zooo 于 2016-5-4 00:08 编辑

思路：根据题意数组中每个元素都有4个方向
oula20思路.png

定义一个函数用来找出每个元素在这4个方向的最大值，遍历整个矩阵后找出最终结果

from functools import reduce
import time

def find_max_eachElem(numArr, x, y):
    aspect = [[], [], [], []]#对数组中每个元素的四个方向初始化
    
    for i in range(4):
        if 0<= y+i <20:
            aspect[0].append(numArr[x][y+i])#右
        else:aspect[0].append(0)

        if 0<= x + i <20 and 0<= y + i <20:
            aspect[1].append(numArr[x + i][y + i])#右下
        else:aspect[1].append(0)
        
        if 0<= x+i <20:
            aspect[2].append(numArr[x + i][y])#下
        else:aspect[2].append(0)

        if 0<= x - i and 0<= y + i <20:
            aspect[3].append(numArr[x - i][y + i])#左下
        else:aspect[3].append(0)

    max, maxArr = 0, []
    for arr in aspect:
        tmp = reduce(lambda x, y:x*y, arr)
        if tmp > max:
            max, maxArr = tmp, arr
            
    return (max, maxArr)

s = time.time()

str_num = '''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''

numArr = list(map(lambda x:list(map(lambda y:int(y), x.split())), str_num.split('\n')))

max = 0
for x in range(20):
    for y in range(20):
        if numArr[x][y]: #跳过0
            result = find_max_eachElem(numArr, x, y)
            if result[0] > max:
                (max, maxArr) = result

print(max, maxArr, time.time()-s)

并行代码（使用pp模块），由于计算规模太小效率反而下降了，实验计算400x400的数组效率明显提升

并行计算数组400x400.zip (171.36 KB, 下载次数: 0)

import pp
import functools

def find_max_eachElem(numArr, x, y):
    aspect = [[], [], [], []]#对数组中每个元素的四个方向初始化
    
    for i in range(4):
        if 0<= y+i <20:
            aspect[0].append(numArr[x][y+i])#右
        else:aspect[0].append(0)

        if 0<= x + i <20 and 0<= y + i <20:
            aspect[1].append(numArr[x + i][y + i])#右下
        else:aspect[1].append(0)
        
        if 0<= x+i <20:
            aspect[2].append(numArr[x + i][y])#下
        else:aspect[2].append(0)

        if 0<= x - i and 0<= y + i <20:
            aspect[3].append(numArr[x - i][y + i])#左下
        else:aspect[3].append(0)

    max, maxArr = 0, []
    for arr in aspect:
        tmp = functools.reduce(lambda x, y:x*y, arr)
        if tmp > max:
            max, maxArr = tmp, arr
            
    return (max, maxArr)

def findMax(numArr, beg, end):
    max = 0
    for x in range(beg, end):
        for y in range(20):
            if numArr[x][y]: #跳过0
                result = find_max_eachElem(numArr, x, y)
                if result[0] > max:
                    (max, maxArr) = result
    return (max, maxArr)

str_num = '''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''

numArr = list(map(lambda x:list(map(lambda y:int(y), x.split())), str_num.split('\n')))

funList = []
#开启pp服务
job_server = pp.Server(ncpus=2)#使用2个核心

#分4段
parts = 4
step = 20//4
for index in range(4):
    funList.append(job_server.submit(findMax, (numArr, index*step, (index+1)*step),
                      (find_max_eachElem, ), ('functools', ) ))

listResults = []

for fun in funList:
    listResults.append(fun())

dictResults = dict(listResults)

job_server.print_stats()

maxNum = max(dictResults.keys())
print(maxNum, dictResults[maxNum])

小火木 · 发表于 2016-5-4 00:42:02

def hmax(array):
    result=0
    relist=[]
    for i in range(len(array)):
            for j in range(len(array[i])):
                try:
                    temp=array[i][j]*array[i][j+1]*array[i][j+2]*array[i][j+3]
                    if temp>result:
                        result=temp
                        relist=[array[i][j],array[i][j+1],array[i][j+2],array[i][j+3]]
                except:pass
    
    return result,relist

def vmax(array):
    result=0
    relist=[]
    for i in range(len(array)):
                for j in range(len(array[i])):
                    try:
                        temp=array[i][j]*array[i+1][j]*array[i+2][j]*array[i+3][j]
                        if temp>result:
                            result=temp
                            relist=[array[i][j],array[i+1][j],array[i+2][j],array[i+3][j],i,j]
                    except:pass
    return result,relist

def drmax(array):
    result=0
    relist=[]
    for  i in range(len(array)):
                    for j in range(len(array[i])):
                        try:
                            temp=array[i][j]*array[i+1][j+1]*array[i+2][j+2]*array[i+3][j+3]
                            if temp>result:
                                result=temp
                                relist=[array[i][j],array[i+1][j+1],array[i+2][j+2],array[i+3][j+3]]
                        except:pass
    return result,relist

def dlmax(array):
    result=0
    relist=[]
    for  i in range(len(array)-1,0,-1):
                    for j in range(len(array[i])):
                        try:
                            temp=array[i][j]*array[i-1][j+1]*array[i-2][j+2]*array[i-3][j+3]
                            if temp>result:
                                result=temp
                                relist=[array[i][j],array[i-1][j+1],array[i-2][j+2],array[i-3][j+3]]
                        except:pass

    return result,relist

def maxprint(hmax):
    print('四个相邻的数字的乘积最大的是：\n','%dx%dx%dx%d=%d'%(hmax[1][0],hmax[1][1],hmax[1][2],hmax[1][3],temp))

    
hub='''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''

line=list(hub.split())
array=[]
k=0
for i in range (0,20):
    array.append ([])
    for j in range (0,20):
        array[i].append(int(line[k]))
        k+=1
    

hmax=hmax(array)
vmax=vmax(array)
drmax=drmax(array)
dlmax=dlmax(array)

temp=max(hmax[0],vmax[0],drmax[0],dlmax[0])
if temp==hmax[0]:
    maxprint(hmax)
elif temp==vmax[0]:
    maxprint(vmax)
elif temp==drmax[0]:
    maxprint(drmax)
else:
    maxprint(dlmax)

DingRan · 发表于 2016-5-4 09:45:05

本帖最后由 DingRan 于 2016-5-4 11:00 编辑

严重支持

txt = '''08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48'''

def trans(i,j):
    return 20*(i-1)+j-1

def heng(i,j):
    if j>17:
        return 0
    return num[trans(i,j)]*num[trans(i,j+1)]*num[trans(i,j+2)]*num[trans(i,j+3)]

def zong(i,j):
    if i>17:
        return 0
    return num[trans(i,j)]*num[trans(i+1,j)]*num[trans(i+2,j)]*num[trans(i+3,j)]

def youxie(i,j):
    if i>17 or j>17:
        return 0
    return num[trans(i,j)]*num[trans(i+1,j+1)]*num[trans(i+2,j+2)]*num[trans(i+3,j+3)]

def zuoxie(i,j):
    if j<4 or i>17:
        return 0
    return num[trans(i,j)]*num[trans(i+1,j-1)]*num[trans(i+2,j-2)]*num[trans(i+3,j-3)]

num = []
for i in range(400):
    num.append(int(txt[3*i:3*i+2]))

max_product = 0

for i in range(1,21):
    for j in range(1,21):
        if heng(i,j)>max_product:
            max_product = heng(i,j)
        if zong(i,j)>max_product:
            max_product = zong(i,j)
        if youxie(i,j)>max_product:
            max_product = youxie(i,j)
        if zuoxie(i,j)>max_product:
            max_product = zuoxie(i,j)

print(max_product)

运行结果

>>> 
70600674
>>>

账号		自动登录	找回密码
密码			立即注册

[技术交流] 小练习：20160425 在20×20的网格中同一直线上四个数的最大乘积是多少？

马上注册，结交更多好友，享用更多功能^_^

本帖被以下淘专辑推荐:

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分

评分