打印之字矩阵

题目意思是这样打印矩阵

分析一下

可以考虑 要这样打印矩阵 要考虑 斜着打印,通过两个点 来定义 一条斜线, 然后 打印这个 斜线 上的 所有点,就可以了. 下图就是分析思路:

定义 A , B 两点, 每个点都有自己的行动轨迹, A 向 右走, 走到 最右边, 往下走.
B 先 向下走, 走到最后一行,开始向右走,
A 和B 最终 会相遇, 如果 A 和B 再次 相遇, 则 A 和B 已经把整个 矩阵 走完了.

图片1

def test_print_matrix_zig(matrix):
    # A 点
    a_r, a_c = 0, 0

    # B 点
    b_r, b_c = 0, 0

    row, column = matrix.shape

    #  矩形对应的 index 下标
    row_index = row - 1
    column_index = column - 1

    while True:
        print('-------------')

        # A 向 右走, 之后 向下走
        a_r = a_r + 1 if a_c == column_index else a_r
        a_c = a_c if a_c == column_index else a_c + 1

        # B 向下走,之后 向右走
        b_c = b_c + 1 if b_r == row_index else b_c
        b_r = b_r if b_r == row_index else b_r + 1

        A = (a_r, a_c)
        B = (b_r, b_c)

        print(f"A:{A},B:{B}")
        if A == B:
            print('A==B  break')
            break


if __name__ == '__main__':
    matrix = np.arange(0, 24).reshape((4, 6))

    test_print_matrix_zig(matrix)

    print(f"\nmatrix:\n{matrix}")

    pass

result :

A:(0, 1),B:(1, 0)
-------------
A:(0, 2),B:(2, 0)
-------------
A:(0, 3),B:(3, 0)
-------------
A:(0, 4),B:(3, 1)
-------------
A:(0, 5),B:(3, 2)
-------------
A:(1, 5),B:(3, 3)
-------------
A:(2, 5),B:(3, 4)
-------------
A:(3, 5),B:(3, 5)
A==B  break

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

程序 能够正常 打印了, A, B 点 走的位置, 最后 A 和 B 同时到达了, (3,5) 位置, 程序 就退出了.

• 下面思考如何 打印 A, B 连接的一条线的 的值呢? 如图所示
  

def print_line(matrix, a_r, a_c, b_r, b_c, reverse=True):
    """


    A (a_r,a_c)
    B (b_r,b_c)

    :param matrix:
    :param a_r:
    :param a_c:
    :param b_r:
    :param b_c:
    :param reverse: bool 
    :return:
    """
    if reverse:
        while a_r != b_r + 1:
            # 从A 右上  --> B 左下 打印
            print(matrix[a_r][a_c], end=' ')
            a_r += 1
            a_c -= 1
    else:
        while b_c != a_c + 1:
            # 从B左下, --->  A 右上 打印
            print(matrix[b_r][b_c], end=' ')
            b_r -= 1
            b_c += 1

    # print('-------' * 5)

来测试一下这个函数

if __name__ == '__main__':
    matrix = np.arange(0, 24).reshape((4, 6))

    print_line(matrix, 0, 3, 3, 0, reverse=True)

    print()
    print_line(matrix, 0, 3, 3, 0, reverse=False)

    print(f"\nmatrix:\n{matrix}")

result: 可以正常的打印A–> B 边上的点的值. 也可以 从 B --> A 打印.

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

• 要完成 之字打印把这两部分 拼起来就可以了.

完整 代码如下, 因为要实现不同的方向的打印所以加了 一个布尔变量来控制打印方向.

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@Time    : 2019/1/5 10:48
@File    : print_matrix_zig_zag.py
@Author  : frank.chang@shoufuyou.com


之” 字形打印矩阵
【 题目】 给定一个矩阵matrix， 按照“之” 字形的方式打印这
个矩阵， 例如： 1 2 3 4 5 6 7 8 9 10 11 12
“之” 字形打印的结果为： 1， 2， 5， 9， 6， 3， 4， 7， 10， 11，
8， 12
【 要求】 额外空间复杂度为O(1)



"""

import numpy as np


def print_line(matrix, a_r, a_c, b_r, b_c, reverse=True):
    """


    A (a_r,a_c)
    B (b_r,b_c)

    :param matrix:
    :param a_r:
    :param a_c:
    :param b_r:
    :param b_c:
    :param reverse:
    :return:
    """
    if reverse:
        while a_r != b_r + 1:
            # 从 右上  -->  左下 打印
            print(matrix[a_r][a_c], end=' ')
            a_r += 1
            a_c -= 1
    else:
        while b_c != a_c + 1:
            # 从左下, --->  右上 打印
            print(matrix[b_r][b_c], end=' ')
            b_r -= 1
            b_c += 1

    # print('-------' * 5)


def _print_matrix_zig_zag(matrix):
    a_r, a_c = 0, 0

    b_r, b_c = 0, 0

    #
    row, column = matrix.shape

    print(f"row:{row},column:{column}")

    from_up = True
    while True:
        # print_line(matrix, a_r, a_c, b_r, b_c,from_up)
        print('----')
        if (a_r, a_c) == (row - 1, column - 1):
            break

        # A 向 右走, 之后 向下走
        a_r = a_r + 1 if a_c == column - 1 else a_r
        a_c = a_c if a_c == column - 1 else a_c + 1

        # B 向下走,之后 向右走
        b_c = b_c + 1 if b_r == row - 1 else b_c
        b_r = b_r if b_r == row - 1 else b_r + 1

        A = (a_r, a_c)
        B = (b_r, b_c)

        from_up = not from_up

        # print(f"A:{A},B:{B}")

    # print_line()
    print()


def print_matrix_zig_zag(matrix):
    # A 点
    a_r, a_c = 0, 0

    # B 点
    b_r, b_c = 0, 0

    row, column = matrix.shape
    print(f"row:{row},column:{column}")
    up = True
    while True:
        print('----')
        print_line(matrix, a_r, a_c, b_r, b_c, reverse=up)
        # 走到了 最后一个位置 , 退出条件
        if (a_r, a_c) == (row - 1, column - 1):
            break

        # A 向右走, 之后向下走
        a_r = a_r + 1 if a_c == column - 1 else a_r
        a_c = a_c if a_c == column - 1 else a_c + 1

        # B 向下走,之后 向右走
        b_c = b_c + 1 if b_r == row - 1 else b_c
        b_r = b_r if b_r == row - 1 else b_r + 1

        up = not up


def test_print_matrix_zig(matrix):
    # A 点
    a_r, a_c = 0, 0

    # B 点
    b_r, b_c = 0, 0

    row, column = matrix.shape

    #  矩形对应的 index 下标
    row_index = row - 1
    column_index = column - 1

    while True:
        print('-------------')

        # A 向 右走, 之后 向下走
        a_r = a_r + 1 if a_c == column_index else a_r
        a_c = a_c if a_c == column_index else a_c + 1

        # B 向下走,之后 向右走
        b_c = b_c + 1 if b_r == row_index else b_c
        b_r = b_r if b_r == row_index else b_r + 1

        A = (a_r, a_c)
        B = (b_r, b_c)

        print(f"A:{A},B:{B}")
        if A == B:
            print('A==B  break')
            break


def test_line():
    matrix = np.arange(0, 24).reshape((4, 6))

    print_line(matrix, 0, 3, 3, 0, reverse=True)

    print()
    print_line(matrix, 0, 3, 3, 0, reverse=False)

    print(f"\nmatrix:\n{matrix}")


if __name__ == '__main__':
    matrix = np.arange(0, 24).reshape((4, 6))

    print_matrix_zig_zag(matrix)

    print(f"\nmatrix:\n{matrix}")
    pass

result如下:

row:4,column:6
----
0 ----
6 1 ----
2 7 12 ----
18 13 8 3 ----
4 9 14 19 ----
20 15 10 5 ----
11 16 21 ----
22 17 ----
23 
matrix:
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]

总结

这个题目还是对编程思想有一定考察,要从 打印 矩阵中 找到规律, 然后就比较好下手了.