Вам надається великий діапазон [a, b], де 'a' і 'b' можуть бути зазвичай від 1 до 4 000 000 000 включно. Ви повинні дізнатися ХОР усіх чисел у заданому діапазоні.

Ця проблема була використана в TopCoder SRM. Я побачив одне з рішень, поданих у матчі, і не можу зрозуміти, як працює.

Може хтось допоможе пояснити виграшне рішення:

long long f(long long a) {
     long long res[] = {a,1,a+1,0};
     return res[a%4];
}

long long getXor(long long a, long long b) {
     return f(b)^f(a-1);
}

Тут getXor()реальна функція обчислення xor усіх чисел у пройденому діапазоні [a, b], а "f ()" є допоміжною функцією.

Це досить розумне рішення - воно використовує той факт, що в запущених XOR існує закономірність результатів. f()Функція обчислює виключає загальний пробіг з [0, а]. Погляньте на цю таблицю для 4-розрядних чисел:

0000 <- 0  [a]
0001 <- 1  [1]
0010 <- 3  [a+1]
0011 <- 0  [0]
0100 <- 4  [a]
0101 <- 1  [1]
0110 <- 7  [a+1]
0111 <- 0  [0]
1000 <- 8  [a]
1001 <- 1  [1]
1010 <- 11 [a+1]
1011 <- 0  [0]
1100 <- 12 [a]
1101 <- 1  [1]
1110 <- 15 [a+1]
1111 <- 0  [0]

Де перший стовпець - це двійкове подання, а потім десятковий результат та його відношення до його індексу (а) у списку XOR. Це трапляється тому, що всі верхні біти скасовуються, а найнижчі два біти проходять цикл кожні 4. Отже, ось як прийти до цієї маленької таблиці пошуку.

Тепер розглянемо загальний діапазон [a, b]. Ми можемо використовувати f()для пошуку XOR для [0, a-1] і [0, b]. Оскільки будь-яке значення XOR'd з самим собою дорівнює нулю, f(a-1)справедливе скасовує, що всі значення в XOR виконуються менше ніж a, залишаючи вас з XOR діапазону [a, b].

Додавши до великої відповіді FatalError, рядок return f(b)^f(a-1);можна було б пояснити краще. Якщо коротко, це тому, що XOR має такі чудові властивості:

• Це асоціативно - розміщуйте дужки куди завгодно
• Це комутативно - це означає, що ви можете переміщати операторів (вони можуть "комутувати")

Ось обидва в дії:

(a ^ b ^ c) ^ (d ^ e ^ f) = (f ^ e) ^ (d ^ a ^ b) ^ c

• Він перевертає себе

Подобається це:

a ^ b = c
c ^ a = b

Додавання та множення - це два приклади інших асоціативних / комутативних операторів, але вони не змінюють себе. Ну так, чому ці властивості важливі? Ну, простий маршрут - це розширити його на те, що він є насправді, і тоді ви зможете побачити ці властивості на роботі.

Спочатку давайте визначимо, що ми хочемо, і назвемо це n:

n      = (a ^ a+1 ^ a+2 .. ^ b)

Якщо це допомагає, подумайте про XOR (^) так, ніби це додаток.

Давайте також визначимо функцію:

f(b)   = 0 ^ 1 ^ 2 ^ 3 ^ 4 .. ^ b

bбільший за a, тому просто безпечно потрапляючи в кілька додаткових дужок (що ми можемо, оскільки це асоціативно), ми також можемо сказати це:

f(b)   = ( 0 ^ 1 ^ 2 ^ 3 ^ 4 .. ^ (a-1) ) ^ (a ^ a+1 ^ a+2 .. ^ b)

Що спрощує:

f(b)   = f(a-1) ^ (a ^ a+1 ^ a+2 .. ^ b)

f(b)   = f(a-1) ^ n

Далі ми використовуємо цю властивість зворотного зв'язку та комунікативність, щоб дати нам магічну лінію:

n      = f(b) ^ f(a-1)

Якби ви думали про XOR як про додавання, ви б там упустили віднімання. XOR - XOR, що додавати - відняти!

Як я сам придумав це?

Запам’ятайте властивості логічних операторів. Працюйте з ними майже як додавання чи множення, якщо це допомагає. Незвично, що і (&), xor (^) і або (|) асоціативні, але вони є!

Запустіть наївну реалізацію спочатку, знайдіть шаблони у висновку, а потім починайте знаходити правила, які підтверджують, що шаблон є правдивим. Ще більше спростіть свою реалізацію та повторіть. Це, мабуть, маршрут, який пройшов оригінальний творець, підкреслений тим, що це не зовсім оптимально (тобто використовувати оператор перемикання, а не масив).

Я з’ясував, що наведений нижче код також працює як рішення, подане в питанні.

Можливо, це мало оптимізовано, але це саме те, що я отримав від спостереження за повторенням, як це було зазначено у прийнятій відповіді,

Мені хотілося б знати / зрозуміти математичне підтвердження даного коду, як пояснено у відповіді @Luke Briggs

Ось той код JAVA

public int findXORofRange(int m, int n) {
    int[] patternTracker;

    if(m % 2 == 0)
        patternTracker = new int[] {n, 1, n^1, 0};
    else
        patternTracker = new int[] {m, m^n, m-1, (m-1)^n};

    return patternTracker[(n-m) % 4];
}

Я вирішив проблему з рекурсією. Я просто розділяю набір даних на майже рівну частину для кожної ітерації.

public int recursion(int M, int N) {
    if (N - M == 1) {
        return M ^ N;
    } else {
        int pivot = this.calculatePivot(M, N);
        if (pivot + 1 == N) {
            return this.recursion(M, pivot) ^ N;
        } else {
            return this.recursion(M, pivot) ^ this.recursion(pivot + 1, N);
        }
    }
}
public int calculatePivot(int M, int N) {
    return (M + N) / 2;
}

Дайте мені знати ваші думки щодо рішення. Раді отримати відгуки про покращення. Пропоноване рішення розраховує XOR за 0 (log N) складності.

Дякую

Щоб підтримувати XOR від 0 до N, вказаний код потрібно змінити, як показано нижче,

int f(int a) {
    int []res = {a, 1, a+1, 0};
    return res[a % 4];
}

int getXor(int a, int b) {
    return f(b) ^ f(a);
}