文章目录
- 1.寻找相同字串
- 2.密钥格式化
- 3.五键键盘的输出
- 4.单词重量
- 5.输出指定字母在字符串的中的索引
- 6.污染水域
- 7.九宫格按键输入
- 8.任务最优调度
- 9.高效的任务规划
1.寻找相同字串
题目描述:
给你两个字符串t和p，要求从t中找到一个和p相同的连续子串，并输出该子串第一个字符的下标。
输入描述:
输入文件包括两行 分别表示字符串t和p
保证t的长度不小于p
且t的长度不超过1000000
p的长度不超过10000
输出描述:
如果能从t中找到一个和p相等的连续子串，则输出该子串第一个字符在t中的下标，下标从左到右依次为1,2,3,…；
如果不能，则输出 “No”
如果含有多个这样的子串，则输出第一个字符下标最小的
用例：
输入：AVERDXIVYERDIAN
RDXI
输出：4
"""寻找相同字串"""
def search_same_string(t: str, p: str):
""""""
t_len = len(t)
p_len = len(p)
for i in range(t_len):
if t[i] == p[0]:
for j in range(p_len):
if t[i+j] != p[j]:
break
else:
return i + 1
return "No"
t = "AVERDXIVYERDIAN"
p = "RDXI"
result = search_same_string(t, p)
print(result)
2.密钥格式化
题目描述:
给定一个非空字符串 S，其被 N 个’-‘分隔成 N+1 的子串，给定正整数 K，要求除第一个子串外，其余的串每 K 个用’-‘分隔，并将小写字母转换为大写。
输入描述:
正整数 K 和‘-’分割的字符串，如：
2
25G3C-abc-d
输出描述:
转换后的字符串
用例1：
输入：4
5F3Z-2e-9-w
输出：5F3Z-2E9W
用例2：
输入：2
2-5g-3-J
输出：2-5G-3J
"""密钥格式化"""
def key_format(k: int, s: str):
""""""
s_split = s.split("-")
post_s = "".join(s_split[1:]).upper()
post_s_split = [post_s[i:i+k] for i in range(0, len(post_s), k)]
post_s = "-".join(post_s_split)
result = f"{s_split[0]}-{post_s}"
return result
k = 4
s = "5F3Z-2e-9-w"
result = key_format(k, s)
print(result)
3.五键键盘的输出
题目描述：
有一个特殊的5键键盘，上面有a，ctrl-c，ctrl-x，ctrl-v，ctrl-a五个键。
a键在屏幕上输出一个字母a；
ctrl-c将当前选择的字母复制到剪贴板；
ctrl-x将当前选择的字母复制到剪贴板，并清空选择的字母；
ctrl-v将当前剪贴板里的字母输出到屏幕；
ctrl-a选择当前屏幕上的所有字母。
注意：
剪贴板初始为空，新的内容被复制到剪贴板时会覆盖原来的内容
当屏幕上没有字母时，ctrl-a无效
当没有选择字母时，ctrl-c和ctrl-x无效
当有字母被选择时，a和ctrl-v这两个有输出功能的键会先清空选择的字母，再进行输出
给定一系列键盘输入，输出最终屏幕上字母的数量。
输入描述:
输入为一行，为简化解析，用数字1 2 3 4 5代表a，ctrl-c，ctrl-x，ctrl-v，ctrl-a五个键的输入，数字用空格分隔。
输出描述:
输出一个数字，为最终屏幕上字母的数量。
用例1：
输入：[1, 1, 1]
输出：3
用例2：
输入：[1, 1, 5, 1, 5, 2, 4, 4]
输出：2
"""5键键盘的输出"""
def five_key_board(opts: list):
""""""
output = ""
select = ""
backup = ""
for n in opts:
if n == 1:
if select:
output = ""
select = ""
output += "a"
if n == 2:
if not select:
continue
backup = select
if n == 3:
if not select:
continue
backup = select
output = ""
if n == 4:
if select:
output = ""
select = ""
output += backup
if n == 5:
if not output:
continue
select = output
return len(output)
opts = [1, 1, 5, 1, 5, 2, 4, 4]
result = five_key_board(opts)
print(result)
4.单词重量
题目描述：
每个句子由多个单词组成，句子中的每个单词的长度都可能不一样，我们假设每个单词的长度Ni为该单词的重量，你需要做的就是给出整个句子的平均重量V。
输入描述:
无
输出描述:
无
用例1：
输入：“Who Love Solo”
输出：3.67
"""单词重量"""
def word_weight(s: str):
""""""
words = s.split()
words_len = len(words)
all_w = 0
for word in words:
all_w += len(word)
result = round(all_w / words_len, 2)
return result
s = "Who Love Solo"
result = word_weight(s)
print(result)
5.输出指定字母在字符串的中的索引
题目描述：
给定一个字符串，把字符串按照大写在前小写在后排序，输出排好后的第 K 个字母在原来字符串的索引。
相同字母输出第一个出现的位置。
输入描述:
无
输出描述:
无
用例1：
输入：hAkDAjByBq
4
输出：6
"""输出指定字母在字符串的中的索引"""
def output_index(s: str, k: int):
""""""
new_s = sorted(s)
s_len = len(s)
for i in range(s_len):
if s[i] == new_s[k-1]:
return i
s = "hAkDAjByBq"
k = 4
result = output_index(s, k)
print(result)
6.污染水域
题目描述：
输入一行字符串，字符串可转换为N*N的数组，数组可认为是一个水域，判断多少天后，水域被全部污染。
数组中只有0和1，0表示纯净，1表示污染，每天只可污染上下左右的水域，如果开始全部被污染，或永远无法污染，则返回-1。
输入描述:
无
输出描述:
无
用例1：
输入：[[1,0,1], [0,0,0], [1,0,1]]
输出：2
用例2：
输入：[[0,0], [0,0]]
输出：-1
"""污染水域"""
def pollute_water(nums: list):
""""""
polluted = []
nums_len = len(nums)
for x in range(nums_len):
for y in range(nums_len):
if nums[x][y] == 0:
continue
polluted.append((x, y))
if not polluted or len(polluted) == nums_len * nums_len:
return -1
def operate():
polluted_len = len(polluted)
for i in range(polluted_len):
x = polluted[i][0]
y = polluted[i][1]
if x - 1 >= 0 and (x - 1, y) not in polluted:
polluted.append((x - 1, y))
if x + 1 < nums_len and (x + 1, y) not in polluted:
polluted.append((x + 1, y))
if y - 1 >= 0 and (x, y - 1) not in polluted:
polluted.append((x, y - 1))
if y + 1 < nums_len and (x, y + 1) not in polluted:
polluted.append((x, y + 1))
day = 1
while True:
operate()
if len(polluted) == nums_len * nums_len:
return day
day += 1
nums = [
[1, 0, 1],
[0, 0, 0],
[1, 0, 1],
]
result = pollute_water(nums)
print(result)
7.九宫格按键输入
题目描述：
九宫格按键输入，输出显示内容，有英文和数字两个模式，默认是数字模式，数字模式直接输出数字，英文模式连续按同一个按键会依次出现这个按键上的字母，如果输入”/”或者其他字符，则循环中断。
字符对应关系如图：
1: ,.
2: abc
3: def
4: ghi
5: jkl
6: mno
7: pqrs
8: tuv
9: wxyz
#:
0: 空格
/:
要求输入一串按键，输出屏幕显示。
输入描述:
输入范围为数字 0~9 和字符’#’、’/’，输出屏幕显示，例如，
在数字模式下，输入 1234，显示 1234
在英文模式下，输入 1234，显示 ,adg
输出描述:
#用于切换模式，默认是数字模式，执行#后切换为英文模式；
/表示延迟，例如在英文模式下，输入 22/222，显示为 bc；
英文模式下，多次按同一键，例如输入 22222，显示为 b；
用例1：
输入：“123#222235/56”
输出：“123adjjm”
"""九宫格按键输入"""
def nine_key_input(s: str):
""""""
nums_dict = {
"1": ",.",
"2": "abc",
"3": "def",
"4": "ghi",
"5": "jkl",
"6": "mno",
"7": "pqrs",
"8": "tuv",
"9": "wxyz",
"#": "",
"0": "空格",
"/": "",
}
num_mode = True
num_index = ["-1", 0]
output = []
s_len = len(s)
for i in range(s_len):
if s[i] == "/":
num_index = ["-1", 0]
continue
if s[i] == "#":
num_mode = False
continue
if num_mode:
output.append(s[i])
num_index = ["-1", 0]
continue
if s[i] == "0":
output.append(" ")
continue
if s[i] == num_index[0]:
s_i_len = len(nums_dict[s[i]])
if num_index[1] + 1 == s_i_len:
num_index[1] = 0
else:
num_index[1] += 1
output[-1] = nums_dict[s[i]][num_index[1]]
continue
output.append(nums_dict[s[i]][0])
num_index = [s[i], 0]
result = "".join(output)
return result
s = "123#222235/56"
result = nine_key_input(s)
print(result)
8.任务最优调度
题目描述：
给定一个正整数数组表示待系统执行的任务列表，数组的每一个元素代表一个任务，元素的值表示该任务的类型。
请计算执行完所有任务所需的最短时间。
任务执行规则如下:
1.任务可以按任意顺序执行，且每个任务执行耗时间均为1个时间单位。
2.两个同类型的任务之间必须有长度为N个单位的冷却时间，比如N为2时，在时间K执行了类型3的任务，那么K+1和K+2两个时间不能执行类型3任务。
3.系统在任何一个单位时间内都可以执行一个任务，或者等待状态。
说明：数组最大长度为1000，数组最大值1000。
输入描述:
1.第一行记录一个用半角逗号分隔的数组，数组长度不超过1000，数组元素的值不超过1000，
2.第二行记录任务冷却时间，N为正整数，N<=100。
输出描述:
输出为执行完所有任务所需的最短时间。
用例1：
输入：[2, 2, 2, 3]
2
输出：7
"""任务最优调度"""
def task_optimal_solution(nums: list, n: int):
""""""
nums_len = len(nums)
min_time = 0
task = 1
task_seq = []
while task <= nums_len:
add_time_min = -1
task_index = 0
for i in range(nums_len):
if i in task_seq:
continue
task_seq_len = len(task_seq)
for j in range(-1, -n-1, -1):
if -j > task_seq_len:
continue
if nums[i] == nums[task_seq[j]]:
add_time = 1 + n + j + 1
break
else:
add_time = 1
if add_time_min == -1 or add_time < add_time_min:
add_time_min = add_time
task_index = i
min_time += add_time_min
task_seq.append(task_index)
task += 1
return min_time
nums = [2, 2, 2, 3]
n = 2
result = task_optimal_solution(nums, n)
print(result)
9.高效的任务规划
题目描述：
你有 n 台机器，编号为 1~n，每台都需要完成一项工作，机器经过配置后都能独立完成一项工作。
假设第 i 台机器你需要花 Bi 分钟进行设置，然后开始运行，Ji 分钟后完成任务。
现在，你需要选择布置工作的顺序，使得用最短的时间完成所有工作。
注意，不能同时对两台进行配置，但配置完成的机器们可以同时执行他们各自的工作。
输入描述:
第一行输入代表总共有 M 组任务数据（1<M<=10）。
每组数第一行为一个整数指定机器的数量 N（0<N<=1000）。随后的 N 行每行两个整数，第一个表示 B（0<=B<=10000），第二个表示 J（0<=J<=10000）。
每组数据连续输入，不会用空行分隔。各组任务单独计时。
输出描述:
对于每组任务，输出最短完成时间。
用例1：
输入：1
1
2 2
输出：4
用例2：
输入：1
3
1 1
2 2
3 3
输出：7
"""高效的任务规划"""
def optimal_task_plan(n: list):
""""""
n_len = len(n)
machine = 1
machine_seq = []
all_config_time = 0
min_time = 0
while machine <= 2:
config_time = -1
machine_ind = 0
max_run_time = -1
for i in range(n_len):
if i in machine_seq:
continue
run_time = n[i][1]
if max_run_time == -1 or run_time > max_run_time:
max_run_time = run_time
config_time = n[i][0]
machine_ind = i
machine_seq.append(machine_ind)
all_config_time += config_time
min_time = max(min_time, all_config_time + max_run_time)
machine += 1
return min_time
n = [(1, 1), (2, 2), (3, 3)]
result = optimal_task_plan(n)
print(result)
