leetcode笔试--day1

"""对字符串逆序"""
print("从键盘输入一串字符串：")
list = input()
new_list = list[::-1]
print(new_list)


"""版本号比较"""
"""
比较两个版本号 _version1_ 和 _version2_
如果`_version1_>_version2_`返回`1`,如果`_version1_<_version2_`返回`-1`,除此之外返回`0`。
你可以假设版本字符串非空，并且只包含数字和 `.` 字符。
`.` 字符不代表小数点，而是用于分隔数字序列。

例如，`2.5`是第二版中的第五个小版本。
示例 1:
输入: `_version1_` = "0.1", `_version2_` = "1.1"
输出: -1

示例 2:
输入: `_version1_` = "1.0.1", `_version2_` = "1"
输出: 1

示例 3:
输入: `_version1_` = "7.5.2.4", `_version2_` = "7.5.3"
输出: -1
"""

# 分析：
# （1）循环次数不确定，用while循环
# （2）1.2.2和1.2.3（1.2.1）；1.2.2和1.2.2；1.2.2和1.2.2.2

def compare_version():
    print("请输入第一个版本：")
    version1 = input()  # 输入第一个版本
    print("请输入第二个版本：")
    version2 = input()  # 输入第二个版本
    version1_list = version1.split(".")
    version2_list = version2.split(".")
    print(version1_list, version2_list)
    i = 0
    a = 0
    while i < len(version1_list) and i < len(version2_list):
        if int(version1_list[i]) > int(version2_list[i]):  # int不要少
            a = 1
            return a
        elif int(version1_list[i]) < int(version2_list[i]):
            a = -1
            return a
        else:
            i += 1
    if i < len(version1_list) and "".join(version1_list[i:]) != 0:
        a = 1
        return a
    if i < len(version2_list) and "".join(version2_list[i:]) != 0:
        a = -1
        return a
    return a


value = compare_version()
print(value)


"""矩阵运算"""
"""
给定两个矩阵A、B，均为n行m列矩阵
求C = (((A^T)*(B))*(B^T))^T
其中^表示转置，*表示矩阵乘法

输入描述：
第一行2个数字：n,m
接下来n行，每行m个数字，用空格隔开，表示矩阵A
接下来n行，每行m个数字，用空格隔开，表示矩阵B

输出描述：
第一行2个数字：n_c和n_m表示C的行数和列数
接下来n_c行，每行m_c个数，用空格隔开，表示矩阵C

--例子--
输入：
2 2
1 2
3 4
4 3
2 1
输出：
58 94
26 42
"""
def get_array():
    """获取矩阵"""
    [n, m] = [int(num) for num in input().split(" ")]  # print("输入n和m：%d, %d" % (n, m))
    listA, listB = [], []
    for i in range(n):
        list = [int(num) for num in input().split(" ")]
        listA.append(list[0:m])

    for i in range(n):
        list1 = [int(num) for num in input().split(" ")]
        listB.append(list1[0:m])
    # print(listA)
    # print(listB)
    return listA, listB


def Transpose(list):
    """ 对矩阵转置"""
    n, m = len(list), len(list[0])
    list_zero = []  # 创建一个list的全0转置阵
    list_zero_in = []
    for i in range(m):
        for j in range(n):
            list_zero_in.append(0)
        list_zero.append(list_zero_in)
        list_zero_in = []
    # print(list_zero)

    for i in range(n):  # 转置矩阵
        for j in range(m):
            list_zero[j][i] = list[i][j]
    # print(list_zero)
    return list_zero


def Dot(listA, listB):
    """矩阵乘法"""
    listC = []
    listC_in = []
    for i in range(len(listA)):
        for j in range(len(listB[0])):
            listC_in.append(0)
        listC.append(listC_in)
        listC_in=[]
    # print(listC)

    sum_val = 0
    for i in range(len(listA)):
        for k in range(len(listB[0])):  # 这个地方是关键
            for j in range(len(listA[0])):
                  sum_val += listA[i][j] * listB[j][k]
            listC[i][k] = sum_val
            sum_val = 0
    # print(listC)
    return listC


def Transform(listA):
    """二维矩阵数字转换成字符"""
    for i in range(len(listA)):
        for j in range(len(listA[0])):
            listA[i][j] = str(listA[i][j])
    for i in range(len(listA)):
        print(" ".join(listA[i]))


if __name__ == "__main__":
    listA, listB = get_array()  # 接受输入
    # Transpose([[1, 4], [2, 3]])  # 对矩阵转置
    # Dot([[1, 2], [3, 4]], [[1, 1, 4], [2, 3, 1]])  # 矩阵的乘法
    # (((A ^ T) * (B)) * (B ^ T)) ^ T
    answer = Transpose(Dot(Dot(Transpose(listA), listB), Transpose(listB)))
    Transform(answer)


"""水源出水"""
"""
在n行m列的二维地图中，一开始每个格子的水位都是0
某一天，在a行b列处出现一个出水量为c的水源
水源周围一圈水量是c[i]-1,再周围一圈水量减少1，直到水量不够为止

--例子--
n=3, m=4, a=1, b=2, c=3
3行4列的地图上，第1行第2列处，出水量为3
0121
1232
0121

输入描述：
第一行为T，表示有T组测试样例
接下来每组样例，每行为n,m,a,b,c
（行列坐标都是从0开始的）
输出描述：
先输出一行"Case #%d:"
接下来n行，每行m个整数，用空格隔开，表示地图上每个位置的水位

输入：
2
3 4 1 2 3
3 4 2 1 2

输出：
Case #1:
0 1 2 1
1 2 3 2
0 1 2 1
Case #2:
0 0 0 0
0 1 0 0
1 2 1 0

备注：
T<=100
1<=n<=100
1<=m<=100
0<=a<n
0<=b<m
0<=b<500
"""


def get_input():
    num = int(input())  #假设num等于2
    if num <= 100:
        case = []
        for i in range(num):
            case.append([int(num) for num in input().split(" ")])
    return case


def solve(case_demo):
    [n, m, a, b, c] = case_demo
    case_list = []
    case_list_in = []
    for _ in range(n):
        for _ in range(m):
            case_list_in.append(0)
        case_list.append(case_list_in)
        case_list_in = []
    case_list[a][b] = c
    for i in range(n):
        for j in range(m):
            if c - (abs(a-i)+abs(b-j)) <= 0:
                case_list[i][j] = 0
            else:
                case_list[i][j] = c - (abs(a-i)+abs(b-j))
    return case_list


def Transform(listA):
    """二维矩阵数字转换成字符"""
    for i in range(len(listA)):
        for j in range(len(listA[0])):
            listA[i][j] = str(listA[i][j])
    for i in range(len(listA)):
        print(" ".join(listA[i]))


if __name__ == "__main__":
    case = get_input()  # case = [[3, 4, 1, 2, 3], [3, 4, 2, 1, 2]]
    for i, case_num in enumerate(case):
        print("Case #%d:" % (i+1))
        case_list = solve(case_num)
        Transform(case_list)
# 3
# 3 4 1 2 3
# 3 4 2 1 2
# 5 5 2 2 6