Algoritmo y Programacin (E-Learning)

Unidad 1: Pas 2 - Conocer y desarrollar operaciones bsicas en los algoritmos.

Onidis Mesino Puello

Cdigo: 18010142

Grupo: 2150510_5

Presentado a

Luz Azucena Flrez

Escuela de Ciencias Bsicas, Tecnologa e

Ingeniera

Universidad Nacional Abierta Y A Distancia UNAD

Cead Cartagena Bolvar

San Andres Isla

2017
 Estudiante 5.

1. Indicar cuales son los operadores de relacin y operadores

lgicos.

Los operadores relacionales

Los operadores relacionales son smbolos que se usan para comparar dos valores. Si el
resultado de la comparacin es correcto la expresin considerada es verdadera, en caso
contrario es falsa. Por ejemplo, 8>4 (ocho mayor que cuatro) es verdadera, se representa
por el valor true del tipo bsico boolean, en cambio, 8<4 (ocho menor que cuatro) es falsa,
false. En la primera columna de la tabla, se dan los smbolos de los operadores relacionales,
en la segunda, el nombre de dichos operadores, y a continuacin su significado mediante un
ejemplo.

Operador nombre ejemplo significado

< menor que a<b a es menor que b
> mayor que a>b a es mayor que b
== igual a a==b a es igual a b
!= no igual a a!=b a no es igual a b
<= menor que o igual a a<=5 a es menor que o igual a b
>= mayor que o igual a a>=b a es menor que o igual a b

Se debe tener especial cuidado en no confundir el operador asignacin con el operador

relacional igual a. Las asignaciones se realizan con el smbolo =, las comparaciones con
==.

En el programa RelacionApp, se compara la variable i que guarda un 8, con un conjunto de

valores, el resultado de la comparacin es verdadero (true), o falso (false).
public class RelacionApp {
public static void main(String[] args) {
int x=8;
int y=5;
boolean compara=(x<y);
System.out.println("x<y es "+compara);
compara=(x>y);
System.out.println("x>y es "+compara);
compara=(x==y);
System.out.println("x==y es "+compara);
compara=(x!=y);
System.out.println("x!=y es "+compara);
compara=(x<=y);
System.out.println("x<=y es "+compara);
compara=(x>=y);
System.out.println("x>=y es "+compara);
}
}

Todos los operadores relacionales admiten como operandos los que pertenezcan a tipos
atmicos, incluyendo las enumeraciones. El resultado de los operadores relacionales es
siempre lgico, esto es, un valor verdadero (no nulo) o falso (nulo). La comparacin de
caracteres sigue la secuencia definida por el cdigo ASCII. Tngase en cuenta que el
cdigo ASCII no ordena correctamente las palabras en Espaol, Francs, Alemn o
cualquier otro idioma que posea signos diacrticos. La comparacin de cadenas no puede
realizarse en empleando los operadores relacionales habituales. Las cadenas son un caso
particular de listas, y al comparar el nombre de dos cadenas mediante los operadores == o
!= se comparan las direcciones en que comienzan ambas. Como quiera que dos cadenas
iguales van a tener generalmente distinta direccin, el resultado no va a ser correcto. Para
comparar dos cadenas debe emplearse una funcin como strcmp() o strncmp(), definidas
ambas en string.h.

Ejemplo
#include <stdio.h>
#include <string.h>

int main(void)
{
char nombre_uno[] = "Alicante";
char nombre_dos[] = "colombia";
char nombre_tres[] = "sanandres";

printf("\n\nFunciones de comparacin de cadenas\n\n");

printf("nombre_uno = %s\n", nombre_uno);

printf("nombre_dos = %s\n", nombre_dos);
printf("nombre_tres = %s\n", nombre_tres);
printf("\n\n");
 printf("nombre_uno == nombre_dos = %d\n", nombre_uno == nombre_dos);
printf("Esto tiene sentido porque %p != %p\n", nombre_uno, nombre_dos);
printf("\n\n");
printf("nombre_uno == nombre_tres = %d\n", nombre_uno == nombre_tres);
printf("Esto tiene sentido porque %p != %p\n", nombre_uno,
nombre_tres);
printf("\n\n");
printf("nombre_dos == nombre_tres = %d\n", nombre_dos == nombre_tres);
printf("Esto tiene sentido porque %p != %p\n", nombre_dos,
nombre_tres);
printf("\n\n");
printf("strcmp(nombre_uno, nombre_dos) = %d\n", strcmp(nombre_uno,
nombre_dos));
printf("strcmp(nombre_uno, nombre_tres) = %d\n", strcmp(nombre_uno,
nombre_tres));
printf("strcmp(nombre_dos, nombre_tres) = %d\n", strcmp(nombre_dos,
nombre_tres));
return 0;
}

Y el resultado de ejecutar este programa es como sigue:

[cauldron:03xx_PROGS]> ./a.out

Funciones de comparacin de cadenas

nombre_uno = Alicante
nombre_dos = colombia
nombre_tres = sanandres

nombre_uno == nombre_dos = 0
Esto tiene sentido porque 0xbffffc00 != 0xbffffc10

nombre_uno == nombre_tres = 0
Esto tiene sentido porque 0xbffffc00 != 0xbffffc20

nombre_dos == nombre_tres = 0
Esto tiene sentido porque 0xbffffc10 != 0xbffffc20

strcmp(nombre_uno, nombre_dos) = -1
strcmp(nombre_uno, nombre_tres) = -1
strcmp(nombre_dos, nombre_tres) = 0
[cauldron:03xx_PROGS]>

Los resultados de aplicar el operador de comparacin "==" a una pareja de cadenas son los
que se obtienen al comparar numricamente las direcciones de comienzo de los operandos
(las dos cadenas). Como nombre_uno, nombre_dos y nombre_tres son variables distintas,
tienen direcciones de comienzo distintas; aunque su contenido sea el mismo, como es el
caso de nombre_dos y nombre_tres, su direccin es diferente, y la comparacin mediante
"==" produce un resultado falso, porque las direcciones no son iguales.
Cuando se hace uso de la funcin strcmp(), se obtiene un resultado ms acorde con lo
esperable. En efecto, esta funcin (vanse los resultados de escribir "man strcmp" en una
shell) produce un resultado negativo, nulo o positivo segn la primera cadena sea menor,
igual o mayor que la segunda, desde un punto de vista lexicogrfico. En nuestro caso,
"Alicante" es menor que "Barcelona", luego el resultado de esa comparacin es -1. Cuando
se comparan nombre_dos y nombre_tres, el resultado es 0, porque son iguales.

Los operadores lgicos

Los operadores lgicos son:

&& AND (el resultado es verdadero si ambas expresiones son verdaderas)

|| OR (el resultado es verdadero si alguna expresin es verdadera)
! NOT (el resultado invierte la condicin de la expresin)
XOR (Verdadero si cualquiera de las expresiones (pero no ambas) es verdadera)

AND y OR trabajan con dos operandos y retornan un valor lgico basadas en las
denominadas tablas de verdad. El operador NOT acta sobre un operando. Estas tablas de
verdad son conocidas y usadas en el contexto de la vida diaria, por ejemplo: "si hace sol Y
tengo tiempo, ir a la playa", "si NO hace sol, me quedar en casa", "si llueve O hace
viento, ir al cine". Las tablas de verdad de los operadores AND, OR y NOT se muestran
en las tablas siguientes

La tabla resumen completa de los operadores lgicos es la mostrada a continuacin:

El operador lgico AND

x y resultado
true true true
true false false
false true false
false false false

El operador lgico OR

x y resultado
true true true
true false true
false true true
false false false

El operador lgico NOT

x resultado
true false
false true

Los operadores AND y OR combinan expresiones relacionales cuyo resultado viene dado
por la ltima columna de sus tablas de verdad. Por ejemplo:

(a<b) && (b<c)

es verdadero (true), si ambas son verdaderas. Si alguna o ambas son falsas el resultado es
falso (false). En cambio, la expresin

(a<b) ||(b<c)

es verdadera si una de las dos comparaciones lo es. Si ambas, son falsas, el resultado es
falso.

La expresin " NO a es menor que b"

!(a<b)
es falsa si (a<b) es verdadero, y es verdadera si la comparacin es falsa. Por tanto, el
operador NOT actuando sobre (a<b) es equivalente a

(a>=b)

La expresin "NO a es igual a b"

!(a==b)

es verdadera si a es distinto de b, y es falsa si a es igual a b. Esta expresin es equivalente a

(a!=b)

La operacin XOR consiste en un negador en el cual la variable principal de dicha funcin

se niega cuando la variable secundaria esta en TRUE, caso contrario, el valor de la variable
principal de la funcin es el mismo. En resumen, esta operacin lgica consiste en un
negador de 2 variables, en las cuales, una variable es la que se desea negar y la otra variable
es la de control para la negacin. Esta funcin consiste en sumar los productos entre
variables, cuyo producto se caracteriza por tener variables de forma negada y no negada,
alternndose unos con otros, para que sea ms claro,

Supongamos que tenemos una funcin lgica f, que consiste en la suma lgica (XOR) de 2
variables A y B tal que: f(A, B) = A B + A B = A B Suponiendo que los valores 1 =
TRUE y 0 = FALSE, entonces podemos armar lo que se denomina, tabla de verdad para
una funcin lgica XOR. Dicha tabla se expresa de la siguiente manera:

Suponiendo que los valores 1 = TRUE y 0 = FALSE, entonces podemos armar lo que se
denomina, tabla de verdad para una funcion logica XOR. Dicha tabla se expresa de la
siguiente manera:

Pueden apreciar que cuando la variable B esta en 1, el resultado de la operacin es la

negacin de la variable A, caso contrario, el resultado de la operacin es el valor de la
variable A
El valor m, que es interpretado como un puntero al primer elemento de la matriz, es
transformado a un bool. Como es distinto de cero (no es un puntero nulo) el resultado es
cierto. A continuacin, el valor x es convertido tambin a bool. En este caso la conversin
produce falso, con lo que este es el resultado del parntesis de la sentencia if.
Ejemplo
#include <iostream.h>

bool alto = true, bajo = false, blanco = true, negro = false;

int main (void) {

if (alto && bajo) { cout << "Uno cierto" << endl; }
else cout << "Uno falso" << endl;
if (alto && blanco) { cout << "Dos cierto" << endl; }
else cout << "Dos falso" << endl;
if (bajo && negro) { cout << "Tres cierto" << endl; }
else cout << "Tres falso" << endl;
}
Salida:
Uno falso
Dos cierto
Tres falso
3 || Operador O lgico
Este operador binario devuelve true si alguno de los operandos es cierto. En caso contrario
devuelve false.
Sintaxis
expr-OR-logica || expresion-AND-logica
Comentario
Este operador sigue un funcionamiento anlogo al anterior. El primer operando (izquierdo)
es convertido a bool. Para ello, si es una expresin, se evala para obtener el resultado (esta
computacin puede tener ciertos efectos laterales). A continuacin el valor obtenido es
convertido a bool cierto/falso siguiendo las reglas de conversin estndar ( 3.2.1b). Si el
resultado es true, el proceso se detiene y este es el resultado, sin que en este caso sea
necesario evaluar la expresin de la derecha (recurdese que en el diseo de C++ prima la
velocidad).
Si el resultado del operando izquierdo es false, se contina con la evaluacin de la
expresin de la derecha, que tambin es convertida a bool. Si el nuevo resultado es true,
entonces el resultado del operador es true. En caso contrario el resultado es false.
Nota: el Estndar establece que antes de ser evaluada la expresin derecha, han sucedido
todos los posibles efectos laterales de la expresin izquierda, a excepcin de la destruccin
de los posibles objetos temporales que se hubieran creado.
Ejemplo
#include <iostream.h>
bool alto = true, bajo = false, blanco = true, negro = false;

int main (void) {

if (alto || bajo) { cout << "Uno cierto" << endl; }
else cout << "Uno falso" << endl;
 if (alto || blanco) { cout << "Dos cierto" << endl; }
else cout << "Dos falso" << endl;
if (bajo || negro) { cout << "Tres cierto" << endl; }
else cout << "Tres falso" << endl;
}
Salida
Uno cierto
Dos cierto
Tres falso
4 ! Operador NO lgico:
Este operador es denominado tambin negacin lgica y se representa en el texto escrito
por la palabra inglesa NOT (otros lenguajes utilizan directamente esta palabra para
representar el operador en el cdigo).
Sintaxis
! expresion-cast
Comentario
El operando expresion-cast (que puede ser una expresin que se evala a un
resultado 1.2.1) es convertido a tipo bool, con lo que solo puede ser uno de los
valores cierto/falso. A continuacin el operador cambia su valor: Si es cierto es convertido
a falso y viceversa.
Resulta por tanto, que el resultado de este operador es siempre un tipo bool, aunque al
existir una conversin estndar por la que un cero es convertido a false, y cualquier valor
distinto de cero a true ( 3.2.1b), coloquialmente se dice que este operador convierte un
operando 0 en 1 y uno no-cero en 0. En otras palabras: este operador devuelve cierto (true)
si la expresin se evala a distinto de cero, en caso contrario devuelve falso (false).
Ejemplo
#include <iostream.h>
bool alto = true, bajo = false;

int main (void) {

if (alto) { cout << "Uno cierto" << endl; }
else cout << "Uno falso" << endl;
if (!alto) { cout << "Dos cierto" << endl; }
else cout << "Dos falso" << endl;
if (!bajo) { cout << "Tres cierto" << endl; }
else cout << "Tres falso" << endl;
}
Salida:
Uno cierto
Dos falso
Tres cierto

Si E es una expresin, !E es equivalente a (0 == E). Como consecuencia, las expresiones

que siguen son equivalentes dos a dos:
if (! valid);
if (valid == 0);
...
if (valid);
if (valid != 0);

7 Representacin explcita
Los operadores lgicos entre valores lgicos &&, ||, !; la relacin de desigualdad !=;
algunos de los operadores lgicos entre bits (&, |, ^, ~) y sus expresiones compuestas
(&=, |=, ^=), tienen una representacin realmente difcil de leer, con la desventaja adicional
que sus smbolos no siempre estn fcilmente accesibles en ordenadores con teclados
distintos del estndar USA. Para resolver este problema, el Estndar C++ ha introducido
nuevas formas para su representacin; las denominamos formas explcitas o naturales, en
razn de que se parecen ms a las palabras correspondientes del lenguaje natural. Las
nuevas formas constituyen palabras-clave, y la tabla de equivalencias es la siguiente:
Biografa

Valores lgicos
Copyright 2006-2017 aprenderaprogramar.com

Programacin java
Curso de Lenguaje Java: Enero de 2000
Procedimientos Numricos en Lenguaje Java: Diciembre de 2001
http://www.sc.ehu.es/sbweb/fisica/curso.htm

programacin c++
Copyright 1990-2016 Zator Systems.
http://www.zator.com/index.htm