INSTITUTO POLITECNICO NACIONAL

ESC. SUPERIOR DE INGENIERÍA MECÁNICA Y

ELÉCTRICA

UNIDAD ZACATENCO

ING. EN COMUNICACIONES Y ELECTRÓNICA

ASIGNATURA : FUNDAMENTOS DE PROGRAMACIÓN

PROFESOR : GUTIÉRREZ VILLALBA MARIA IVONNE

PRACTICA 4. ESTRUCTURAS DE REPETICIÓN

GRUPO : 1CM3

INTEGRANTES:
 CEDILLO GONZÁLEZ ISELA
 LOA MORENO LUIS FERNANDO
 RIOS CRUZ ANGEL VICENTE
 RODRÍGUEZ HERNÁNDEZ DANIEL
Índice

Tabla de contenido
Índice ................................................................................................................................................. 2
Introducción..................................................................................................................................... 3
Desarrollo ......................................................................................................................................... 4
Ejercicio 1: ................................................................................................................................... 4
Ejercicio 3 y 4: ................................................................................................................................. 6
Ejercicio 2: ................................................................................................................................. 10
Ejercicio 5: ................................................................................................................................. 11
Ejercicio 6: ................................................................................................................................. 13
Ejercicio 7: Serie de Taylor ................................................................................................... 15
Ejercicio 8: Calificaciones de Examen ............................................................................... 17
Ejercicio 9: ................................................................................................................................. 19
Ejercicio 10: ............................................................................................................................... 21
Conclusiones: ............................................................................................................................... 23
REFERENCIAS .................................................................................................................................. 24
Introducción

Se analizan las estructuras de control con las que el lenguaje C puede trabajar; se
utilizan estructuras de decisión, selección múltiple y de repetición, las cuales
permiten controlar el flujo del programa a partir de la evaluación de una condición
(en estructuras de decisión y repetición) o del valor que tome una variable
(estructura de selección múltiple). Los programas que se realizaron muestran el
pseudocódigo y su diagrama de flujo, el código en el lenguaje C con su respectiva
ejecución del programa.
Una estructura de decisión controla las acciones o el flujo de ejecución que debe
tomar un programa con base en la evaluación de una condición; la condición a
evaluar devuelve solamente dos posibles resultados: verdadero o falso. Las
estructuras de decisión se dividen en simples, dobles y ramificadas (anidadas).
Desarrollo

Ejercicio 1:
Ejercicio 3 y 4:
 Ejercicio 2:
// Verificar opción seleccionada

switch (opcion) {

case 1:
#include <stdio.h>
mostrarTablaFor(numero, inicio, fin);

break;
// Declaración de funciones
case 2:
void mostrarTablaFor(int numero, int inicio, int fin);
mostrarTablaWhile(numero, inicio, fin);
void mostrarTablaWhile(int numero, int inicio, int fin);
break;
void mostrarTablaDoWhile(int numero, int inicio, int fin);
case 3:

mostrarTablaDoWhile(numero, inicio, fin);

int main() {
break;
int numero, inicio, fin, opcion;
default:
// Entrada del usuario
printf("Opción no válida.\n");
printf("Ingrese un número para generar la tabla de
multiplicar: "); return 1;
scanf("%d", &numero); }
printf("Ingrese el inicio de la tabla: "); return 0;
scanf("%d", &inicio); }
printf("Ingrese el fin de la tabla: "); // Función para mostrar la tabla de multiplicar
utilizando el ciclo for
scanf("%d", &fin);
void mostrarTablaFor(int numero, int inicio, int fin) {
// Menú de opciones
printf("Tabla de multiplicar usando ciclo For:\n");
printf("\nSeleccione el tipo de ciclo:\n");
for (int i = inicio; i <= fin; i++) {
printf("1. For\n");
printf("%d x %d = %d\n", numero, i, numero * i);
printf("2. While\n");
}
printf("3. Do-While\n");

printf("Ingrese la opción: "); }

scanf("%d", &opcion); // Función para mostrar la tabla de multiplicar

utilizando el ciclo while

void mostrarTablaWhile(int numero, int inicio, int fin) {

printf("Tabla de multiplicar usando ciclo While:\n");

int i = inicio;

while (i <= fin) {

printf("%d x %d = %d\n", numero, i, numero * i);

i++;

} while (i <= fin);

}
Ejercicio 5:

#include <stdio.h>

#include <math.h>

// Declaración de la constante pi

#define PI 3.14159265358979323846

// Declaración de la función para calcular el área del círculo

double calcularAreaCirculo(int radio);

int main() {

int N;

// Entrada del usuario

printf("Ingrese el valor de N para generar la tabla de áreas de

círculos: ");

scanf("%d", &N);

// Verificar si el valor de N es válido

if (N < 1) {

printf("Ingrese un valor válido para N (mayor o igual a 1).\n");

return 1;

// Mostrar encabezado de la tabla

printf("\nRadio\t\tÁrea\n");

// Generar tabla de áreas de círculos

for (int radio = 1; radio <= N; radio++) {

double area = calcularAreaCirculo(radio);

printf("%d\t\t%.2f\n", radio, area);

return 0;

// Función para calcular el área del círculo

double calcularAreaCirculo(int radio) {

return PI * pow(radio, 2);

}
Ejercicio 6:
#include <stdio.h>

// Declaración de la función para calcular el factorial

unsigned long long calcularFactorial(int numero);

int main() {

int N;

// Entrada del usuario

printf("Ingrese el valor de N para generar la tabla de factoriales:

");

scanf("%d", &N);

// Verificar si el valor de N es válido

if (N < 0) {

printf("Ingrese un valor válido para N (mayor o igual a 0).\n");

return 1;

// Mostrar encabezado de la tabla

printf("\nNúmero\t\tFactorial\n");

// Generar tabla de factoriales

for (int numero = 0; numero <= N; numero++) {

unsigned long long factorial = calcularFactorial(numero);

printf("%d\t\t%llu\n", numero, factorial);

return 0;

// Función para calcular el factorial de un número

unsigned long long calcularFactorial(int numero) {

if (numero == 0 || numero == 1) {

return 1;

} else {

return numero * calcularFactorial(numero - 1);

}
Ejercicio 7: Serie de Taylor
Ejercicio 8: Calificaciones de Examen
 Ejercicio 9:

#include <stdio.h>

// Declaración de la función para calcular Fibonacci

unsigned long long calcularFibonacci(int n);

int main() {

// Imprimir los primeros 50 números de Fibonacci

printf("Los primeros 50 números de Fibonacci son:\n");

for (int i = 0; i < 50; i++) {

printf("%llu ", calcularFibonacci(i));

return 0;

// Función para calcular Fibonacci recursivamente

unsigned long long calcularFibonacci(int n) {

if (n == 0 || n == 1) {

return n;

} else {

return calcularFibonacci(n - 1) + calcularFibonacci(n - 2);

}
Ejercicio 10:

#include <stdio.h>

#include <math.h>

// Declaración de la función para calcular la serie

double calcularSerie(int N);

int main() {

int N;

// Entrada del usuario

printf("Ingrese un número entero N: ");

scanf("%d", &N);

// Calcular y mostrar el resultado de la serie

double resultado = calcularSerie(N);

printf("El resultado de la serie para N=%d es: %.2f\n",

N, resultado);

return 0;

// Función para calcular la serie

double calcularSerie(int N) {

double resultado = 0;

for (int i = 1; i <= N; i++) {

double termino = pow(-1, i) * pow(i, i);

resultado += termino;

return resultado;

}
Conclusiones:

-Rios Cruz Angel Vicente

Las estructuras de decisión en el lenguaje C son fundamentales para la programación, ya que

permiten tomar decisiones basadas en condiciones y controlar el flujo de un programa. En C, las
estructuras de decisión se implementan a través de las declaraciones "if", "

En resumen, las estructuras de decisión en C son esenciales para:

1. Tomar decisiones lógicas en un

2. Ejecutar diferentes bloques de código según las condiciones establecidas.

3. Controlar el flujo de ejecución de un programa.

4. realizar

Al comprender y utilizar eficazmente las estructuras de decisión en C, los programadores pueden

escribir programas más flexibles y capaces de adaptarse.

-RODRÍGUEZ HERNÁNDEZ DANIEL

La estructura de decisión en programación es fundamental para controlar el flujo de ejecución de

un programa. Permite que el programa tome decisiones basadas en condiciones específicas y
ejecute diferentes bloques de código en función de si esas condiciones se cumplen o no. En
resumen, la estructura de decisión es esencial para la lógica y la toma de decisiones en un
programa. En esta respuesta, se exploraron los siguientes puntos clave sobre la estructura de
decisión en programación: 1. **Estructuras de decisión básicas:** Las estructuras de decisión
básicas incluyen `if`, `else if` y `else`. Estos se utilizan para evaluar condiciones y ejecutar
diferentes bloques de código en función de si esas condiciones son verdaderas o falsas.
-Loa Moreno Luis Fernando

1. as estructuras de decisión, como "if", "else if" y "else", son fundamentales en

programación para tomar decisiones basadas en condiciones.

2. Las condiciones en las estructuras de decisión se evalúan como verdaderas o

3. Las estructuras de decisión son esenciales para realizar tareas como filtrar datos,
seleccionar rutas de ejecución

4. Puedes anidar estructuras de decisión para manejar situaciones más complejas y tomar
decisiones jerárquicas.

5. La sintaxis de las estructuras de decisión en C es relativamente sencilla, pero su uso adec.

Las estructuras de decisión en el lenguaje C, como "if" y "else", son esenciales para tomar
decisiones basadas en condiciones. Estas decisiones permiten controlar el flujo del programa y
adaptar la ejecución según situaciones específicas. Su sintaxis es relativamente simple.

-CEDILLO GONZÁLEZ ISELA

La estructura de decisión en programación es un pilar fundamental para el desarrollo de software.

Permite que un programa sea más dinámico y pueda adaptarse a diversas situaciones. Al evaluar
condiciones y tomar decisiones en tiempo de ejecución, se pueden diseñar aplicaciones que
respondan de manera inteligente a las necesidades del

En resumen, la estructura de decisión es una herramienta poderosa que aumenta la versatilidad y

utilidad de los programas, permitiendo que respondan de manera adecuada a diferentes
escenarios.

REFERENCIAS

 FUNDAMENTOS DE PROGRAMACIÓN. PIENSA EN C

OSVALDO CAIRO B ATTISTUTTI
 FUNDAMENTOS DE PROGRAMACIÓN
LORENA ASURA PÉREZ
BEATRIZ EUGENIA CORONA RAMÍREZ
INSTITUTO POLITÉCNICO NACIONAL