Ниже даю рабочую и универсальную конструкцию, которая удовлетворяет условиям задачи для любых входных данных.

---

✅ Идея решения

Требуется:

• XOR на отрезке $[l, r]$ равен 0.
• XOR на любом другом отрезке ≠ 0.

Самый простой способ обеспечить уникальность —
сделать весь массив нулевым, кроме двух точек l и r, где стоят одинаковые значения.

Тогда:

• $a_l = a_r = X$
• Все остальные $a_i = 0$

Тогда XOR на $[l, r]$:

$$a_l \oplus 0 \oplus 0 \oplus \ldots \oplus 0 \oplus a_r = X \oplus X = 0.$$

Для любого другого отрезка:

• Если отрезок включает только один из $l, r$ → XOR = X ≠ 0.
• Если отрезок включает оба, но строго шире, чем [l,r]
  — тогда в нём появится 0 внутри, но также X и X по краям → XOR ≠ 0.
• Если отрезок полностью вне [l,r] → XOR = 0 XOR 0 ... = 0, но это запрещено.

Чтобы избежать нулевого XOR вне $[l,r]$, достаточно поставить в позицию 1 число, отличное от X, например $1$, если 1 не попадает внутрь [l,r].

Поэтому берём универсальную конструкцию:

---

✅ Готовая формула массива

Пусть $X = 10^9$.

Для каждого теста:

text
Если 1 < l:
    a1 = 1
Иначе:
    a_n = 1   (если l = 1, то ставим «единицу» в конец)

a_l = X
a_r = X
все остальные ai = 0

Это гарантирует:

• XOR на $[l,r]$ = 0
• Во всех других отрезках XOR ≠ 0, т.к. обязательно появится либо 1, либо единственный X.

---

✅ Пример вывода

Ниже — функция, которая формирует массив для одного теста:

python
def build(n, l, r):
    X = 10**9
    a = [0] * n

    if l > 1:
        a[0] = 1
    else:
        a[-1] = 1

    a[l-1] = X
    a[r-1] = X
    return a

---

🔥 Пример

Вход:

text
1
5 2 4

Вывод (пример из многих допустимых):

1 1000000000 0 1000000000 0

Проверка:

• XOR(2..4) = X ⊕ 0 ⊕ X = 0
• Любой другой отрезок содержит ровно один X или 1 → XOR ≠ 0

---

❓ Хотите, я напишу полный код на C++ / Python, готовый для отправки?

Сделать все $a_i$ ≥ 1 и одновременно добиться ровно одного нулевого XOR — можно, если мыслить через префиксные XOR’ы.

---

1. Переформулировка через префиксы

Обозначим префиксы:

$$p_0 = 0,\quad p_i = a_1 \oplus a_2 \oplus \dots \oplus a_i.$$

Тогда XOR на отрезке $[x, y]$:

$$f(x,y) = a_x \oplus \dots \oplus a_y = p_{x-1} \oplus p_y.$$

Отсюда:

• $f(x,y)=0 \iff p_{x-1} = p_y$.

Условие задачи:

• $f(l,r) = 0 \iff p_{l-1} = p_r$.
• Для любого другого $(x,y)$ (с $x \le y$) XOR ≠ 0,
  то есть все пары $(i,j)$ с $0 \le i < j \le n$, кроме $(l-1,r)$, должны иметь $p_i \ne p_j$.

Итого: среди $p_0, p_1, \dots, p_n$ все значения разные, кроме того, что $p_{l-1} = p_r$.

---

2. Конструкция префиксов

Возьмём очень простой вариант:

• Для всех $i$ от 0 до $n$:
  $p_i = i$,
• кроме одного места: $$p_r = l-1.$$

Тогда:

• Значение $l-1$ встречается ровно в двух позициях: $p_{l-1}$ и $p_r$.
• Все остальные $p_i$ равны своим индексам и все различны.

Значит:

• единственная пара $(i,j)$ с $i<j$ и $p_i = p_j$ — это $(l-1, r)$,
• ⇒ единственный отрезок с XOR = 0 — это $[l, r]$.

---

3. Восстановление массива $a$

Теперь по префиксам строим сами элементы:

$$a_i = p_{i-1} \oplus p_i.$$

Проверим ограничения:

• $a_i \ne 0$, т.к. $p_{i-1} \ne p_i$ для любых соседних индексов:
  • мы сделали только одну «дублирующуюся» пару префиксов: $(l-1, r)$, они не соседние, так как $r > l-1+1 \iff r>l$ (а $r>l$ по условию).
• Значит $a_i \ge 1$.
• Все $p_i \le n \le 4\cdot 10^5$, поэтому их XOR тоже ≤ $2^{19}-1 < 10^9$,
  значит $a_i \le 10^9$.

Условия $1 \le a_i \le 10^9$ выполнены.

---

4. Проверка свойств

• Для отрезка $[l,r]$:

$$f(l,r) = p_{l-1} \oplus p_r = (l-1) \oplus (l-1) = 0.$$

• Для любого другого отрезка $[x,y]$:

$$f(x,y) = p_{x-1} \oplus p_y = 0 \iff p_{x-1} = p_y,$$

а это возможно только при $(x-1,y) = (l-1,r)$, то есть $[x,y] = [l,r]$.
Следовательно, для остальных отрезков XOR ≠ 0.

---

5. Готовый код

C++ (рекомендовано для посылки)

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

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;
    while (T--) {
        int n, l, r;
        cin >> n >> l >> r;

        vector<int> p(n + 1);
        // Базовые префиксы: p[i] = i
        for (int i = 0; i <= n; ++i) {
            p[i] = i;
        }
        // Единственное совпадение префиксов: p[l-1] и p[r]
        p[r] = l - 1;

        // Восстанавливаем массив a
        vector<int> a(n + 1);
        for (int i = 1; i <= n; ++i) {
            a[i] = p[i - 1] ^ p[i];  // XOR двух разных префиксов
        }

        for (int i = 1; i <= n; ++i) {
            cout << a[i] << (i == n ? '\n' : ' ');
        }
    }

    return 0;
}

Python (если нужно)

python
import sys

input = sys.stdin.readline

t = int(input())
out_lines = []
for _ in range(t):
    n, l, r = map(int, input().split())

    p = list(range(n + 1))
    p[r] = l - 1

    a = [0] * (n + 1)
    for i in range(1, n + 1):
        a[i] = p[i - 1] ^ p[i]

    out_lines.append(" ".join(str(a[i]) for i in range(1, n + 1)))

print("\n".join(out_lines))

Если хочешь, могу добавить коду проверку (bruteforce) на маленьких $n$, чтобы убедиться в корректности конструкции.