问题 A: 1的个数
题目描述
输入一个int型的正整数,计算出该int型数据在内存中存储时1的个数。
输入
输入一个整数(int类型)。
输出
这个数转换成2进制后,输出1的个数。
样例输入 Copy
5
样例输出 Copy
2
i = int(input())
bs = bin(i)
ans = 0
for b in bs :
if b == '1':
ans += 1
print(ans)
问题 B: 又一道简单题
题目描述
输入一个四个数字组成的整数 n,你的任务是数一数有多少种方法,恰好修改一个数字,把它 变成一个完全平方数(不能把首位修改成 0)。比如 n=7844,有两种方法:3844=622 和 7744=882。
输入
输入第一行为整数 T (1<=T<=1000),即测试数据的组数,以后每行包含一个整数 n (1000<=n<=9999)。
输出
对于每组数据,输出恰好修改一个数字,把 n变成完全平方数的方案数
样例输入 Copy
2 7844 9121
样例输出 Copy
Case 1: 2 Case 2: 0
import math
def pf(n):
root = math.sqrt(n)
return int(root + 0.5) ** 2 == n
def fa(n):
count = 0
for i in range(4): # 对每一位进行遍历
temp = list(str(n).zfill(4))
if i == 0:
for j in range(1,10):
temp[i] = str(j)
if pf(int(''.join(temp))) and(int(''.join(temp))) != n :
count += 1
else:
for j in range(10):
temp[i] = str(j)
if pf(int(''.join(temp))) and (int(''.join(temp))) != n:
count += 1
return count
while 1:
n = int(input())
aa = []
ans = 0
for i in range(n):
num = int(input())
aa.append(num)
for i in range (len(aa)):
print(f'Case {i + 1}: {fa(aa[i])}')
问题 C: 安置路灯
题目描述
小Q正在给一条长度为n的道路设计路灯安置方案。
为了让问题更简单,小Q把道路视为n个方格,需要照亮的地方用'.'表示, 不需要照亮的障碍物格子用'X'表示。
小Q现在要在道路上设置一些路灯, 对于安置在pos位置的路灯, 这盏路灯可以照亮pos - 1, pos, pos + 1这三个位置。
小Q希望能安置尽量少的路灯照亮所有'.'区域, 希望你能帮他计算一下最少需要多少盏路灯。
输入
输入的第一行包含一个正整数t(1 <= t <= 1000), 表示测试用例数 接下来每两行一个测试数据, 第一行一个正整数n(1 <= n <= 1000),表示道路的长度。 第二行一个字符串s表示道路的构造,只包含'.'和'X'。
输出
对于每个测试用例, 输出一个正整数表示最少需要多少盏路灯。
样例输入 Copy
2 3 .X. 11 ...XX....XX
样例输出 Copy
1 3
t = int(input())
for i in range(t):
n = int(input())
s = input()
i = 0
ans = 0
while i < n:
if s[i] == 'X':
i += 1
else:
ans += 1
i += 3
print(ans)
问题 D: 单源最短路径问题
题目描述
编程实现Dijkstra算法,求一个有向加权图中,从源点出发到其他各个顶点的最短路径。
输入
第1行第1个值表示顶点个数,第2个值表示边个数;第2行开始为边(两个顶点,边的起点和终点)及权重。
输出
顶点0到每一个顶点的最短路径长度。
样例输入 Copy
5 7 0 1 10 0 3 30 0 4 100 1 2 50 2 4 10 3 2 20 3 4 60
样例输出 Copy
0 10 50 30 60
import heapq
def dijkstra(graph, start):
diss = {v: float('infinity') for v in graph}
diss[start] = 0
priority_queue = [(0, start)]
while priority_queue:
current_dis, current_v = heapq.heappop(priority_queue)
if current_dis > diss[current_v]:
continue
for neighbor, weight in graph[current_v].items():
dis = current_dis + weight
if dis < diss[neighbor]:
diss[neighbor] = dis
heapq.heappush(priority_queue, (dis, neighbor))
return diss
dot,line = map(int,input().split())
graph = {i: {} for i in range(dot)}
for _ in range(line):
start, end, weight = map(int, input().split())
graph[start][end] = weight
start_v = 0
shortest_paths = dijkstra(graph, start_v)
print(' '.join(map(str, [shortest_paths[i] for i in range(dot)])))
问题 E: ABC + DEF = GHI
题目描述
用1, 2, 3...9 这九个数字组成一个数学公式,满足:ABC + DEF = GHI,每个数字只能出现一次,编写程序输出所有的组合。
输入
无
输出
输出所有的 ABC + DEF = GHI,
每行一条数据,格式为ABC+DEF=GHI
输出结果按照ABC升序排列,如果ABC相同,则按照DEF升序排列。
from itertools import permutations
# 生成1-9的所有排列
digits = list(range(1, 10))
all_permutations = permutations(digits)
# 存储满足条件的组合
valid_combinations = []
# 检查每个排列
for perm in all_permutations:
ABC = perm[0] * 100 + perm[1] * 10 + perm[2]
DEF = perm[3] * 100 + perm[4] * 10 + perm[5]
GHI = perm[6] * 100 + perm[7] * 10 + perm[8]
if ABC + DEF == GHI:
valid_combinations.append((ABC, DEF, GHI))
# 按照要求排序
valid_combinations.sort()
# 输出结果
for ABC, DEF, GHI in valid_combinations:
print(f"{ABC}+{DEF}={GHI}")
问题 F: 油田问题
题目描述
输入一个m行n列的字符矩阵,统计字符“@”组成多少个八连块。如果两个字符“@”所在的格子相邻(横、竖或者对角线方向),即属于同一个八连块。
输入
输入行数m,以及列数n。
然后输入*和@
1<=n,m<=100
输出
样例输入 Copy
5 5 ****@ *@@*@ *@**@ @@@*@ @@**@
样例输出 Copy
2
def dfs(w: int, e: int):
q = [[w, e]]
while q:
tw, te = q.pop(0)
for d in directions:
dw, de = tw + d[0], te + d[1]
if 0 <= dw < m and 0 <= de < n and maze[dw][de] == '@' and visited[dw][de] == 0:
visited[dw][de], _ = cnt, q.insert(0, [dw, de])
return
directions = [[-1, 0], [1, 0], [0, -1], [0, 1], [-1, -1], [1, -1], [-1, 1], [1, 1]]
while True:
try:
m, n = map(int, input().split())
maze, visited, cnt = [input().strip() for _ in range(m)], [[0] * n for _ in range(m)], 0
for i in range(m):
for j in range(n):
if maze[i][j] == '@' and visited[i][j] == 0:
visited[i][j], cnt = cnt + 1, cnt + 1
dfs(i, j)
# print(visited)
print(cnt)
except:
break