Instituto Tecnológico de Tijuana

Departamento de Ingeniería Industrial

Algoritmos y Lenguajes de Programación

Portafolio de Evidencias
“Estructuras selectivas y de repetición”

Grupo 4A

Nombre del Alumno:

Ingrid Citlalli García Martínez

Nombre del Maestro:

Alma Graciela Casas Fausto

TIJUANA, B.C. 06 de mayo del 2024

 Índice
Introducción..................................................................................................................................... 3
Marco teórico................................................................................................................................... 4
Estructuras selectivas y de repetición ..................................................................................... 4
4.1 Selectiva simple ................................................................................................................... 4
4.3 Selectiva anidada................................................................................................................. 6
4.4 Selectiva múltiple ................................................................................................................ 7
4.5 Repetir mientras................................................................................................................... 8
4.6 Repetir hasta ....................................................................................................................... 10
4.7 Repetir desde ...................................................................................................................... 11
4.8 Elaboración de programas .............................................................................................. 11
Ejercicios Unidad 4 ...................................................................................................................... 13
Conclusión ..................................................................................................................................... 39
Referencias Bibliográficas......................................................................................................... 39
 Introducción
En el siguiente trabajo de investigación, se presentará desarrollado los 8 temas
visualizado en la materia de algoritmos y lenguajes de programación, denominado
estructuras simples y de repetición, en este trabajo estarán introducidos con un
marco teórico donde se presentarán los tipos de selectiva y los tipos de repetir, con
el objetivo de presentarlos trabajos desarrollados a lo largo de la unidad numero 4.
En el mundo de la programación y los algoritmos, las estructuras simples y de
repetición son los cimientos sobre los cuales se construyen soluciones complejas.
Las estructuras simples, como las variables y las condiciones, proporcionan el
marco básico para la lógica de programación, mientras que las estructuras de
repetición, como bucles y recursión, permiten la ejecución repetida de instrucciones
según condiciones específicas. Comprender y dominar estas estructuras es
fundamental para el desarrollo de algoritmos eficientes y robustos.
Por otro lado, las estructuras de repetición, también conocidas como bucles, son
esenciales para ejecutar instrucciones de forma repetida hasta que se cumpla una
condición específica. Los bucles permiten automatizar tareas repetitivas y procesar
grandes conjuntos de datos de manera eficiente. Los bucles más comunes son el
"for", el "while" y el "do-while", cada uno con sus propias características y
aplicaciones. Además de los bucles, la recursión es otra técnica importante que
implica la llamada repetida a una función dentro de sí misma, lo que permite resolver
problemas de manera elegante y eficiente, especialmente en casos donde la
solución se puede dividir en subproblemas más pequeños.
Marco teórico

Estructuras selectivas y de repetición

4.1 Selectiva simple
Como hemos tenido ocasión de comprobar, la especificación formal de algoritmos
tiene utilidad real, cuando éstos requieren una descripción más complicada que una
simple secuencia de instrucciones. Uno de estos casos se produce cuando existen
varias alternativas, resultantes de la evaluación de una determinada condición,
como ocurre, por ejemplo, al resolver una ecuación de segundo grado, donde el
procedimiento a seguir es distinto según el discriminante sea positivo, nulo ó
negativo. Las estructuras selectivas en un programa se utilizan para tomar
decisiones, de ahí que se suelan denominar también estructuras de decisión o
alternativas. En estas estructuras se evalúa una condición, especificada mediante
expresiones lógicas, en función de cuyo resultado, se realiza una opción u otra. En
una primera aproximación, para esta toma de decisiones, podemos pensar en una
variable interruptor o conmutador (switch), que representa un estado y por tanto
puede cambiar de valor a lo largo de la ejecución regulando el paso a una u otra
parte del programa, lo que supone una bifurcación en el flujo del programa,
dependiendo del valor que tome el conmutador.
Dependiendo si la comparación es cierta o falsa, se puede realizar una o más
acciones. Para realizar más de una, se puede usar el concepto de bloque (INICIO
FINAL).
Se identifican porque están compuestos únicamente de una condición. La
estructura si entonces evalúa la condición y en tal caso:
• Si la condición es verdadera, entonces ejecuta la acción Si.
• Si la condición es falsa, entonces no se hace nada.
Ejemplo Construir un algoritmo tal, que dado como dato la calificación de un alumno
en un examen, escriba "Aprobado" en caso que esa calificación fuese mayor que 8.

Salidas: mensaje de aprobado si se cumple la condición.

Entradas: calificación
Datos adicionales: un alumno aprueba si la calificación es mayor que 8
Variables:
Cal = calificación
Algoritmo:
Inicio
Leer (cal)
Si cal > 8 entonces
Escribir ("aprobado")
Fin_si
Fin
 4.2 Selectiva doble

Son estructuras lógicas que permiten controlar la ejecución de varias acciones y se

utilizan cuando se tienen dos opciones de acción, por la naturaleza de estas se debe
ejecutar una o la otra, pero no ambas a la vez, es decir, son mutuamente
excluyentes. La estructura selectiva si entonces/sino permite que el flujo del
diagrama se bifurque por dos ramas diferentes en el punto de la toma de
decisión(es). Si al evaluar la condición (o condiciones) el resultado es verdadero,
entonces se sigue por un camino específico y se ejecuta(n) cierta(s) operación(es).
SI el resultado es falso entonces se sigue por otro camino y se ejecuta(n) otra(s)
operación(es).
Entonces, si una condición C es verdadera, se ejecuta la acción S1 y si es falsa,
se ejecuta la acción S
Ejemplo

Algoritmo
1. Inicio
2. Leer la calificación del alumno. CAL.
3. Evaluar si la calificación es mayor o igual a 8.
3.1. Si la calificación es mayor o igual a 8., imprimir “Aprobado”.
3.2. Si la calificación no es mayor o igual a 8., imprimir “Reprobado”.
4. Fin

Pseudocódigo
Inicio
Leer CAL
Si CAL>=8 entonces
Imprimir “Aprobado”
Sino
Imprimir “Reprobado”
Fin Si
Fin
 4.3 Selectiva anidada
La estructura selectiva anidada es una cadena de estructuras selectivas que se
conectan de la parte else de la actual con la parte if de la siguiente, es decir cuando
después de una decisión se debe tomar otra, después otra y así sucesivamente.

Las estructuras selectivas anidada es aquella que evalúa una condición si es

verdadera realiza una acción o grupo de acciones y si es falsa ejecuta las demás
instrucciones. En las condiciones se utiliza operadores lógicos.

Ejemplo: Realizar un DF y codificación de un programa que permita ingresar 4

caracteres si alguna de ellas es carácter ’s’ ingresar 3 números y luego sumarlos.

Pseudocódigo 9)Si d=5 entonces

si ir al paso 10
1) Inicio
10) leer x,y,z
2) leer a,b,c,d
r x+y+z
3) Si a=’s’ entonces
Imprimir r
si ir al paso 4
11) Fin
sino ir al paso 5
4) leer x,y,z
r x+y+z
Imprimir r
5)Si b=’s’ entonces
si ir al paso 6
sino ir al paso 7
6) leer x,y,z
r x+y+z
Imprimir r
7)Si c=’s’ entonces
si ir al paso 8
sino ir al paso 9
8) leer x,y,z
r x+y+z
Imprimir r
 4.4 Selectiva múltiple
La estructura selectiva si múltiple permite que el flujo del diagrama se bifurque por
varias ramas en el punto de la toma de decisión(es), esto en función del valor que
tome el selector. Así si el selector toma el valor 1 se ejecutará la acción 1, si toma
el valor 2 se ejecutará la acción 2, si toma el valor N se realizará la acción N, y si
toma un valor distinto de los valores comprendidos entre 1 y N, se continuará con el
flujo normal del diagrama realizándose la acción N + 1.

Ejemplo
Construya un diagrama de flujo tal que dado como datos dos variables de
tipo entero, obtenga el resultado de la siguiente función:
Datos de entrada:
Se requiere el valor de V y el valor de NUM

(Definición de variable)
V. Variable de tipo entero que expresa el valor de V dentro de la función. NUM.
Variable de tipo entero que expresa el valor de NUM.

Resultado esperado o datos de salida:

El resultado de la función VAL.

(Definición de variable)
VAL. Variable de tipo real que expresa el resultado de la función realizada.

Proceso: (Algoritmo)
1. Inicio
2. Leer el valor de V y NUM.
3. Evaluar el valor de NUM
3.1. Si NUM = 1 entonces realizar la función VAL= 100 * V.
3.2. Si NUM = 2 realizar la función VAL= 100 ** V.
3.3. Si NUM = 3 calcular la función VAL= 100 / V.
3.4. Para cualquier otro valor de NUM asignar a VAL el valor de cero. VAL=0.
4. Imprimir el resultado de la función VAL
5. Fin
 4.5 Repetir mientras
El computador está especialmente diseñado para aplicaciones en las que una
operación o un conjunto de ellas deben repetirse muchas veces. En este sentido,
definiremos bucle o lazo (loop), como un segmento de un programa cuyas
instrucciones se repiten bien un número determinado de veces o mientras se cumpla
una determinada condición.
Es imprescindible que se establezcan mecanismos para controlar esta tarea
repetitiva, ya que si éstos no existen, el bucle puede convertirse en un proceso
infinito. Así, en el bucle representado por el organigrama, se observa que las
instrucciones incluidas en él se repiten indefinidamente. El mecanismo de control
citado se establece mediante una condición que se comprueba en cada paso o
iteración del bucle. En la Figura 3.11, se coloca una condición tras la lectura de la
variable N (comprobar si su valor es cero), de forma que tenemos la oportunidad de
que el bucle deje de ser infinito, ya que podrá interrumpirse cuando la condición sea
verdadera.
Los procesos que se repiten varias veces en un programa necesitan en muchas
ocasiones contar el número de repeticiones habidas. Una forma de hacerlo es
utilizar una variable llamada contador, cuyo valor se incrementa o decremento en
una cantidad constante en cada repetición que se produzca.

Este ciclo consiste en un conjunto de instrucciones que se repiten mientras se

cumpla una condición. De igual manera que en los condicionales, la condición es
evaluada y retorna un valor lógico, que puede ser verdadero o falso. En el caso del
ciclo mientras las instrucciones contenidas en la estructura de repetición se
ejecutarán solamente si al evaluar la condición se genera un valor verdadero; es
decir, si la condición se cumple; en caso contrario, se ejecutará la instrucción que
aparece después de Fin mientras.

A diferencia de otros ciclos, el ciclo mientras comienza evaluando la expresión

condicional, si el resultado es verdadero se ejecutarán las instrucciones que estén
entre el mientras y el fin mientras, al encontrarse la línea fin mientras se volverá a
evaluar la condición, si se cumple se ejecutarán nuevamente las instrucciones y así
sucesivamente hasta que la condición deje de cumplirse, en cuyo caso, el control
del programa pasa a la línea que aparece después de fin mientras. Si en la primera
pasada por el ciclo mientras la condición no se cumple las instrucciones que están
dentro del ciclo no se ejecutarán ni una sola vez.

Los comentarios efectuados en relación a Mientras.

• El número de repeticiones no está prefijado.

 • El diseño debe aportar una condición de salida válida.
• El control del bucle se realiza a través de contadores, acumuladores,
etc.

Ejemplo: Un algoritmo para mostrar los números del 1 al 10.

Definición del problema

Mostrar listado de números de 1 a 10.

• Análisis del problema

• Datos de entrada: ninguno
• Datos de salida: número
• Proceso: ninguno
• Diseño de la solución

La condición o expresión relacional con la cual se implementa el ciclo es num <=

10, dado que num inicia en 1, la primera vez que se encuentra la instrucción
mientras, la expresión es verdadera, por tanto se ejecutan las instrucciones que
aparecen al interior del ciclo.

Después de haber mostrado el contenido de la variable num, éste cambia, se

incrementa
 4.6 Repetir hasta
Esta estructura es característica de lenguajes como PASCAL, y su uso es muy
sencillo, se especifica un valor de partida (lógicamente) y un valor de parada (por
eso es “hasta”) que es el valor límite hasta el cual se realizara cierta instrucción
utilizando como base el valor de repetición. Esta estructura es manejada por
PASCAL como una estructura aparte
Esta estructura se encuentra en cualquier lenguaje de programación, no
necesariamente tal cual se muestra aquí, se utiliza un for o un while, simplemente
se modifica la condición para que no afecte al número de repeticiones. Por ejemplo
con un for:for (a = 0; a<50; a++) printf(“Rafa\n”);Esta sentencia se ejecutará 50
veces, ósea hasta el 50.Como conclusión decir que todo lo necesario para realizar
repeticiones se encuentran con las estructuras while() y for(), solo es cuestión de
saber estructurar las condiciones.

Ejemplo
Calcular el factorial de un número N, usando la estructura repetir.
inicio
leer N
Factorial ←1
I←1
repetir
Factorial← Factorial * I
I ← I+1
hasta_que I > N
escribir “el factorial del número”, N, “es”, Factorial
fin
 4.7 Repetir desde
Los valores inicial y final de la variable de control se determinan antes de que
empiece la repetición y no pueden cambiarse durante la ejecución de la instrucción
Desde. Dentro del cuerpo del bucle Desde, los valores de las variables que
especifican los valores inicial y final pueden cambiar, pero esto no va a afectar al
número de repeticiones. La instrucción del cuerpo del bucle de una instrucción
Desde puede utilizar el valor de la variable de control, pero no debe modificar este
valor. Esta estructura se puede usar únicamente en aquellos casos en que
conocemos el número de veces que se va a realizar el ciclo.
Esta estructura hace el incremento automáticamente y se inicializa en la instrucción
desde.

4.8 Elaboración de programas

Estructuras repetitivas del software PSeint

Dentro del programa PSeint se tienen disponibles a 3 de las estructuras repetitivas,
las cuales son Mientras, Repetir-Hasta y la estructura Para. La estructura y sintaxis
de uso de cada una se explica a continuación.

• Mientras
• Repetir Hasta
• Para
Sintaxis y uso de la instrucción “Mientras”
Repite un bloque de instrucciones (Secuencia_de_acciones) limitada entre el paso
Mientras y paso FinMientraS.

La repetición del bloque de pasos se controla al inicio de la estructura, gracias a

evaluar a una condición lógica CL “Expresion_logica”, cuyo resultado Verdadero o
Falso es aprovechado para determinar si repite o no el bloque.

Al utilizar un lazo Mientras hay que tener cuidado de lo siguiente:

a) Para permitir que el lazo Mientras ejecute al menos una vez su ciclo
de instrucciones, usted debe de asegurarse que su Condición Lógica
se cumpla (inicialmente), sino PSeint ignora a todo el bloque a repetir
dentro de la estructura y continuara con el paso justamente después
del cierre del Mientras.

b) Para que el lazo Mientras pueda repetir el Bucle una o más veces,
asegúrese que en el interior de los pasos del ciclo se modifique/altere
el valor de (por lo menos) una de las variables utilizada en la CL, de
manera que al finalizar el ciclo actual, PSeint evalué de nuevo la CL,
y decida si repetir el Bucle.

c) Según la aclaración anterior, si necesita que el lazo finalice (que ya no

se repita de nuevo el ciclo), asegúrese que al volver a evaluar la CL,
está ya no se cumpla.
 Ejercicios Unidad 4
Ejercicio 4.1: Calcular Promedio se obtuvo beca
Código:

Ejecución:
Ejercicio 4.2: Promedio del alumno, se obtuvo beca y no se obtuvo beca
Código:

Ejecución:
Ejercicio 4.3: Capturar 3 calificaciones, nombre y matricula, desplegar si
obtiene beca o si no obtiene beca
Código:

Ejecución:
Ejercicio 4.4: Calcule ventas mensuales de un empleado si las ventas son
mayores a 20000 desplegar "obtiene comisión del 15 %" de lo contrario "no
logra venta" y no obtiene comisión desplegar nombre y no de empleado
Código:

Ejecución:
Ejercicio 4.5: Capture Nombre del alumno, si tiene promedio mayor a 90,
exenta el examen, de lo contrario desplegar que no exenta
Código:

Ejecución:
Ejercicio 4.6: Capture el precio de tres productos, si la venta es mayor a 1500,
y pertenece al departamento de jugueteria, desplegar que se le aplicara un
descuento del 20%, de lo contrario, desplegar que no se aplicara descuento y
que su venta total es
Código:

Ejecución:
Ejercicio 4.7: Capture etapa de vida
Código:

Ejecución:
Ejercicio 4.7a: Capture etapa de vida
Código:

Ejecución:
Ejercicio 4.8: Capture el tiempo de dos máquinas , determinar el tiempo más
optimo considerar que puede ser iguales los tiempos
Código:

Ejecución:
Ejercicio 4.8a: Tiempos óptimos de la maquina
Código:

Ejecución:
Ejercicio 4.9a: Estatura de una persona anidada
Código:

Ejecución:
Ejercicio 4.9:Estatura de una persona
Código:

Ejecución:
Ejercicio 4.10:Equipo de básquet, desplegar si forma parte del equipo o si no
forma dependiendo con la estatura.
Código:

Ejecución:
Ejercicio 4.11 : Suma de fracciones o números naturales
Código:

Ejecución:
Ejercicio 4.12 : Determinar el total a pagar por el boleto de estacionamiento
Código:

Ejecución:
Ejercicio 4.13 : Contadores incremento y decremento
Código:

Ejecución:
Ejercicio 4.14 : Capturar 10 nombres y desplegar la suma de los números
Código:

Ejecución:
Ejercicio 4.15: Capture nombre de un empleado y capture venta mensual y
determine venta anual
Código:

Ejecución:
Ejercicio 4.16 : Cronometro en decremento
Código:

Ejecución:
Ejercicio 4.17 : Cronometro en incremento
Código:

Ejecución:
Ejercicio 4.18: Despliegue si el numero capturado es par o impar
Código:

Ejecución:
Ejercicio 4.19: Capturar minutos y segundos con contador
Código:

Ejecución:
Ejercicio 4.20: While True, Contador con los segundos totales
Código:

Ejecución:
Ejercicio 4.21: Capturar 10 números y desplegar la suma de los pares y de los
que pertenecen a los impares
Código:

Ejecución:
Ejercicio 4.22: Cronometro Bucle While True
Código:

Ejecución:
Ejercicio 4.23:Cronometro en decremento Bucle for
Código:

Ejecución:
 Conclusión
En resumen, las estructuras simples y de repetición son pilares fundamentales en
el desarrollo de software y la resolución de problemas computacionales. Al
comprender y dominar estas estructuras, los programadores adquieren la capacidad
de diseñar algoritmos eficientes y escalables, así como de construir software
robusto y fácil de mantener. En el contexto de un portafolio de evidencias para la
materia de algoritmos, demostrar un sólido entendimiento y aplicación de estas
estructuras será crucial para mostrar competencia y habilidad en la programación y
resolución de problemas computacionales.

Referencias Bibliográficas

DIEGO LLANOS. (2010). Fundamentos de informática y programación. En

Fundamentos de informática y programación(310-314). MEXICO: GUSTAVO GUILI.

JOYANES, L. (2008). Fundamentos de la programación. Algoritmos y Estructura de

Datos, 4ª Edición. Madrid: McGraw-Hill.