有没有更有效的方法来解决这个问题？

Question

Consider the following N × N matrices A and B that contain only positive integers:

• B is created from A by summing the odd numbers that neighbour each element, at position [i,j] in A .
• Each computed sum is then stored in the corresponding position [i,j] in B .

For example:

• At position [3, 2] there are 4 odd numbers [3, 1, 5, 3] that neighbour A[3,2] .
• The sum of these neighbouring odd numbers is 12 , which is stored in B[3,2]

This code works by brute force, taking each of the 9 regions separately, (Namely: Top, bottom, left, right, 4 corners and inner).

Is there a better way to go about this?

from numpy import array,zeros,shape

def sum_neighbours(A):
    A = array(A,int)
    r,c = shape(A)
    B = zeros(shape(A),int)

    for i in range(r):
        for j in range(c):
            N_list_i = [0,-1,-1,-1,0,1,1,1,0] #[l,tl,t,tr,r,br,b,bl]
            N_list_j = [-1,-1,0,1,1,1,0,-1,-1]          

            # innerSquares
            if 1 <= i <= (r-2) and 1 <= j <= (r-2):
                for k in range(len(N_list_j)-1):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #TopLeft            
            elif i==0 and j==0:
                N_list_i = N_list_i[4:(4+3)]
                N_list_j = N_list_j[4:(4+3)]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #BottomLeft            
            elif j==0 and i==(r-1):
                N_list_i = N_list_i[2:(2+3)]
                N_list_j = N_list_j[2:(2+3)]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #TopRight            
            elif i==0 and j == (r-1):
                N_list_i = N_list_i[6:(6+3)]
                N_list_j = N_list_j[6:(6+3)]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #BottomRight            
            elif i == (r-1) and j == (r-1):
                N_list_i = N_list_i[0:(0+3)]
                N_list_j = N_list_j[0:(0+3)]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #TopBorder            
            elif i==0 and j < (r-1):
                N_list_i = N_list_i[4:(4+5)]
                N_list_j = N_list_j[4:(4+5)]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #LeftBorder            
            elif j==0 and i < (r-1):
                N_list_i = N_list_i[2:(2+5)]
                N_list_j = N_list_j[2:(2+5)]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #BottomBorder            
            elif i==(r-1) and j < (r-1):
                N_list_i = N_list_i[0:(0+5)]
                N_list_j = N_list_j[0:(0+5)]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]

            #RightBorder            
            elif j==(r-1) and i < (r-1):
                N_list_i = [1,1,0,-1,-1]
                N_list_j = [0,-1,-1,-1,0]
                for k in range(len(N_list_j)):
                    if A[i+N_list_i[k]][j+N_list_j[k]] %2 != 0:
                        B[i][j] += A[i+N_list_i[k]][j+N_list_j[k]]
    return B

A = array([[3,2,8,1,1],
           [1,2,4,1,1],
           [7,3,4,1,8],
           [1,8,0,6,4],
           [5,6,5,3,8]])

Answer 1

In terms of refactoring, you almost certainly want to avoid "brute force" in the sense of having to explicitly type out all your cases :) @alexmcf addresses this above.

In conceptual terms, your approach follows the problem statement directly: check all neighbors for each number in the matrix and sum all odd numbers. This means that you are always doing the checking and summing, even if there are no odd numbers in the matrix.

As an alternative: we can first run through the matrix and identify odd numbers. Then, starting from a null matrix, we simply add the odd numbers to all valid neighbors. This saves work in proportion to the sparcity of odd numbers in the matrix.

import numpy as np

def find_offsets(row, col, size):
    """Return all valid pairs of offsets as [(row_offset, col_offset)...]."""
    offsets = ((-1, -1), (-1, 0), (-1, 1),
               (0, -1), (0, 1),
               (1, -1), (1, 0), (1, 1))

    return [(r_off, c_off) for r_off, c_off in offsets
            if row + r_off >= 0 and row + r_off < size
            if col + c_off >= 0 and col + c_off < size]

def find_odds(matrix, size):
    """Return all odd values in matrix as [(row_ind, col_ind, value)...]."""
    return [(row, col, matrix[row][col])
            for row in xrange(size)
            for col in xrange(size)
            if matrix[row][col] % 2 != 0]

def gen_matrix(source, size):
    """Filter source 2x2 matrix for odds and add each to valid neighbors."""

    out = np.zeros((size, size), dtype=int)

    # filter for location and value of all odd numbers
    odds = find_odds(source, size)
    for row, col, value in odds:
        # add odd number to all valid neighbors (by finding valid offsets)
        offsets = find_offsets(row, col, size)
        for r_off, c_off in offsets:
            out[row + r_off][col + c_off] += value

    return out

def sum_neighbors():
    """Sum neighbors as described in problem."""
    N = 5
    A = [[3,2,8,1,1],
         [1,2,4,1,1],
         [7,3,4,1,8],
         [1,8,0,6,4],
         [5,6,5,3,8]]
    return gen_matrix(A, N)

The above runs about twice as fast as your code (for an apples-to-apples comparison, I tweaked the above when executing in iPython so that the same matrix A is provided as a parameter in both cases):

In [19]: %timeit original.sum_neighbours(A)
1000 loops, best of 3: 195 µs per loop

In [20]: %timeit new.sum_neighbors(A)
10000 loops, best of 3: 84 µs per loop

Answer 2

Working Code

import numpy as np

def sum_neighbours_NEW(A):
    A = np.array(A,int)
    r,c = np.shape(A)
    B = np.zeros(A.shape, int)

    def b(x,y, size=A.shape):
        xlim,ylim = size # get limits of axes

        # generate a list of all i,j bordering x,y
        # this will cause the most slowdown... for faster code, you minimise   
        # the number of tims idx gets called by making it a parameter of b()
        # adding x and y and doing a np.where() to ensure it doesn't 
        # index out of the array range
        idx = [[x+i,y+j] for i in range(-1,2) for j in range(-1,2) \
               if (i,j) != (0,0) and (x+i>=0 and y+j>=0) and (x+i<xlim and y+j<ylim)]
        idx = np.asarray(idx) # convert to numpy array
        return idx[:,0], idx[:,1] # split into x,y for indexing

    # iterate across all elements of A
    for i in xrange(r):
        for j in xrange(c):
            els = A[b(i,j)]
            sum_A = els[np.where(els % 2)].sum() # only sum odd elements
            B[i,j] = sum_A
    return B

Test

A = array([[3,2,8,1,1],
           [1,2,4,1,1],
           [7,3,4,1,8],
           [1,8,0,6,4],
           [5,6,5,3,8]])

# check new function vs. old function
(sum_neighbours(A) == sum_neighbours_NEW(A)).all()
True

Explanation

Try this loop for scanning across the 'surrounding elements', it returns a tuple of x,y elements split into individual x and y arrays as specified by numpy indexing

def b(x,y, size=A.shape):
    xlim,ylim = size # get limits of axes

    # generate a list of all i,j bordering x,y
    idx = [[x+i,y+j] for i in range(-1,2) for j in range(-1,2) \
           if (i,j) != (0,0) and (x+i>=0 and y+j>=0) and (x+i<xlim and y+j<ylim)]
    idx = np.asarray(idx) # convert to numpy array
    return idx[:,0], idx[:,1] # split into x,y for indexing

idx = b(3,2) 
# check correct by matching indexes e.g. 
# (idx[0][0],idx[1][0]) => (2,1) , (idx[0][1],idx[1][1]) => (2,2) etc.
print idx 
(array([2, 2, 2, 3, 3, 4, 4, 4]), array([1, 2, 3, 1, 3, 1, 2, 3]))

Then you can access elements in A by:

els = A[idx]
print els
array([3, 4, 1, 8, 6, 6, 5, 3])

You can then sum all elements that are odd by:

print els[np.where(els % 2)].sum()
12

use this to obtain the sum across every element in A .

Answer 3

The top portion of this should help out in getting just the odd elements.

import numpy as np
# generate an array of random integers
A = np.random.random_integers(1,10, [20,10])
# get only the odd values back from the array
A_odds = A*(A%2!=0)
# pad the array with zeros to make summing easier
A_odds_padded = np.pad(array=A_odds, pad_width=1, mode='constant')
# iterate elements and sum
B = np.zeros(np.shape(A))
for i in range(shape(B)[0]):
    for j in range(shape(B)[1]):
        #etc

Answer 4

I have this:

def find_odd_sum(arr):
    # Pad the original array
    arr_pad = np.pad(arr, 1, 'constant', constant_values=0)

    shape = np.shape(arr)
    arr_b = np.zeros((shape[0] + 2, shape[1] + 2))

    for ii in range(0, shape[0]):  #rows
        for jj in range(0, shape[1]):  #cols
            point = np.array([ii+1, jj+1])
            # Points to check
            kernel = [np.array([-1, 0]),
                      np.array([0, 1]), 
                      np.array([1, 0]), 
                      np.array([0, -1]),
                      np.array([-1, -1]),
                      np.array([1, 1]),
                      np.array([-1, 1]),
                      np.array([1, -1])]
            points = [k+point for k in kernel]
            s = [arr_pad[points[i][0], points[i][1]] for i in range(len(points))]
            s1 =sum([i for i in s if i % 2 != 0])
            arr_b[point[0], point[1]] = s1

    return arr_b[1:-1, 1:-1]



>>>
[[  1.   4.   2.   3.   3.]
 [ 13.  14.   6.   4.   4.]
 [  5.   9.   5.   2.   3.]
 [ 15.  21.  12.   9.   4.]
 [  1.  11.   3.   5.   3.]]