Python 求对角数

我这里有一个数组：

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

假设我使用

getD（t，0,0）

使用上面的代码，我希望返回以下内容：

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

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

或者如果我想使用

getD（t，19，19）

使用上面的代码，我希望返回以下内容：

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

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

---

我想你可能想要像这样的东西

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

---

您可以更改

对角线方向的顺序

，以符合您的期望。另外，请注意，如果您没有足够的条款，我将返回

[]

，而不是

[0,0,0]

。返回

[0,0,0,0]

是个坏主意，ISTM——您如何区分术语数量不足和术语数量正确，但它们都为零？将该逻辑加载到对角函数中让我感觉很奇怪，但您可以很容易地更改它。

使用Numpy，Euler问题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子数组上迭代即可。完成。

请包含一个示例，其中包含您希望看到的结果。在你想要回复的内容之后，我遇到了一些问题。请添加一个指向你正在谈论的问题的链接，或者为我们写下来。我们开始吧。我试着解释，一定说得不够清楚。对不起。我不明白什么是艺术，比如《了不起的男人》中的b！我想我是在正确的轨道上，但不完全正确。现在来看看剩下的问题。除息的。不会碰巧有任何代码来做上下左右，对吗？同样的格式…@SmartLemon：我把这个留给你。如果你明白什么是

dx

和

dy

的意思，你应该能够弄清楚如何使用相同的方法来实现这些方向，或者如何实现骑士的步伐。我会尝试一下的。嗯，等我醒来的时候我会的。早上4点43分在密苏里州，所以我不想知道答案，这个项目的目的是让人们思考。