题意： 给一串$1~n$的数字，有$k$次操作，第$i$次操作满足下面两个条件： 当$i$为奇数时：交换下标为 $2*i-1$ 和 $2*i$ 的数； 当$i$为偶数时：交换下标为 $2*i$ 和 $2*i+1$ 的数。 $k$次操作全部完成之后，问数字$q$在第几位。

题解： 列出任意一种交换的情况可以发现，该操作$2*n$次操作为一个循环。 并且每个数字下标的变换满足特定的规律，按照该规律写出代码即可AC（注意边界值）。

#include <bits/stdc++.h>
using namespace std;
void solve()
{
    int n, k, q;
    cin >> n >> k >> q;
    k %= 2 * n;
 
    int ans;
    if (k == 0)
    {
        cout << q << endl;
    }
    else if (k == n)
    {
        cout << n - q + 1 << endl;
    }
    else if (k < n)
    {
        if (q & 1)
        {
            if (k >= n - q + 1)
            {
                k -= n - q + 1;
                ans = n - k;
            }
            else
            {
                ans = q + k;
            }
        }
        else
        {
            if (k >= q)
            {
                k -= q;
                ans = k + 1;
            }
            else
            {
                ans = q - k;
            }
        }
        cout << ans << endl;
    }
    else if (k > n)
    {
        k -= n;
        if (q & 1)
        {
            if (k > n - q)
            {
                k -= n - q;
                ans = k;
            }
            else
            {
                ans = (n - q) - k + 1;
            }
        }
        else
        {
            if (k > n - (n - q + 1))
            {
                k -= n - (n - q + 1);
                ans = n - k + 1;
            }
            else
            {
                ans = (n - q + 1) + k;
            }
        }
        cout << ans << endl;
    }
 
    return;
}
signed main()
{
    int _T = 1;
    cin >> _T;
    while (_T--)
    {
        solve();
    }
    return 0;
}

#include <bits/stdc++.h> using namespace std;

// 处理单个测试用例的函数 void solve() { int n, k, q; // 涉及参数：n（总长度），k（位移量），q（查询位置） cin >> n >> k >> q; k %= 2 * n; // 周期优化：位移具有2n的周期性

int ans; // 存储最终结果

/* 特殊边界条件处理 */
if (k == 0) // 无位移情况
{
    cout << q << endl; // 直接返回原位置
}
else if (k == n) // 半周期反转
{
    cout << n - q + 1 << endl; // 位置镜像翻转（如1↔n）
}
/* 正向位移逻辑（k < n） */
else if (k < n)
{
    if (q & 1) // 奇数位置处理分支
    {
        /* 当剩余空间不足时 */
        if (k >= n - q + 1) // 剩余空间计算：n - q + 1
        {
            // 消耗全部剩余空间
            k -= n - q + 1; 
            // 回绕到尾部继续计算
            ans = n - k; 
        }
        else // 正常前移
        {
            ans = q + k;
        }
    }
    else // 偶数位置处理分支
    {
        /* 当位移量超过当前位置值时 */
        if (k >= q) 
        {
            // 消耗全部当前值
            k -= q;
            // 转换移动方向
            ans = k + 1; 
        }
        else // 正常后移
        {
            ans = q - k;
        }
    }
    cout << ans << endl;
}
/* 反向位移逻辑（k > n）*/
else if (k > n)
{
    k -= n; // 转换为反向位移量
    if (q & 1) // 奇数位置处理分支
    {
        /* 剩余空间不足时 */
        if (k > n - q) 
        {
            // 消耗剩余空间
            k -= n - q;
            // 回绕到头部处理
            ans = k; 
        }
        else // 正常反向移动
        {
            ans = (n - q) - k + 1;
        }
    }
    else // 偶数位置处理分支
    {
        /* 转换剩余空间计算方式 */
        int effective = n - (n - q + 1); 
        if (k > effective)
        {
            // 消耗有效空间
            k -= effective;
            // 反向回绕计算
            ans = n - k + 1; 
        }
        else
        {
            // 正常逆向偏移
            ans = (n - q + 1) + k; 
        }
    }
    cout << ans << endl;
}

return;

}

signed main() { int _T = 1; // 测试用例数 cin >> _T; while (_T--) { solve(); // 处理每个用例 } return 0; } 注释