编程题练习@9-5

题目一：

题目描述
解析输入的字符串数组，提取出字符串中的时间戳信息，并且将字符串按照时间戳排序后，输出到控制台。

输入描述

第1行指定数组的size; 第2行到第n行，每行为一个独立的字符串，n为size的值。
每行的字符串由”/-:”和字母、数字组成，时间戳在字符串中的位置不确定时间戳格式为:2019-01-01T07:30:20，表示2019年1月1日，7点30分20秒时间为24小时制。

输出描述

将输入的字符串按照时间戳进行从小到大排序后，输出。 符合如下规则: 1、如果时间戳信息相同，按照字符串长度从小到大进行排序;
2、如果长度相同，则按照从首字符开始的ASCII码值比较，从小到大进行排序; 3、如果两个字符串完全一样，则只需要输出一个。

示例1
输入

5
my/2019-01-01T09:00:01
my/2019-01-01T09:00:01
abc/2018-12-24T08:00:00/test/you
1/2018-12-24T08:00:00/test/Test1
123/2018-12-24T08:00:09/test/me

输出

1/2018-12-24T08:00:00/test/Test1
abc/2018-12-24T08:00:00/test/you
123/2018-12-24T08:00:09/test/me
my/2019-01-01T09:00:01

size = int(input())
timestamps = []
for _ in range(size):
    timestamps.append(input())

def custom_sort(timestamp):
    parts = timestamp.split("/")
    ts_index = None
    for i, part in enumerate(parts):
        if "-" in part and "T" in part:
            ts_index = i
            break
    if ts_index is not None:
        ts = parts[ts_index]
        return (ts, len(timestamp), timestamp)
    else:
        return (timestamp, len(timestamp), timestamp)

sorted_timestamps = sorted(timestamps, key=custom_sort)

unique_timestamps = []
for ts in sorted_timestamps:
    if ts not in unique_timestamps:
        unique_timestamps.append(ts)

for ts in unique_timestamps:
    print(ts)
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

1/2018-12-24T08:00:00/test/Test1
abc/2018-12-24T08:00:00/test/you
123/2018-12-24T08:00:09/test/me
my/2019-01-01T09:00:01
1
2
3
4

题目二：

题目描述
有一个很长的英文单词串，里面全是小写字母，请你统计一下里面长度大于等于k的单词一共出现了多少次，然后输出出现频率最高的那个单词。
如果有多解，输出长度较小的那一个，如果长度相同，输出字典序较小的那一个。

输入描述
第一行一个整数K，如题中描述。
第二行一个字符串str，只包含小写字母，长度不给出。
k<=50
len(str)<=100000

输出描述
一行一个字符串，表示满足长度大于等于h且频率最高的字符串，无解输出-1。

示例1

输入
2
abababababa

输出
ab

import collections

# 输入K和字符串str
K = int(input())
str = input()

# 获取字符串的长度
str_length = len(str)

# 初始化结果列表
words = []

# 遍历字符串，切割成所有长度大于等于K的子串
for i in range(str_length):
    for j in range(i + K, str_length + 1):
        substr = str[i:j]
        words.append(substr)

# 创建一个字典来存储单词和它们的出现次数
word_count = collections.defaultdict(int)

# 统计长度大于等于K的单词出现次数
for word in words:
    word_count[word] += 1

# 找到出现频率最高的单词
if word_count:
    print(min(word_count, key=lambda x: (-word_count[x], len(x), x)))
else:
    print(-1)
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

ab
1

题目三：

题目描述
给定一个二叉树的根节点root，该树的节点值都在数字0-9之间，每一条从根节点到叶子节点的路径都可以用一个数字表示。
1 该题路径定义为从树的根结点开始往下一直到叶子结点所经过的结点
2 叶子节点是指没有子节点的节点
3 路径只能从父节点到子节点，不能从子节点到父节点
4 总节点数目为n

用例：
输入
1
↙ ↘
2 3
输出
25

说明：
例如根节点到叶子节点的一条路径是1->2->3，那么这条路径就用123来代替。 找出根节点到叶子节点的所有路径表示的数字之和。 例如这棵二叉树一共有两条路径根节点到叶子节点的路径1->2用数字12代替根节点到叶子节点的路径1->3用数字13代替所以答案为12+13=25。

# 原题是核心代码模式
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

def sumNumbers(root):
    def dfs(node, current_sum):
        if not node:
            return 0

        # 计算当前路径上的数字之和
        current_sum = current_sum * 10 + node.val

        # 如果是叶子节点，返回当前路径的数字之和
        if not node.left and not node.right:
            return current_sum

        # 否则，递归计算左子树和右子树的路径数字之和，并相加
        return dfs(node.left, current_sum) + dfs(node.right, current_sum)

    return dfs(root, 0)

# 创建示例二叉树
root = TreeNode(1)
root.left = TreeNode(2)
root.right = TreeNode(3)

# 计算根节点到叶子节点的所有路径表示的数字之和
result = sumNumbers(root)
print(result)
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

25
1