Question

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

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

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

我使用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

ym和xm是我们想要移动的方向，因此如果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]]

Answer 1

我想你可能想要像

这样的东西

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 - 您如何区分没有足够的条款和拥有正确数量的条款，但它们都是零？将逻辑加载到对角函数中对我来说感觉很奇怪，但你可以很容易地改变它。

Answer 2

使用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()])

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

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子阵列 - 完成。

找对角线数

2 个答案: