编程题练习@9-7

题目一：

题目描述
一个有序的整数列表示方式通常使用逗号隔开。如果序列中的几个整数是连续递增 1 时可以使用数字范围的方式表达，通常用[-] 符隔开。而 [-]的两端分别表示此数据范围的起始数据和结束数据 (包括起始数据和结束数据)，如果想使用区域的表达方式必须保证区域中至少有 3 个整数。
例如: 12.13,15-17。
此任务会提供一个有序的整数列表，你需要编写函数按上述描述将此列表进行相应的格式化。

示例:
输入
-6 -3 -2 -1 0 1 3 4 5 7 8 9 10 11 14 15 17 18 19 20
输出
-6,-3-1,3-5,7-11,14,15,17-20

代码如下：

nums = [-6, -3, -2, -1, 0, 1, 3, 4, 5, 7, 8, 9, 10, 11, 14, 15, 17, 18, 19, 20]
# nums = list(map(int, input().split()))

left = right = 0
res = []

while right < len(nums):
    while right < len(nums)-1 and nums[right] == nums[right + 1] - 1:
        right += 1

    if right - left + 1 > 2:
        res.append(str(nums[left]) + '-' + str(nums[right]))
    else:
        res.extend(nums[left:right+1])
    
    right += 1
    left = right

print(','.join([str(x) for x in res]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

-6,-3-1,3-5,7-11,14,15,17-20
1

题目二：

题目描述：
每日股票价格
给定某只股票连续N天的价格列表stockPrices，其中stockPrices表示股票某天的价格请生成一个新列表，对应位置输出为:要想等到股票价格上涨，至少需要等待的天数，如果股票价格不上涨，对应位置输出为0。

输入
第一行表示第二行元素的个数N
第二行为用空格隔开的整数，表示每天股票的价格
其中0 输出
输出为用空格分隔的长度为N的列表，对应位置为;要想等到股票价格上涨，至少需要等待的天数

样例1
输入
5
33 34 14 12 16
输出
1 0 2 1 0

样例2
输入
5
12 13 14 15 16
输出
1 1 1 1 0

代码如下：

'''
从后往前
'''
stockPrices = [33, 34, 14, 12, 16]
n = 5
# n = int(input())
# stockPrices = list(map(int, input().split()))

res = [0] * n
stack = []

for i in range(n-1, -1, -1):
    while stack and stockPrices[stack[-1]] <= stockPrices[i]:
        stack.pop()
    res[i] = (i if not stack else stack[-1]) - i
    stack.append(i)

print(' '.join([str(x) for x in res]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1 0 2 1 0
1

'''
从前往后
'''
stockPrices = [33, 34, 14, 12, 16]
n = 5
# n = int(input())
# stockPrices = list(map(int, input().split()))

result = [0] * n
stack = []

for i in range(n):
    while stack and stockPrices[stack[-1]] <= stockPrices[i]:
        top = stack.pop()
        result[top] = i - top
    stack.append(i)

print(' '.join([str(x) for x in result]))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

1 0 2 1 0
1

题目三：

题目描述：
中庸行者
给定一个 m*n 的整数矩阵作为地图，矩阵数值为地形高度:
中庸行者选择地图中的任意一点作为起点，尝试往上、下、左、右四个相邻格子移动移动时有如下约束:
1 中庸行者只能上坡或者下坡，不能走到高度相同的点;
2 不允许连续上坡或者连续下坡，需要交替进行;
3 每个位置只能经过一次，不能重复行走;
请给出中庸行者在本地图内，能连续移动的最大次数。

输入
一个只包含整数的二维数组:
3 3
4 7 8
8 6 6
2 6 4
第一行两个数字，分别为行数和每行的列数；
后续数据为矩阵地图内容；
矩阵边长范围:[1,8];
地形高度范围:[0,100000];
输出
一个整数，代表中庸行者在本地图内能够移动的最大次数。

样例1
输入
2 2
1 2
4 3
输出
3

样例2
输入
33
1 2 4
3 5 7
6 8 9
输出
4

matrix = [[1, 2, 4], [3, 5, 7], [6, 8, 9]]
m, n = 3, 3
# m, n = map(int, input().split())
# matrix = []
# for _ in range(m):
#     matrix.append([int(c) for c in input().split()])

def moderateWalker(matrix, m, n):
    used = set()

    def dfs(i, j, flag):
        
        ans = 0
        for (ni, nj) in ((i+1, j), (i-1, j), (i, j+1), (i, j-1)):
            if ni < 0 or nj < 0 or ni >= m or nj >= n or \
                matrix[ni][nj] == matrix[i][j] or (ni, nj) in used:
                continue
            if flag == False and matrix[ni][nj] <= matrix[i][j]:
                continue
            if flag == True and matrix[ni][nj] >= matrix[i][j]:
                continue
            used.add((i, j))
            ans = max(ans, dfs(ni, nj, flag ^ True) + 1)
            used.remove((i, j))
        return ans

    res = 0
    for i in range(m):
        for j in range(n):
            res = max(res, dfs(i, j, False), dfs(i, j, True))
    print(res)

moderateWalker(matrix, m, n)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

4
1