Python实现顺时钟回形矩阵

  无意间在网上看到了一个面试题是,写出一个回形矩阵。实现的效果大致如下:  

  [ 1,   2,   3,   4, 5]
  [16, 17, 18, 19, 6]
  [15, 24, 25, 20, 7]
  [14, 23, 22, 21, 8]
  [13, 12, 11, 10, 9]

  因为日常都是使用Python,刚开始觉得使用list的append方法就可以做出来,动手一下发现还是不行的。后来,觉得应该先根据参数容量制作一个list,用list的替换方法来做替换。处理的过程中,还是发现有很多思维断掉的地方。

  最后,在别人的博客上看到2004年,有人用Python实现了逆时钟方向的回形矩阵。借鉴了一下他的方法。大致的思路是这样的:

  第0步:回形矩阵的特点是什么?

  顺时钟回形矩阵,在等差值为1的情况下,按照一个回形为一层的情况来看:

  推导的前三条矩阵边上的 “结束值” - “起始值” = “矩阵边长”-1,第四条矩阵边的 "结束值" 为 该层的起始值。

  [ 1, 2, 3, 4,  5]

  [16,   ,   ,   , 6]

  [15,   ,   ,   , 7]

  [14,   ,   ,   , 8]

  [13,12,11,10,9]

  

  第一步,根据设定的矩阵边长,生成一个二维数组(C语言中这么描述,Python就是list里面嵌套list)

1 for i in range(size):
2         arry.append(range(size))

  第二步,按照矩阵边长生成该层的数据池:

1 while size >0 :
2     create pool()
3     layer += 1        
4     size -= 2

  最终代码:

  

 1 #!/usr/bin/env python
 2 # coding: utf-8
 3
 4
 5 def draw_matrix(begin, size, layer, arry, controlle_num):
 6     # 以顺时钟方向建立递增矩阵,按照层级
 7     # 根据递增1的特点,建立当前层的上下左右,四个list,形成资源池
 8     # 每个方向list的长度都等于size的长度
 9     # [1,2,3]
10     # [8, ,4]
11     # [7,6,5]
12     top = range(begin, begin+size)
13     right = range(begin+size-1, begin+size*2-1)
14     bottom = range(begin+size*2-2, begin+size*3-2)
15     left = range(begin+size*3-3, begin+size*4-3)
16     left[size-1] = begin       # 顺时钟的左list最后一个值改为起始值
17
18     # size相当矩阵的边长,i既可以表示长,也可以表示宽
19     # 通过i步进来从本层的资源池里面取得各个值
20     for i in range(size):
21         arry[layer][layer+i] = top[i]
22         arry[layer+i][controlle_num-layer-1] = right[i]
23         arry[controlle_num-layer-1][controlle_num-layer-i-1] = bottom[i]
24         arry[controlle_num-1-layer-i][layer] = left[i]
25     return arry
26
27
28 def Matrix(size, begin=1, layer=0):
29     controlle_num = size
30     arry = []
31     for i in range(size):
32         arry.append(range(size))
33     while size > 0:
34         arry = draw_matrix(begin, size, layer, arry, controlle_num)
35         begin = begin+(4*(size-1))
36         size = size - 2
37         layer = layer + 1
38     return arry
39
40
41 if __name__ == ‘__main__‘:
42     dat = Matrix(5)
43     for i in range(5):
44         print dat[i]
时间: 2024-10-29 19:11:54

Python实现顺时钟回形矩阵的相关文章

2.python算法之回形矩阵

代码: #!/usr/bin/env python # encoding: utf-8 """ @author: 侠之大者kamil @file: 2.回形矩阵.py @time: 2016/3/21 10:51 """ def sankeMatric(n): m = [[0] * n for x in range(n)] p = 0 q = n-1 t = 1 while p < q: for i in range(p,q): m[p][

『Python』PIL图像处理_矩阵转化

应师兄要求改图,因为使用了PIL包把图片对象转化为numpy的矩阵,截取以及处理很好玩且方便,特此记录: 1 import numpy as np 2 from PIL import Image 3 import matplotlib.pyplot as plt 4 5 img = Image.open('./7b6021ef9e6892dcf14dc5dd269afaada763fedc13b29-iHXENu_fw658.jpeg') 6 plt.imshow(img) 7 plt.show

使用python求海森Hessian矩阵

考虑一个函数$y=f(\textbf{x}) (R^n\rightarrow R)$,y的Hessian矩阵定义如下: 考虑一个函数:$$f(x)=b^Tx+\frac{1}{2}x^{T}Ax\\其中b^T=[1,3,5], A在代码中可读$$ 求该函数在x = [0,0,0]处海森矩阵值的python代码如下: import torch # 定义函数 x = torch.tensor([0., 0, 0], requires_grad=True) b = torch.tensor([1.,

python 入门(一)矩阵处理

numpy 使用 1.使用 array 定义矩阵 dataSet = array([[1.0,1.1],[1.0,1.0],[0.0,0.0],[0,0.1]]) 2.使用 shape 返回矩阵的行数(列数) dataSet.shape[0] #4dataSet.shape[1] #2 3.使用 tile 成倍的扩大矩阵 intX =array([0,1,1,1]) tsample = tile(intX,(4,2)) # 表示将矩阵 行复制4次,列复制2次 4.矩阵各个元素值的平方/开平方 s

利用python中的PIL进行矩阵与图像之间的转换

1.图像转换为矩阵 matrix = numpy.asarray(image) 2.矩阵转换为图像 image = Image.fromarray(matrix)

python numpy初始化一个图像矩阵

mask_all = np.zeros((256, 256), dtype='uint8')  单通道 mask_all_enlarge = np.zeros((256, 256, 3), dtype='uint8'  三通道 #为三通道图像赋值,这里我用的是循环,因该还有更简单的方式 img_base = np.zeros((256, 256, 3), np.uint8)     for i in range(256):        for j in range(256):         

python实现简单的并行矩阵乘法

本文采用的矩阵乘法方式是利用一个矩阵的行和二个矩阵的列相乘时不会互相影响.假设A(m,n)表示矩阵的m行,n列.那么C(m,m)=A(m,n) B(n,m) :计算C矩阵时候分解成:process-1:C(1,1) = A(1,:) B(:,1) process-2:C(1,2) = A(1,:) * B(:,2) .......... process-mC(m,m) = A(m,:) * B(:,m) 实现源码:import multiprocessing #导入多进程模块,实现多进程impo

python动态演示动态规划解决矩阵连乘

矩阵连乘:给定n个矩阵:A1,A2,...,An,其中Ai与Ai+1是可乘的,i=1,2...,n-1.确定计算矩阵连乘积的计算次序,使得依此次序计算矩阵连乘积需要的数乘次数最少.输入数据为矩阵个数和每个矩阵规模,输出结果为计算矩阵连乘积的计算次序和最少数乘次数. 若A是一个p*q的矩阵,B是一个q*r的矩阵,则其乘积C=AB是一个p*r的矩阵.数乘次数是p*q*r. 动态规划算法与分治法类似,其基本思想也就是将待求解的问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解,简

Python中2维数组/矩阵转化为字典(矩阵中第一列含有重复元素)??

例如将a=[[3,789],[1,100],[1,102],[2,102],[1,106],[2,456]];转化为一个字典b={1:[100,102,102],2:[102,456],3:[789]} 如果用强制转换: 1 >>> a=[[3,789],[1,100],[1,102],[2,102],[1,106],[2,456]]; 2 >>> b=dict(a) 3 >>> b 4 {1: 106, 2: 456, 3: 789} 5 >&