Tabla de Contenido
Introducción.......................................................................................................................................3
Objetivos.............................................................................................................................................4
Expresiones booleanas y las estructuras de selección..........................................................5
Estructuras de selección................................................................................................................6
Operadores de comparación racional.........................................................................................7
Lógica ADN........................................................................................................................................8
Estructuras de selección..............................................................................................................10
Lógica AND......................................................................................................................................11
Lógica OR.........................................................................................................................................11
Precedencia de Operadores.........................................................................................................13
Conclusiones...................................................................................................................................16
Bibliografía.......................................................................................................................................17
Universidad Tecnológica de Honduras
Introducción
La creación de ciclos en el análisis y diseño de algoritmo se refiere a las diversas
técnicas y principios utilizados para crear soluciones iterativas y repetitivas en la
resolución de problemas. Los ciclos permiten que las computadoras repitan la
misma secuencia de operaciones repetidamente hasta que se cumpla una condición
específica, lo cual es de gran utilidad para resolver problemas que requieren de
múltiples pasos y/o iteraciones para llegar a una solución. En el análisis y diseño de
algoritmo, los ciclos permiten mejorar la eficiencia y efectividad de los programas al
dividir “tasks” complejas en tareas más simples y manejables.
Los ciclos juegan un papel importante en el diseño de algoritmos, ya que ayudan a
organizar el flujo de datos y controlar repeticiones en la ejecución del programa.
pág. 3
Universidad Tecnológica de Honduras
Objetivos
Mejorar la legibilidad y mantenibilidad del código al permitir reducir
la repetición de instrucciones.
Reducir la probabilidad de errores de programación causados por
la necesidad de realizar múltiples copias de un mismo código.
Mejorar la eficacia y velocidad del programa al reducir la
necesidad de repetir instrucciones varias veces.
pág. 4
Universidad Tecnológica de Honduras
Expresiones booleanas y las estructuras de selección
Son conceptos fundamentales en la programación, relacionados con la toma de
decisiones. Son expresiones que pueden evaluarse como verdaderas o falsas. Las
expresiones booleanas suelen utilizarse para realizar comparaciones y decidir qué
camino tomar en un programa.
En lenguajes de programación, una expresión booleana puede involucrar
operadores como:
== (igual)
!= (diferente)
> (mayor que)
< (menor que)
>= (mayor o igual que)
<= (menor o igual que)
&& (y lógico)
|| (o lógico)
! (negación lógica)
Ejemplo en pseudocódigo:
a=5
b = 10
resultado = (a < b) # Esto es una expresión booleana que se evalúa como
"verdadero"
Las expresiones booleanas son las condiciones que se evalúan en las estructuras
de selección, lo que permite que el programa tome diferentes caminos dependiendo
del valor de verdad de esas condiciones
pág. 5
Universidad Tecnológica de Honduras
Estructuras de selección
Son bloques de código que permiten tomar decisiones basadas en el resultado de
una expresión booleana.
En otras palabras, permiten ejecutar una u otra acción dependiendo de si una
condición es verdadera o falsa.
Las estructuras de selección más comunes son:
if-else (si-sino): Ejecuta un bloque de código si la condición es verdadera, y otro
bloque si es falsa.
else-if (sino-si): Permite evaluar varias condiciones de manera secuencial.
switch (según): Evalúa una expresión y selecciona una entre varias opciones.
Ejemplo en pseudocódigo con if-else:
si (edad >= 18) entonces
imprimir("Eres mayor de edad")
sino
imprimir("Eres menor de edad")
fin si
Las expresiones booleanas son las condiciones que se evalúan en las estructuras
de selección, lo que permite que el programa tome diferentes caminos dependiendo
del valor de verdad de esas condiciones
pág. 6
Universidad Tecnológica de Honduras
Operadores de comparación racional
Los operadores de comparación racional se refieren a los operadores que se utilizan
para comparar dos valores o expresiones en términos de relaciones lógicas o
matemáticas.
Estos operadores permiten evaluar si una expresión es mayor, menor, igual o
diferente a otra.
Los más comunes son:
1. Igual a (==) - Verifica si dos valores son iguales.
Ejemplo: 5 == 5 es verdadero.
2. Diferente de (!=) - Verifica si dos valores no son iguales.
Ejemplo: 5 != 3 es verdadero.
3. Mayor que (>) - Verifica si el valor de la izquierda es mayor que el de la
derecha.
Ejemplo: 7 > 5 es verdadero.
4. Menor que (<) - Verifica si el valor de la izquierda es menor que el de la
derecha.
Ejemplo: 3 < 5 es verdadero.
5. Mayor o igual que (>=) - Verifica si el valor de la izquierda es mayor o igual
que el de la derecha.
Ejemplo: 5 >= 5 es verdadero.
6. Menor o igual que (<=) - Verifica si el valor de la izquierda es menor o igual
que el de la derecha.
Ejemplo: 4 <= 6 es verdadero.
Estos operadores se usan en muchos lenguajes de programación y en lógica
matemática para realizar comparaciones entre variables, números u otras
expresiones.
pág. 7
Universidad Tecnológica de Honduras
Estructuras de selección
Son bloques de código que permiten tomar decisiones basadas en el resultado de
una expresión booleana. En otras palabras, permiten ejecutar una u otra acción
dependiendo de si una condición es verdadera o falsa.
Las estructuras de selección más comunes son:
• if-else (si-sino): Ejecuta un bloque de código si la condición es
verdadera, y otro bloque si es falsa.
• else-if (sino-si): Permite evaluar varias condiciones de manera
secuencial.
• switch (según): Evalúa una expresión y selecciona una entre varias
opciones.
Ejemplo en pseudocódigo con if-else:
si (edad >= 18) entonces
imprimir("Eres mayor de edad") sino
imprimir("Eres menor de edad")
fin si
1. Errores comunes con operadores relacionales
Un error frecuente es usar el operador relacional incorrecto al establecer límites. Un
ejemplo que ilustra esto es cuando se programa para seleccionar a empleados
mayores de 65 años. Si se usa el operador >, se excluirán las personas de 65 años,
pero si se usa >=, se incluyen correctamente. Esto enfatiza la importancia de
entender y utilizar los operadores relacionales de manera precisa.
Es importante interpretar correctamente las instrucciones de quienes solicitan el
programa, ya que a menudo las instrucciones pueden ser ambiguas, como la
pág. 8
Universidad Tecnológica de Honduras
diferencia entre "más de" y "mayor o igual a". Por eso, siempre es recomendable
confirmar los requerimientos antes de implementarlos.
Lógica ADN
La lógica AND en programación es una operación booleana que permite combinar
dos o más condiciones para tomar decisiones. Se utiliza cuando es necesario que
todas las condiciones especificadas sean verdaderas para que se ejecute una
acción o se produzca un resultado.
Características clave de la lógica AND:
1. Ambas condiciones deben ser verdaderas: Si una condición es falsa, la expresión
completa será falsa. Solo si todas las condiciones evaluadas son verdaderas, la
expresión AND dará como resultado verdadero.
2. Sintaxis en varios lenguajes:
En muchos lenguajes de programación, la lógica AND se representa con && (doble
ampersand). Por ejemplo:
if (a > 10 && b < 20) {
// Solo se ejecuta si ambas condiciones son verdaderas.
En otros lenguajes como Python, se utiliza la palabra and:
if a > 10 and b < 20:
# Solo se ejecuta si ambas condiciones son verdaderas.
Ejemplo práctico:
Supongamos que estás desarrollando un sistema para una tienda que ofrece un
descuento si un cliente cumple con dos condiciones:
1. El cliente ha hecho más de 5 compras.
2. El total de las compras es mayor a $500.
pág. 9
El código que implementa esta lógica usando AND sería algo como:
if num_compras > 5 and total_compras > 500:
Universidad Tecnológica de Honduras
Aquí, el mensaje "Descuento aplicado" solo se mostrará si ambas condiciones (más
de 5 compras y más de $500) se cumplen.
¿Cómo funciona en la vida real?
Un ejemplo común sería un control de acceso. Supongamos que, para entrar a una
habitación segura, necesitas dos cosas:
1. Tener una tarjeta válida.
2. Saber el código de acceso correcto.+66666666
En este caso, ambas condiciones deben cumplirse para que la puerta se abra. Si
una de las dos es falsa (por ejemplo, si la tarjeta no es válida), la puerta no se
abrirá.
Tabla de verdad del operador AND:
La tabla de verdad para el operador AND muestra las posibles combinaciones de
verdad/falsedad y el resultado:
La lógica AND se usa cuando es necesario que todas las condiciones sean
verdaderas.
Es útil para crear condiciones compuestas y controlar flujos de decisiones
complejas.
Lógica AND
Condiciones compuestas: A veces es necesario evaluar más de una condición para
tomar una decisión en un programa. Esto se llama una condición compuesta, y para
pág. 10
Universidad Tecnológica de Honduras
ello se utiliza la lógica AND. Esto significa que ambas condiciones deben ser
verdaderas para que la acción se ejecute.
Ejemplo: En el caso de una empresa de telefonía, para cobrar $20 adicionales, se
debe cumplir con dos condiciones:
1. El cliente debe haber hecho más de 100 llamadas.
2. El total de minutos consumidos debe ser mayor a 500.
Si ambas condiciones se cumplen, se realiza el cobro adicional. Este tipo de lógica
se utiliza frecuentemente en programación cuando hay múltiples factores a evaluar.
3. Decisión AND en pseudocódigo
El diagrama de flujo y el pseudocódigo presentados muestran cómo funciona la
lógica AND en un programa de facturación telefónica. El pseudocódigo empieza con
declaraciones básicas y luego evalúa si las condiciones de número de llamadas y
minutos se cumplen. Si es así, el programa añade el cargo adicional, de lo contrario,
no lo hace.
Además, se introduce el concepto de decisiones encadenadas, que se construyen
usando la cláusula if-then-else para evaluar varias condiciones en cascada.
La lógica AND es esencial cuando se necesita cumplir más de una condición para
que se ejecute una acción.
Lógica OR
En ocasiones usted desea que ocurra una acción cuando una u otra de dos
condiciones sea verdadera. Esto se llama decisión OR porque una condición o
alguna otra condición deben cumplirse para que un evento se presente.
Si alguien pregunta:
“¿Estás libre para cenar el viernes o el sábado?”, sólo una de las dos condiciones
tiene que ser verdadera para que la respuesta a la pregunta completa sea sí; sólo si
las respuestas a ambas mitades de la pregunta son falsas el valor de la expresión
entera es falso.
pág. 11
Universidad Tecnológica de Honduras
Por ejemplo, suponga que desea agregar $20 a las facturas de los clientes de
telefonía celular que hagan más de 100 llamadas o usen más de 500 minutos. el
módulo detailLoop() alterado del programa de facturación que logra este objetivo.
Tabla de verdad para el operador OR
Evitar errores comunes cuando se usan comprobaciones de rango
Evitar errores comunes al usar comprobaciones de rango es crucial para garantizar
la precisión y efectividad de tu código.
Aquí hay algunos consejos:
1. **Definir claramente los límites**: Asegúrate de que los límites inferior y
superior estén bien definidos y documentados. Usa constantes en lugar de valores
mágicos para mayor claridad.
2. **Inclusión o exclusión de límites**: Decide si los límites deben ser inclusivos o
exclusivos y mantén la consistencia en todo el código.
3. **Orden de las comprobaciones**: Si realizas múltiples comprobaciones,
colócalas en un orden lógico. Por ejemplo, verifica primero si el valor está por
debajo del límite inferior antes de verificar el límite superior.
4. **Uso de operadores adecuados**: Asegúrate de usar los operadores correctos
(`<`, `<=`, `>`, `>=`) según las reglas que definas para tu rango.
5. **Validación de tipos de datos**: Asegúrate de que el valor que estás
comprobando sea del tipo esperado. Realiza conversiones si es necesario.
pág. 12
Universidad Tecnológica de Honduras
6. **Pruebas exhaustivas**: Realiza pruebas con diferentes valores, incluidos los
límites, para asegurarte de que las comprobaciones funcionan correctamente en
todos los casos.
7. **Manejo de errores**: Implementa un manejo adecuado de errores o
excepciones para valores fuera de rango. Esto ayudará a identificar problemas
durante la ejecución.
8. **Comentarios y documentación**: Incluye comentarios en el código para
explicar las comprobaciones de rango, lo que ayudará a otros (o a ti mismo en el
futuro) a entender la lógica.
9. **Refactorización**: Si el código de comprobación de rango se repite en varias
partes, considera refactorizarlo en una función para evitar errores y mantener la
consistencia.
10. **Revisión de código**: Realiza revisiones de código con compañeros para
detectar posibles errores o mejoras en la lógica de las comprobaciones.
Siguiendo estos consejos, puedes minimizar errores y mejorar la robustez de tu
código al trabajar con comprobaciones de rango.
• Precedencia cuando se combinan operadores AND y OR comprensión
Cuando se combinan los operadores AND y OR en expresiones lógicas, es
importante entender la precedencia para evitar confusiones. Aquí tienes un resumen
de cómo funciona:
Precedencia de Operadores
[Link]: Tiene la mayor precedencia. Se evalúa primero.
[Link]: Se evalúa después de NOT y antes de OR.
[Link]: Tiene la menor precedencia.
Ejemplo de Evaluación:
Considera la expresión:
A OR B AND
pág. 13
Universidad Tecnológica de Honduras
Evaluación Paso a Paso:
1. Primero se evalúa B AND C.
2. Luego se evalúa A OR (resultado de B AND C).
Uso de Paréntesis
Para evitar ambigüedades y hacer que el código sea más legible, es recomendable
usar paréntesis.
Por ejemplo:
Si quieres que A se evalúe con B antes que C, puedes escribirlo así:
(A OR B) AND C
Resumen
• Siempre recuerda que NOT se evalúa primero, seguido de AND, y finalmente
OR.
• Usa paréntesis para aclarar la intención de tu lógica y mejorar la legibilidad.
Siguiendo estas pautas, puedes evitar errores lógicos y hacer que tu código sea
más claro
pág. 14
Universidad Tecnológica de Honduras
Conclusiones
El uso de ciclos en el diseño de algoritmos ayuda a mejorar la legibilidad,
mantenibilidad y calidad del código, al permitir reducir la repetición de
instrucciones.
El uso de ciclos reduce la probabilidad de errores de programación causados
por la necesidad de realizar múltiples copias de un mismo código.
El uso de ciclos puede mejorar la eficacia y velocidad del programa al reducir
la necesidad de repetir instrucciones varias veces.
pág. 15
Universidad Tecnológica de Honduras
Bibliografía
*Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to Algorithms (3rd ed.).
MIT Press.
*Sebesta, R. W. (2012). Concepts of Programming Languages (10th ed.). Addison-Wesley.
[Link]
[Link]
%20biomol%C3%A9cula%20que%20compone%20al%20genoma
[Link]
[Link]
c690c48c3012/UAPA-estructuras-seleccion/[Link]#:~:text=Las%20estructuras%20de%20selecci
%C3%B3n%20(o%20condicionales)%20permiten%20realizar%20una%20u
[Link]
%20comparar%20dos%20valores%20y%20determinar%20si%20son%20iguales,%20diferentes,
[Link]
%C3%B3gico%20OR%20%28%7C%7C%29%20Este%20operador%20l%C3%B3gico
%20compara,sentencia%20devolver%C3%A1%20el%20valor%20de%20la%20primera%20expresi
%C3%B3n.
Álgebra booleana: qué es, historia, teoremas, postulados, ejemplos ([Link])
pág. 16
