Operadores lógicos

Para comentar también rápido funciona el comando:
ctrl + k + c

Si se les complica entender los operadores AND y OR, piensen en está analogía jaja 😜

Cada valor es un vasito de agua🥛, los cuales pueden contener agua sucia (false) o agua purificada (true).

AND los obliga a probar todos los vasos de agua, mientras que con OR pueden beber solo el que esté limpio.

El resultado de cualquier sentencia con AND y OR, será TRUE si se pueden librar de beber agua sucia o FALSE si se van con diarrea… 😜

Siganme para más lecciones de lógica.

Operadores Logicos

Los operadores lógicos en C# son utilizados para comparar y combinar valores booleanos. Los operadores lógicos disponibles en C# incluyen:

• && (and): Devuelve verdadero si ambos operandos son verdaderos.
• || (or): Devuelve verdadero si al menos uno de los operandos es verdadero.
• ! (not): Invierte el valor booleano del operando.
• ^ (xor): Devuelve verdadero si sólo uno de los operandos es verdadero.

Ejemplo:

bool a = true;
bool b = false;
bool c = (a && b); // c es false
bool d = (a || b); // d es true
bool e = !b; // e es true
bool f = (a ^ b); // f es true

En** OR || **cualquier valor que sea verdadero , dará como resultado VERDADERO.

**Ejemplo: **
Verdadero OR Verdadero = Verdadero
Verdadero OR Falso = Verdadero
Falso OR Verdadero = Verdadero
Falso OR Falso = Falso

En AND && si existe un valor que sea diferente al resto será, FALSO

Ejemplo:
Verdadero AND Verdadero = Verdadero
Verdadero AND Falso = Falso
Falso AND Verdadero = Falso
Falso AND Falso = Verdadero

En NOT ! es una negación al resultado existente.

Ejemplo:
Si valor1 es Verdadero
!Valor1 será Falso

En Xor compara valores e indica si son diferentes(Verdadero) o iguales(Falso)

Ejemplo:
Verdadero ^ Verdadero = Falso
Falso ^ Verdadero = Verdadero

var (valor1, valor2, valor3) = (true, true, false);

bool resultAnd = valor1 && valor2 && valor3;
Console.WriteLine("resultAnd " + resultAnd);

bool resultOr = valor1 || valor2 || valor3;
Console.WriteLine("resultOr " + resultOr);

bool resultAndOr = (valor1 && valor2) || valor3;
Console.WriteLine("resultAndOr " + resultAndOr);

bool resultNot = !valor1;
Console.WriteLine("resultNot " + resultNot);

bool resultXor = (valor1 ^ valor2) ^ valor3;
Console.WriteLine("resultXor " + resultXor);

Si no sabes como poner el XOR o “^” en tu teclado, prueba con alt + 94.

|| = (Alt+124)2

Recomendación: estudiar las tablas de verdad. 👍

Una imagen dice más que mil palabras

Esa forma de declarar las variable (min 11 en adelane) se llama Deconstruct

var (valor1, valor2, valor3) = (true, true, false)

Tengo poco tiempo estudiándolo, pero es una forma abstracta de declarar pero a la vez fácil para asignar resultados, al menos así lo veo.

espero que les sirva mis apuntes

/* Operadores logicos y cuales son cada uno en c# 
 * operador && este es un and lo que funciona como necesita dos ciertos para ser cierto 
 * OPERADOR  || OR  este operador tiene la funcion de pasar un cierto y un falso como un cierto y si ambos son ciertos pasa como cierto 
 * Operador  ! NOT tiene la capacidad de pasar todo al contrario de lo que es 
 * ^ OPERADOR XOR 

*/

/* bool valor1 = true; 
bool valor2 = true;      aqui lo que hicimos es declarar las variables de forma clasica 
bool valor3 = false;
*/

var (valor1, valor2, valor3) = (true, true, false);//aqui dejamos que visual studio declare solo las variables 
Console.WriteLine(" los valors de son " + valor1 + " " + valor2 + " " + valor3);

bool resultAND = valor1 && valor2 && valor3;
Console.WriteLine("el resultado de AND es : "+resultAND);

bool resultOR = valor1 || valor2 || valor3;
Console.WriteLine("el resultado de OR  es : "+resultOR);



bool resultAndOr = (valor1 && valor2) || valor3; 
Console.WriteLine("el resultado de AND Y OR  es : "+resultAndOr);

bool resultNOT = !valor1;  // usamos el operador not y vemos como cambia el true al false 
Console.WriteLine("el resultado de NOT  es : "+resultNOT);

bool resultXOR = valor1 ^ valor2;  
Console.WriteLine("el resultado de XOR es : "+resultXOR); // este funciona como un or pero negativo no hay pierde creo... 

hay operadores no para realizar operaciones, si no para comparar expresiones
& AND: Determina su veracidad cuando todos sus enunciados son verdaderos, de lo contario todos son falsos

|| u OR: Solamente es falso, cuando todos los datos son falsos

! Negar el valor lógico

^ o xor: determinar la diferencia de valores*/

no dices el paso en donde cambias result por resultAnd, ¿ por que lo cambias?

OPERADORES ARITMETICOS

• Operadores logicos booleanos
  Tambien tenemos como parte del lenguaje los operadores logicos booleanos, que en realidad lo tiene casi todos los lenguajes de programacion.

 Operador   Logical operator    Example
    !           NOT             !false
    &&          AND             x && y
    ||          OR              x || y

Apuntes de los Operadores Lógicos 
<code> 
/*
&& AND
|| OR
!  NOT
^  XOR
 */

//bool valor1 = true;
//bool valor2 = true;
//bool valor3 = false;

var (valor1, valor2, valor3) = (true, true, false);

bool resultAnd = valor1 && valor2 && valor3;
Console.WriteLine(resultAnd);

bool resultOr = valor1 || valor2 || valor3;
Console.WriteLine(resultOr);

bool resultAndOr = (valor1 && valor2) || valor3;
Console.WriteLine(resultAndOr);

bool resultNot= !valor1;
Console.WriteLine(resultNot);

bool resultXor = valor1 ^ valor2 ^ valor3;
Console.WriteLine(resultXor);

Operadores lógicos

Los operadores lógicos en C# son utilizados para realizar operaciones de lógica booleana sobre expresiones que evalúan a valores booleanos (verdadero o falso). Aquí tienes los operadores lógicos en C#:

1. AND Lógico:

   &&
   
   

   Devuelve verdadero si ambas expresiones son verdaderas; de lo contrario, devuelve falso.

2. OR Lógico:

   ||
   
   

   Devuelve verdadero si al menos una de las expresiones es verdadera; devuelve falso si ambas son falsas.

3. NOT Lógico:

   !
   
   

   Devuelve verdadero si la expresión es falsa, y viceversa. Es un operador unario que invierte el valor de verdad de la expresión.

Estos operadores se utilizan comúnmente en estructuras de control de flujo (como if, while, for, etc.) para tomar decisiones basadas en condiciones lógicas.

Ejemplo:

bool condicion1 = true;
bool condicion2 = false;

// AND lógico
bool resultadoAnd = condicion1 && condicion2;  // resultadoAnd es falso

// OR lógico
bool resultadoOr = condicion1 || condicion2;   // resultadoOr es verdadero

// NOT lógico
bool resultadoNot = !condicion1;               // resultadoNot es falso

Estos operadores son fundamentales para construir lógica en programas y permiten tomar decisiones basadas en condiciones booleanas.

En C#, no hay un operador XOR lógico específico como un símbolo único como en algunos otros lenguajes. En su lugar, se puede simular utilizando el operador de diferencia exclusiva (^).

El operador XOR realiza una operación de diferencia exclusiva, lo que significa que devuelve true si exactamente uno de los operandos es true, y false si ambos o ninguno son true. Aquí tienes un ejemplo:

bool condicion1 = true;
bool condicion2 = false;

// XOR lógico utilizando el operador de diferencia exclusiva
bool resultadoXOR = condicion1 ^ condicion2;  // resultadoXOR es verdadero

El operador ^ se puede utilizar para implementar el comportamiento de XOR lógico en expresiones booleanas.

Vale aclarar que && no es el opuesto de ^, como se dice en la clase, ya que depende de los valores de verdad de las variables a comparar.

Console.WriteLine(" Hola estos son operadores logicos : " ) ;

/* operadores logicos :

&& And = y
|| or = o
! = negacion
== = igualdad
!= = desigualdad
^ = xor
*/

//variables
bool valor1 = true ;
bool valor2 = false ;
bool valor3 = true ;
int numero1=0;
int numero2=0;


// si valor 1 y valor 2 son iguales
bool resultado = valor1 && valor2 ;
Console.WriteLine( resultado ) ;

// si valor 1 o valor 2 o valor 3 son diferentes
bool resultado2 = valor1 || valor2 || valor3 ;
Console.WriteLine( resultado2 ) ;

// si valor 1 y valor 2 son iguales o el valor 3 es true
bool resultado3 = (valor1 && valor2) || valor3 ;
Console.WriteLine( resultado3 ) ;

// si valor numero 1 y numero 2 son iguales
bool resultado4 = (numero1 == numero2) ;
Console.WriteLine( resultado4 ) ;

// valor opuesto al valor 1
bool resultNot = !valor1;
Console.WriteLine( resultNot ) ;

// si el valor 1 y el valor 2 son diferentes
bool resultXor = valor1 ^ valor2 ;
Console.WriteLine( resultXor ) ;

// si el valor 1 y el valor 3 son diferentes
bool resultXorr = valor1 ^ valor3;
Console.WriteLine(resultXorr);

Para duplicar lineas, el comando Ctrl + D sirve también.

Para descomentar de forma rapido funciona con el comando ctrl + k + u