赵宇 · 华为 软件开发工程师（应届，通用软件）面试押题与算法练习

import sys
def main():
    data = sys.stdin.read().split()        # 一次读完，按空白切分
    it = iter(data)
    n = int(next(it))
    arr = [int(next(it)) for _ in range(n)]
    # 按行读取时：lines = sys.stdin.read().splitlines()
    print(solve(n, arr))

def solve(n, arr):
    return sum(arr)

if __name__ == "__main__":
    main()

把核心逻辑和 I/O 分开写，面试官看得清楚，也方便口述。Java 用 BufferedReader + StreamTokenizer，避免 Scanner 超时。

# 按出现次数降序，次数相同按字典序升序
from collections import Counter
cnt = Counter(words)
res = sorted(cnt.items(), key=lambda kv: (-kv[1], kv[0]))
# 分辨率排序：按宽*高降序，相同按宽降序
res = sorted(items, key=lambda s: (-(s[0]*s[1]), -s[0]))

from collections import deque
def bfs(grid, sr, sc):
    m, n = len(grid), len(grid[0])
    dist = [[-1]*n for _ in range(m)]
    q = deque([(sr, sc)]); dist[sr][sc] = 0
    while q:
        r, c = q.popleft()
        for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):
            nr, nc = r+dr, c+dc
            if 0 <= nr < m and 0 <= nc < n and grid[nr][nc] != '#' and dist[nr][nc] == -1:
                dist[nr][nc] = dist[r][c] + 1
                q.append((nr, nc))
    return dist

class DSU:
    def __init__(self, n):
        self.p = list(range(n)); self.sz = [1]*n
    def find(self, x):
        while self.p[x] != x:
            self.p[x] = self.p[self.p[x]]   # 路径压缩
            x = self.p[x]
        return x
    def union(self, a, b):
        a, b = self.find(a), self.find(b)
        if a == b: return False
        if self.sz[a] < self.sz[b]: a, b = b, a
        self.p[b] = a; self.sz[a] += self.sz[b]
        return True

import heapq
def topo(n, edges):
    g = [[] for _ in range(n)]; indeg = [0]*n
    for u, v in edges:
        g[u].append(v); indeg[v] += 1
    h = [i for i in range(n) if indeg[i] == 0]; heapq.heapify(h)
    order = []
    while h:
        u = heapq.heappop(h); order.append(u)
        for v in g[u]:
            indeg[v] -= 1
            if indeg[v] == 0: heapq.heappush(h, v)
    return order if len(order) == n else None   # None 表示有环

def max_min_gap(pos, k):          # 在 pos 中选 k 个点，使最小间距最大
    pos.sort()
    def ok(d):                    # 间距 >= d 时能否放下 k 个
        cnt, last = 1, pos[0]
        for x in pos[1:]:
            if x - last >= d:
                cnt += 1; last = x
        return cnt >= k
    lo, hi = 1, pos[-1] - pos[0]
    while lo < hi:
        mid = (lo + hi + 1) // 2
        if ok(mid): lo = mid
        else: hi = mid - 1
    return lo

def knap01(W, items):             # items: [(weight, value)]
    dp = [0]*(W+1)
    for w, v in items:
        for c in range(W, w-1, -1):          # 倒序：每件一次
            dp[c] = max(dp[c], dp[c-w] + v)
    return dp[W]

def knap_complete(W, items):
    dp = [0]*(W+1)
    for w, v in items:
        for c in range(w, W+1):              # 正序：可重复
            dp[c] = max(dp[c], dp[c-w] + v)
    return dp[W]

def next_greater(nums):
    res = [-1]*len(nums); st = []
    for i, x in enumerate(nums):
        while st and nums[st[-1]] < x:
            res[st.pop()] = x
        st.append(i)
    return res