1

所以我在这里有这个数组：

t = [[8,2,22,97,38,15,0,40,0,75,4,5,7,78,52,12,50,77,91,8],
     [49,49,99,40,17,81,18,57,60,87,17,40,98,43,69,48,4,56,62,0],
     [81,49,31,73,55,79,14,29,93,71,40,67,53,88,30,3,49,13,36,65],
     [52,70,95,23,4,60,11,42,69,24,68,56,1,32,56,71,37,2,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,3,45,2,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,2,62,12,20,95,63,94,39,63,8,40,91,66,49,94,21],
     [24,55,58,5,66,73,99,26,97,17,78,78,96,83,14,88,34,89,63,72],
     [21,36,23,9,75,0,76,44,20,45,35,14,0,61,33,97,34,31,33,95],
     [78,17,53,28,22,75,31,67,15,94,3,80,4,62,16,14,9,53,56,92],
     [16,39,5,42,96,35,31,47,55,58,88,24,0,17,54,24,36,29,85,57],
     [86,56,0,48,35,71,89,7,5,44,44,37,44,60,21,58,51,54,17,58],
     [19,80,81,68,5,94,47,69,28,73,92,13,86,52,17,77,4,89,55,40],
     [4,52,8,83,97,35,99,16,7,97,57,32,16,26,26,79,33,27,98,66],
     [88,36,68,87,57,62,20,72,3,46,33,67,46,55,12,32,63,93,53,69],
     [4,42,16,73,38,25,39,11,24,94,72,18,8,46,29,32,40,62,76,36],
     [20,69,36,41,72,30,23,88,34,62,99,69,82,67,59,85,74,4,36,16],
     [20,73,35,29,78,31,90,1,74,31,49,71,48,86,81,16,23,57,5,54],
     [1,70,54,71,83,51,54,69,16,92,33,48,61,43,52,1,89,19,67,48]]

这只是一个二维列表，我需要做的是以任何方式找到与数字对角线的四个数字。

我使用 xy 坐标获取数字，然后获取它周围的数字，我认为这很容易。

我尝试做的是获取数字，然后找到其他 3 个数字，我这样做四次，每个方向

这是我尝试让它工作的代码，但它不想得到正确的数字。

def getD(t,x,y):
    z = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
    xm = 1
    ym = 1
    for a in range(0,4):
        if a == 0:
            xm = 1
            ym = 1
        elif a == 1:
            xm = 1
            ym = -1
        elif a == 2:
            xm = -1
            ym = 1
        elif a == 3:
            xm = -1
            ym = -1
        for b in range(0,4):
            z[a][b]=t[y+(b*ym)][x+(b+xm)]
    print z

ymxm是我们要移动的方向，所以如果是xm-1，就向左，如果是1，就向右，如果ym是-1，就向下，否则向上。

有人有办法做到这一点吗？

如果我这样做getD(t, 0, 0)了，我会回来[[2, 99, 73, 4], [2, 54, 29, 72], [8, 49, 49, 95], [8, 1, 73, 36]]

我将如何发出无效的？例如，当它是getD(t,0,0)并且我只想要向下和向右的对角线，因为其他人不可能是正确的？

这是数组的格式化版本

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

假设我想要(0,0)[顶角] 的所有对角线使用getD(t,0,0)

使用上面的代码，我想要一些类似的东西：

[[0, 0, 0, 0], [8, 49, 31, 23], [0, 0, 0, 0], [0, 0, 0, 0]]

或者如果我想在点(19,19)[最后一个底角] 使用对角线getD(t, 19, 19)

使用上面的代码，我想要一些类似的东西：

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [48, 5, 4, 40]]
4

2 回答 2

3

我想你可能想要类似的东西

def get_diagonal(t, x, y, length=4):
    rays = []
    diagonal_directions = [(1,1),(1,-1),(-1,1),(-1,-1)]
    for dx, dy in diagonal_directions:
        if not ((0 <= (x+dx*(length-1)) < len(t[0])) and
                (0 <= (y+dy*(length-1)) < len(t))):
            ray = []
        else:
            ray = [t[y+dy*i][x+dx*i] for i in range(length)]
        rays.append(ray)
    return rays

[更好：rays完全且简单地移除yield每条射线。]

我总是在做这些事情时搞混x，y所以你会想检查一下，但我认为这样的事情应该可行。例子：

In [48]: get_diagonal(t, 0, 0)
Out[48]: [[8, 49, 31, 23], [], [], []]

In [49]: get_diagonal(t, 19, 19)
Out[49]: [[], [], [], [48, 5, 4, 40]]

In [50]: get_diagonal(t, 5, 5)
Out[50]: [[3, 67, 20, 97], [3, 63, 42, 93], [3, 64, 68, 58], [3, 51, 23, 31]]

In [51]: get_diagonal(t, 5, 5, 3)
Out[51]: [[3, 67, 20], [3, 63, 42], [3, 64, 68], [3, 51, 23]]

您可以更改顺序diagonal_directions以符合您的期望。另外，请注意，如果您没有足够的条款，我会返回[]。[0,0,0,0]返回[0,0,0,0]是一个坏主意，ISTM - 您如何区分没有足够的术语和具有正确数量的术语但它们都为零？将该逻辑加载到对角函数中对我来说感觉很奇怪，但您可以轻松更改它。

于 2012-10-01T15:34:36.250 回答
0

使用 Numpy 解决欧拉问题 11 真的很简单：

首先，创建您的 Numpy 矩阵：

>>> import numpy as np
>>> LoL=np.array([map(int,ss.split()) for ss in """\
... 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\
... """.splitlines()])

现在，您可以将 4x4 矩阵中的每 225 个视为其自己的简单部分：

def maxOfSub4x4(a):
    l=[]
    for i in range(4):             # each line of 4x4 square
        l.append(a[i])
        l.append(a[:,i])

    l.append(a.diagonal())
    l.append(a[::-1].diagonal())   # opposite diagonal
    print l

    return max([reduce(int.__mul__,[int(i) for i in e]) for e in l])

现在可以看到 LoL[0:4,0,4] 处特定方格的最大值：

    print maxOfSub4x4(LoL[0:4,0:4])

打印 4x4 子数组的元素，包括两条对角线，以及这些数组元素的最大乘积：

[array([ 8,  2, 22, 97]), array([ 8, 49, 81, 52]), array([49, 49, 99, 40]), array([ 2, 49, 49, 70]), array([81, 49, 31, 73]), array([22, 99, 31, 95]), array([52, 70, 95, 23]), array([97, 40, 73, 23]), array([ 8, 49, 31, 23]), array([52, 49, 99, 97])]
24468444

现在，只需遍历 20 x 20 完整数组中的所有 225 个 4x4 子数组——完成。

于 2012-10-01T18:47:37.917 回答