Comprensión del operador binario XOR en C#

Introducción a XOR

Tim comienza el vídeo mencionando que forma parte de su serie Understanding Binary in C#, concretamente de la lección número nueve. Prepara el escenario explicando que en esta sesión enseñará cómo funciona el operador OR exclusivo (XOR) y cómo puede ser útil en varios escenarios.

Sintaxis y explicación básica del operador XOR

Tim introduce dos valores, 1 y 2, y los imprime en la consola como referencia. Elimina la representación de 32 bits para mantener el enfoque en la representación binaria estándar de 8 bits.

En el minuto 0:31, explica que XOR se representa con el símbolo de la intercalación (^) en C#. Recuerda a los espectadores que:

• El operador AND (&) requiere que ambos bits sean 1 para devolver 1.
• El operador OR (|) devuelve 1 si al menos uno de los bits es 1.
• El operador XOR (^) devuelve 1 sólo si uno de los dos bits es 1, pero no ambos.

Tim explica con más detalle la regla para cada comparación de bits:

• 1 XOR 0 = 1
• 0 XOR 1 = 1
• 1 XOR 1 = 0
• 0 XOR 0 = 0

Esto significa que XOR actúa como un detector de diferencias entre dos valores.

Demostración de XOR en código C

Tim pasa a un ejemplo práctico al definir una variable uint que contiene el resultado de aplicar XOR a dos valores:

// Define two sample values
uint val1 = 0b0001;  // 1 in decimal
uint val2 = 0b0010;  // 2 in decimal

// Perform XOR operation between val1 and val2
uint result = val1 ^ val2;

// Print the resultant binary value of XOR operation
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

// Define two sample values
uint val1 = 0b0001;  // 1 in decimal
uint val2 = 0b0010;  // 2 in decimal

// Perform XOR operation between val1 and val2
uint result = val1 ^ val2;

// Print the resultant binary value of XOR operation
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

A continuación, imprime el resultado en la consola y anota el resultado:

0000 0011

Este resultado pone de relieve que XOR sólo conserva los bits en los que uno de los valores originales tenía un 1, pero no ambos.

Uso de XOR para la comparación de valores

Tim demuestra ahora un uso práctico de XOR: comprobar si dos valores son idénticos.

A las 3:00, él modifica los valores para que val1 y val2 sean exactamente iguales:

// Initialize val1 and val2 to the same value
uint val1 = 0b10011001;
uint val2 = 0b10011001;

// Perform XOR operation to check for identical values
uint result = val1 ^ val2;

// Output will be zero if both values are identical
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

// Initialize val1 and val2 to the same value
uint val1 = 0b10011001;
uint val2 = 0b10011001;

// Perform XOR operation to check for identical values
uint result = val1 ^ val2;

// Output will be zero if both values are identical
Console.WriteLine(Convert.ToString(result, toBase: 2).PadLeft(8, '0'));

Cuando ejecuta la operación XOR, el resultado es:

0000 0000

Tim explica que un resultado XOR de 0 significa que los valores eran idénticos. Esto convierte a XOR en una forma rápida de comparar dos números para comprobar su igualdad.

XOR para identificar diferencias

A las 4:00, Tim muestra otro caso donde val1 y val2 tienen ligeras diferencias. Esta vez, XOR produce un resultado distinto de cero, lo que indica una diferencia entre los valores.

Este enfoque es útil cuando se comparan grandes valores binarios de manera eficiente, ya que XOR puede resaltar las diferencias en un solo paso.

XOR para intercambiar dos variables sin una variable temporal

Tim presenta un truco de programación clásico: intercambiar dos números sin utilizar una variable temporal.

A las 5:40, desafía a los espectadores a intercambiar val1 y val2 sin declarar una variable adicional. La solución utiliza XOR tres veces:

// Original values
uint val1 = 0b0010; // 2 in decimal
uint val2 = 0b0100; // 4 in decimal

// Swap the values using XOR
val1 = val1 ^ val2;
val2 = val1 ^ val2;
val1 = val1 ^ val2;

// After swap: val1 = 4, val2 = 2
Console.WriteLine($"val1: {val1}, val2: {val2}");

// Original values
uint val1 = 0b0010; // 2 in decimal
uint val2 = 0b0100; // 4 in decimal

// Swap the values using XOR
val1 = val1 ^ val2;
val2 = val1 ^ val2;
val1 = val1 ^ val2;

// After swap: val1 = 4, val2 = 2
Console.WriteLine($"val1: {val1}, val2: {val2}");

Recorre el proceso:

1. val1 almacena val1 ^ val2, lo que significa que ahora contiene una mezcla de ambos valores.
2. val2 se actualiza aplicando XOR nuevamente con val1, dejando solo el valor original de val1.
3. Se aplica XOR nuevamente a val1, dejando solo el valor original de val2.

A las 7:30, Tim imprime los valores intercambiados y confirma que val1 y val2 han intercambiado valores exitosamente.

Comprensión de XOR en representación binaria

Para consolidar la comprensión, Tim ejecuta una versión binaria de la operación de intercambio, mostrando cómo cada paso de XOR afecta a los bits. Destaca que cada bit se invierte solo cuando es necesario, lo que convierte a XOR en una forma eficaz de intercambiar valores.

Conclusión

Tim concluye reforzando los puntos principales:

• XOR devuelve 1 sólo cuando exactamente uno de los bits es 1.
• Puede utilizarse para comparar valores de forma eficiente.
• Ayuda a intercambiar dos valores sin una tercera variable, lo que lo convierte en un truco práctico en los retos de codificación.

Anima a los espectadores a experimentar con XOR y aplicarlo a problemas del mundo real para construir una comprensión más profunda.

Reflexiones finales

El vídeo de Tim Corey ofrece un desglose excelente y conciso de XOR en C#. A través de ejemplos paso a paso, demuestra la utilidad del operador en comparaciones, diferencias e incluso intercambio de valores.

Si te interesan las operaciones binarias o los trucos bitwise, este es un vídeo imprescindible para reforzar tu comprensión de la manipulación binaria en C#.