携程 2026 春招笔试真题 - 研发岗（3.29）

import sys
input = sys.stdin.readline

s = input().strip()
for i in range(5):
    if s[i] == 'a':
        print(i + 1)
        break

import sys
input = sys.stdin.readline
from collections import defaultdict

n = int(input())
best = defaultdict(lambda: defaultdict(int))  # best[user][problem]
total = defaultdict(int)                       # total[user]
results = []

for _ in range(n):
    u, p, s = map(int, input().split())
    old = best[u][p]
    if s > old:
        total[u] += s - old
        best[u][p] = s

    # 计算用户 1 的排名
    score1 = total[1]
    rank = 1
    for uid in total:
        if uid != 1 and total[uid] > score1:
            rank += 1
    results.append(str(rank))

print(" ".join(results))

import sys
input = sys.stdin.readline

def suffix_array(s):
    """倍增法构建后缀数组，返回 sa 和 rank 数组"""
    n = len(s)
    sa = list(range(n))
    rank = [ord(c) for c in s]
    tmp = [0] * n
    k = 1
    while k < n:
        def cmp_key(i):
            return (rank[i], rank[i + k] if i + k < n else -1)
        sa.sort(key=cmp_key)
        tmp[sa[0]] = 0
        for i in range(1, n):
            tmp[sa[i]] = tmp[sa[i - 1]]
            if cmp_key(sa[i]) != cmp_key(sa[i - 1]):
                tmp[sa[i]] += 1
        rank = tmp[:]
        if rank[sa[-1]] == n - 1:
            break
        k *= 2
    return sa, rank

def solve():
    n = int(input())
    s = input().strip()
    a = list(map(int, input().split()))

    sa, rank = suffix_array(s)

    # 将 a 降序排列
    a_sorted = sorted(a, reverse=True)

    # sa[i] 是排名第 i 的后缀的起始位置
    # 排名第 0 小的后缀分配最大值，排名第 1 小的分配次大值...
    ans = [0] * n
    for i in range(n):
        ans[sa[i]] = a_sorted[i]

    print(" ".join(map(str, ans)))

solve()

import sys
input = sys.stdin.readline
from math import gcd

def get_divisors(b):
    """获取 b 的所有因子，升序排列"""
    divs = []
    i = 1
    while i * i <= b:
        if b % i == 0:
            divs.append(i)
            if i != b // i:
                divs.append(b // i)
        i += 1
    divs.sort()
    return divs

def solve():
    x, b, n = map(int, input().split())

    for _ in range(n):
        if x >= b:
            # 不动点: f(x) = b + gcd(x, b), 之后不再变化
            x = b + gcd(x, b)
            break

        g = gcd(x, b)

        # x < b: f(x) = x + g
        # 计算在 gcd 不变的情况下可以跳多少步
        # x, x+g, x+2g, ... 直到 gcd 变化或 x+t*g >= b
        steps_to_b = (b - x - 1) // g  # 最多这么多步还保持 x < b

        # 找最小步数使 gcd 变化: 枚举 b 的因子中大于 g 的
        divs = get_divisors(b)
        min_steps = steps_to_b + 1  # 默认跳到 >= b

        for d in divs:
            if d <= g:
                continue
            # 找最小 t >= 1 使得 d | (x + t * g)
            rem = x % d
            if rem == 0:
                # 已经整除，但 gcd(x,b) = g < d，说明 d 不整除 b 或
                # x 包含 d 但 gcd(x,b) 不等于 d —— 不可能，因为 d|b 且 d|x 则 d|gcd(x,b)
                continue
            need = d - rem  # 需要增加 need 使得 (x + need) % d == 0
            if need % g != 0:
                continue
            t = need // g
            if t == 0:
                t = d // g  # 下一个周期
            if t < min_steps:
                min_steps = t

        # 实际可跳步数受剩余 n 限制
        actual = min(min_steps, n - (_ + 1 - 1))
        # 重新计算: 当前是第 _+1 步（从0开始计数的第_步），还剩 n-1-_ 步可用
        # 但我们在循环里逐步处理，这里需要改为批量跳跃

        # 简化：直接跳 min_steps 步或剩余步数
        break  # 这个方法在循环结构里不好写，改用 while 循环

    print(x)

def solve_case():
    x, b, n = map(int, input().split())

    step = 0
    while step < n:
        if x >= b:
            g = gcd(x, b)
            x = b + g  # 不动点
            step += 1
            break

        g = gcd(x, b)
        # x < b, 每次 x += g (在 g 不变期间)
        # 还需 n - step 步

        remaining = n - step

        # 最多跳多少步 x 还 < b
        steps_to_b = (b - x - 1) // g

        # 找最小步数使 gcd 变化
        divs = get_divisors(b)
        min_change = steps_to_b + 1

        for d in divs:
            if d <= g:
                continue
            rem = x % d
            if rem == 0:
                continue
            need = d - rem
            if need % g != 0:
                continue
            t = need // g
            if t == 0:
                t = d // g
            if 0 < t < min_change:
                min_change = t

        jump = min(min_change, remaining)
        x += jump * g
        step += jump

    print(x)

t = int(input())
for _ in range(t):
    solve_case()