El documento presenta un trabajo de computación en el que se abordan la programación en C y el aprendizaje basado en la resolución de problemas a través de estructuras de control, subprogramas y recursión. Se analizan tres problemas específicos: la aproximación del área bajo la curva de una función, el cálculo del mínimo común múltiplo y el máximo común divisor utilizando diferentes métodos. Las conclusiones destacan la eficiencia del uso de estructuras de control y la importancia del análisis metodológico en la programación.

1. FACULTAD REGIONAL MULTIDISCIPLINARIA DE CARAZO
FAREM-CARAZO
II Trabajo de Computación (Programación)
Programa de doctorado en Matemática Aplicada
Aprendizaje basado en la resolución de problemas, mediante la
programación C
Estructuras de control (Estructuras repetitivas, Condicionales múltiples), Sub
programas (Procedimientos y funciones) y Recursión
Autores
 Cliffor Jerry Herrera Castrillo
 Donald Ariel Hernández Muñoz
 Norman Rafael López Herrera
 Ileana María Martínez Méndez
Docente: Dr. Harold Ramiro Gutiérrez Marcenaro.
28 de Julio 2019

2. Índice
I. Introducción _________________________________________________________ 1
Problema 1 ______________________________________________________________________2
Problema 2 ______________________________________________________________________6
Problema 3 _____________________________________________________________________21
II. Conclusiones______________________________________________________ 31
Bibliografía ____________________________________________________________ 32

3. 1
I. Introducción
En el presente escrito, se muestra la aplicación de las estructuras repetitivas y condicionales
múltiples, subprogramas (procedimientos y funciones), recursividad y además el análisis de
los arreglos.
La metodología de análisis de los programas planteados en este trabajo investigativo, y que
le dan solución a los problemas propuestos en la tercera evaluación del Módulo de
Computación (programación), es la siguiente: las funciones, variables, constantes, arreglos,
entre otros, se analizan en forma de comentarios, haciendo uso de la función de Word
(Insertar- Comentario).
Sin dejar a lado el resumen de los logros, dificultades y los aprendizajes por descubrimientos
de forma intencional y accidental (Heurístico inherente y la Serendipía), estos se presentan
en el apartado de las conclusiones.
Es importante recalcar, que en este informe se continúa implementando las instrucciones de
control (for, while, do – while, switch, break, return)y que se denominan así, ya que cuando
termina la ejecución de la última sentencia, el flujo de control vuelve a la primera y comienza
otra repetición delas sentencias o condiciones. Estas repeticiones se conocen como iteración
o pasada a través de los ciclos.
Una función toma uno o más valores, denominados argumentos o parámetros actuales y,
según el valor de éstos, devuelve un resultado en el nombre de la función. Para invocar a una
función se utiliza su nombre seguido por los parámetros actuales o reales entre paréntesis en
una expresión. Es decir que se podrá colocar la llamada a una función en cualquier
instrucción donde se pueda usar una expresión.(Aguilar, 2003, p. 80)
Lo antes planteado hace referencia a funciones, las cuales se implementan de manera
constante en este trabajo, como funciones principales, ejemplo main, y también aquellas que
están dentro de subprogramas, ejemplo buscarea, las cuales tienen una forma general de
ejecución: Cabecera, con la definición de la función y el cuerpo de la misma. Dentro del
cuerpo de la función está el bloque de expresiones y de instrucciones.

4. 2
Desarrollo
En este capítulo se presentan los programas resueltos que permiten obtener la solución de las
incógnitas de cada uno de los tres problemas propuestos en la guía didáctica número tres,
además, haciendo uso de una nueva metodología respecto a los dos trabajos evaluativos de
este curso, los análisis se realizan dentro de los algoritmos y también de manera explícita
apoyándose de la función insertar – comentario en Word.
Es importante recalar que los programas resueltos en este informe, se complementan, con
una carpeta comprimida, donde ahí se puede evidenciar los algoritmos que le dan solución
a cada problema, al ser ejecutados en el lenguaje C.
Problema 1
Es posible hacer una aproximación del área bajo la curva y=f(x) sobre el intervalo [a,b]
mediante la subdivisión del intervalo [a,b] en n subintervalos iguales, para después construir
un rectángulo sobre cada uno de los subintervalos (donde la altura del rectángulo será
equivalente al valor de f(x) en el punto medio del subintervalo). La suma de las áreas de
estos n rectángulos es una aproximación del área bajo la curva (integral de la función). La
figura 1 y la figura 2 representan respectivamente, el área exacta y el área aproximada cuando
f(x)= x2+1 sobre el intervalo [0,1] con n=3.

5. 3
El siguiente programa en Lenguaje C, calcula el área aproximada bajo la curva, de la función
f(x)=x2+1. El ancho de cada rectángulo se calculó mediante la división de la longitud del
intervalo entre el número de rectángulos que es necesario construir, es decir ancho  (b-a) /
n. La altura es igual al valor de la función f en el punto medio del rectángulo:
Solución
a) Analice el código del programa y explique endetalle el funcionamiento de cada uno
de sus subprogramas. Por ejemplo, ¿Qué función cumple la variable asum? ¿Para
qué sirve la instrucción puntomed=a+(ancho/2)? ¿Para qué sirve la instrucción
puntomed=puntomed+ancho?, entre otros.
#include<stdio.h>
#include<conio.h>
#include<math.h>
Figura2. Representacióndel
área aproximada bajo la
curva de la función
f(x)=x2
+1.
Figura1. Representacióndel
área exactabajola curva de
la funciónf(x)=x2
+1.

6. 4
double f(double);
doublebuscarea(double,double,int);
void main()
{
doublearea,a,b;// A qui se declaran las variables
int n;
clrscr();
printf("nDe el valor de a : ");
scanf("%lf",&a);
printf("nDe el valor de b : ");
scanf("%lf",&b);
printf("nDe el número de rectángulos : ");
scanf("%d",&n);
area=buscarea(a,b,n);
printf("nEl área aproximada es %.4lf",area);
getch();
}
// subprogram 1
double f(double x)/* Esta función f lo que hace es, calcular la potencia f(x)=x^2+1*/
{
return(pow(x,2)+1);
}
doublebuscarea(double a, double b, intn)// subprogram 2
{
inti;
doubleancho,puntomed,altura,asum;
ancho=(b-a)/n;
asum=0.0;
puntomed=a+(ancho/2);

7. 5
for(i=1;i<=n;i++)
{
altura=f(puntomed);/*Dentro de la función buscarea manda a buscar otra función f,
la que se encuentre en el subprograma 1, luego de hacer eso, pasa el valor a la altura y
lo suma.*/
asum=asum+altura*ancho;/*A la suma que valía cero la primera vez, le suma la altura
por ancho*/
puntomed=puntomed+ancho;/*Y el punto medio va ser ahora, el punto medio que se
había calculado más el nuevo ancho*/
}
return(asum);
}
b) Calcule manualmente el resultado de ∫ 𝒙 𝟐
+ 𝟏 𝒅𝒙
𝟏
𝟎
y compare con el resultado del
programa cuando se introduce a0, b1, n3.
Comparación del cálculo de la integral ∫ 𝒙 𝟐
+ 𝟏 𝒅𝒙
𝟏
𝟎
Manual Programa
∫ 𝑥2
+ 1 𝑑𝑥
1
0
=
𝑥3
3
+ 𝑥|
1
0
Usando 𝑓(𝑥)| 𝑏
𝑎
= 𝐹( 𝑏) − 𝐹(𝑎)
13
3
+ 1 − (
03
3
+ 0) =
4
3
= 𝟏. 𝟑𝟑𝟑𝟑
Análisis: En la comparación del calculo de la integral definida entre la gráfica f(x), el
eje de las abscisas y las rectas verticales a=0 y y=1 por ambos métodos, se puede
evidenciar que el valor del área bajo la curva através del prográma, es es un valor que
se aproxima al valor verdadero de 4/3, calculado manualmente.
c) Corra nuevamente el programa incrementando sucesivamente el valor de n. ¿Cuál
es el comportamiento del valor del área bajo la curva?
Captura 1, Extraída de Borland C++

8. 6
Análisis:"La idea principal acá es que si hacemos los intervalos de nuestra partición más y
más pequeños, la suma de las áreas de los rectángulos se aproximarán a un límite." Si
aumentamos el número de rectángulos nos acercaremos (intuitivamente) al valor de la
integral definida, en este caso a 4/3.
Todo esto se constató, ya que cuando el usuario en el programa va aumentando la asignación
de rectángulos a n, el área se aproxima a 4/3.
Se puede decir que la integral definida es el límite de las sumas de Riemann cuando el número
de subdivisiones tiende a infinito y la longitud de cada subintervalo tiende a cero. Y no
importa el punto i que tomamos de cada subintervalo.
Problema 2
El mínimo común múltiplo (m.c.m.) de dos números enteros a y b, es el menor de los
múltiplos comunes a ambos números (distinto de cero). El siguiente programa encuentra e
imprime el mínimo común múltiplo de dos números enteros positivos a y b, haciendo uso de
un ciclo for:
#include<stdio.h>
#include<conio.h>
void main()
{
inta,b,i,mcmab;
clrscr();
printf("De el primer número entero positivo : ");

9. 7
scanf("%d",&a);
printf("De el segundo número entero positivo : ");
scanf("%d",&b);
for(i=b;i>=1;i--)
{
if((a*i)%b==0)
mcmab=a*i;
}
printf("nnEl mcm( %d ,%d ) = %d",a,b,mcmab);
getch();
}
Esta solución realiza obligatoriamente b iteraciones del ciclo for, aún en los casos en que el
mcm(a,b) sea a*b.
Por otro lado, el máximo común divisor (m.c.d.) de dos números enteros a y b es el mayor
entero que divide a ambos números simultáneamente. El método convencional para encontrar
el m.c.d. de dos números es: 1) Se descompone cada número en un producto de factores
primos, 2) El producto de estos factores comunes elevados al menor exponente es el m.c.d
entre ambos números.Por ejemplo, para encontrar el mcd(12,18) se siguen estos pasos:

10. 8
12 2 18 2
6 2 9 3
3 3 3 3
1 1
12 = 22 x 3
18 = 2 x 32
mcd(12,18) = 2 x 3 = 6
Este método es totalmente programable, aunque existen alternativas de implementación
menos complicadas computacionalmente, una de ella es el Algoritmo de Euclides, que en
resumen puede representarse así:
b,mcd(b,a MOD b)) cuando b>0
mcd(a,b)=
a cuando b=0
Este planteamiento nos lleva a una definición recursiva del problema. Recuerde que “MOD”,
algorítmicamente representa el cociente de una división entera (a%b, en Lenguaje C).
Escriba un programa que pida al usuario dos números enteros positivos, luego encuentre el
máximo común divisor, presentando para ello tres opciones en un menú:
La opción 1 se llamará “MCD Euclides”, y deberá invocar a una función recursiva que
implemente el Algoritmo de Euclides para el cálculo del máximo común divisor.
La opción 2 se llamará “MCD Iterativo”, y deberá invocar a una función que retorne el mcd
entre ambos números, utilizando un ciclo, de manera similar a la estructura del programa que
se muestra al inicio después del encabezado del ejercicio.

11. 9
La opción 3 se llamará “MCD Convencional”, y deberá invocar a una función que encuentre
el máximo común divisor a través del método convencional, es decir por el producto de los
factores comunes elevados al menor exponente.
Como se acostumbra, la última opción del menú es “Salir”.
Solución del problema
#include<conio.h>
#include<conio.h>
#include<math.h>
int calcMCD_Euclides(int, int);
int calcMCD_Iteractivo(int, int);
int calcMCD_Convencional(int);
int primo(int);
int primomayor(int);
int mcdconv(int,int);
int exp(int x);
void main()
{
int num1, num2, opc, bandera;
bandera=0;
clrscr();
do
{
Pero al igual debemos tomar las funciones para
obtener el menor de los múltiplos comunes elevados
al menor exponente para poder aplicar el método
convencional.
Programa principal, aquí se hace el llamado a los
demás subprogramas
Se declaran las variables y un valor bandera para salir
del main.
Con este do se mete dentro de él el menú, para que no salga mientras no se de la
opción de salir.
Ilustración 1: Elaborado por Norman López

12. 10
clrscr();
printf("nSeleccione el n%cmero de opci%cn para calcular elnM%cximo Com%cn Divisor
por el m%ctodo de:n", 163,162,160,163,130);
printf("t1-> Euclides");
printf("nt2-> Iteractivo");
printf("nt3-> Convencional");
printf("nt4-> Salir");
printf("nOpci%cn : ",162);
scanf("%d",&opc);
switch(opc)
{
case 1:
clrscr();
printf("Digite el primer n%cmero entero: ", 163);
scanf("%d", &num1);
printf("Digite el segundo n%cumero entero: ", 163);
scanf("%d", &num2);
printf("nEl MCD es %d", calcMCD_Euclides(num1, num2));
break;
case 2:
Se escribe en el menú tomando las opciones,
1,2,3 y 4, pido la opción y leo la opción,
aclarando que 163,162,160,163,130, son el
código ASSI Y las palabras acentuadas.
Este es el menú y se hace con un switch, que significa, según sea la
opción, se obtendrá l opción del número que se haya digitado.

13. 11
clrscr();
printf("Digite el primer n%cmero entero: ", 163);
scanf("%d", &num1);
printf("Digite el segundo n%cumero entero: ", 163);
scanf("%d", &num2);
printf("nEl MCD es %d", calcMCD_Iteractivo(num1, num2));
break;
case 3:
clrscr();
printf("De el primer n%cmero : ",163);
scanf("%d", &num1);
printf("De el segundo n%cmero : ",163);
scanf("%d", &num2);
printf("n1.-Descomponiendo en Factores:n ");
calcMCD_Convencional(num1);
printf("nn");
calcMCD_Convencional(num2);
printf("nn2.-Elevando a sus respectivos factores primos:");
printf("nnt-> %d : ", num1);
exp(num1);

14. 12
printf("nnt-> %d : ", num2);
exp(num2);
printf("nn3.-Encontrando el M%cximo Com%cn Divisor:n", 160,163);
printf("nEl mcd ( %d , %d ) =
%d",num1,num2,mcdconv(num1,num2));
break;
case 4:
bandera=1;
break;
default:
printf("nnERROR: Opci%cn no v%clida...",162,160);
}
if(!bandera)
{
printf("nnnPresione una tecla para continuar...");
getch();
}
}while(!bandera);
printf("nUsted est%c saliendo del programa.",160);
printf("nnPresione una tecla para salir...");
getch();
Condición: Cuando el valor bandera sea diferente de
cero entonces indica que ya va a salir.
Con un break detenemos el ciclo
default: Si el valor digitado no es correcto,o ninguno de las opciones del
menú.

15. 13
}
calcMCD_Euclides(int dividendo, int divisor)
{
int residuo = dividendo % divisor;
if(residuo == 0)
{
return(divisor);
}
while(!residuo == 0)
{
dividendo = divisor;
divisor = residuo;
residuo = dividendo % divisor;
if(residuo == 0)
{
return(divisor);
}
}

16. 14
}
int calcMCD_Iteractivo(int a, int b)
{
int i, MCD;
for(i=1;i<=b;i++)
{
if((a % i == 0) && (b % i == 0))
MCD = i;
}
return(MCD);
}
int calcMCD_Convencional(int x)
{
int i;
printf("nt%d", x);
for(i=2;i<=x;i++)
{
while(x % i == 0)
{
x = x/i;
printf("t|%d", i);
printf("nt%d", x);
if(x % i == 1)

17. 15
{
break;
}
}
}
}
int primo(int num)
{
int i,cont;
cont=0;
for(i=1;i<=num;i++)
{
if(num%i==0)
{
cont++;
}
}
if(cont==2)
return(1);
else
return(0);
}

18. 16
int primomayor(int num)
{
int i,pm;
for(i=1;i<=num;i++)
{
if(primo(i))
pm=i;
}
return(pm);
}
int mcdconv(int a, int b)
{
int pma,pmb; // El primo divisor mayor de a y el de b
int pmab; // El mayor entre los primos divisores entre pma pmb.
int i; // La variable contador de los ciclos for
int coca,cocb; // El cociente de la división de a / factor primo
// El cociente de la división de a / factor primo
int mcd; // La variable que al final obtiene el mcd entre a y b
// Por la multiplicación de factores comunes con menor
// exponente.
int conta,contb; // El contador de divisiones de a entre un factor.
// El contador de divisiones de b entre un factor.
int mencontab; // El menor entre conta y contb.
pma=primomayor(a);
Aplicando el método convencional para
obtener el mayor de los términos comunes
elevados al menor exponente.

19. 17
pmb=primomayor(b);
pmab=pma>pmb?pma:pmb;
coca=a;
cocb=b;
mcd=1;
for(i=pmab;i>=1;i--)
{
if(primo(i))
{
if((coca%i==0)&&(cocb%i==0))
{
conta=0;
while(coca%i==0)
{
coca=coca/i;
conta++;
}
contb=0;
printf("n");
while(cocb%i==0)
{
cocb=cocb/i;
Si dos términos no tienen MCD entre si se obtendrá
como resultado el número uno.
Usamos un contador al elegir dos
números el cual irá contando sus
divisores entre ambos hasta
alcanzar lo que realmente se
quiere que es hallar el MCD
entre dos términos si es que
existen, de lo contrario será 1.
Por eso debe haber un contador
para el valor a y un contador para
el valor b.

20. 18
contb++;
}
mencontab=conta<contb?conta:contb;
mcd*=pow(i,mencontab);
}
}
}
return(mcd);
}
int exp(int x)
{
int i,cont;
for(i=2;i<=x;i++)
{
cont = 0;
while(x % i == 0)
{
x = x/i;
cont+=1;
if(x % i == 1)
Como está en un ciclo Do while, y al
presionar cualquier tecla me devuelve
al menú.
Y asíobtendremos
bien aplicado lo
que es el método
convencional para
conocer el MCD
entre los valores a
y b elevados a su
menor exponente.

21. 19
{
break;
}
}
if(cont != 0)
{
printf("%d^%d ",i, cont);
}
}
}
Análisis General: Como se ha venido analizando dicho programa se puede mencionar que
la primera función y segunda función (método de Euclides y método iterativo nos funcionó
correctamente), pero en la tercera función tuvimos la mayor dificultad ya que inicialmente
representaba su MCD, Pero no mostraba su común elevado al menor exponente como lo pide
el problema, lo cual es una de las mayores problemas presentadas en la solución de esta
situación, tal y como se muestra en la siguiente captura, pero a medida de buscar soluciones
se logró el objetivo de ordenar y mejorar el programa, el cual nos permitió calcular el MCD,
aplicando el método convencional y mostrando sus términos comunes elevados al menor
exponente, logrando todo esto con el apoyo incondicional del facilitador de dicho módulo de
programación.
A continuación se presentan algunas capturas al momento de correr el programa:
Y así con la elaboración de este
programa, podemos conocer el
MCD aplicando los tres
métodos solicitados.
MCD EUCLIDES
MCD ITERATIVO
MCD CONVENCIONAL

22. 20
CAPTURA REPRESENTATIVA SOBRE LAS OPCIONES DEL PROGRAMA
CAPTURA SOBRE LA APLICACIÓN DEL MÉTOD DE EUCLIDES
CAPTURA SOBRE LA APLICACIÓN DEL MÉTODO ITERATIVO
CAPTURA SOBRE LA APLICACIÓN DEL MÉTODO CONVENCIONAL

23. 21
Problema 3
El nombre de un arreglo se puede usar como argumento de un subprograma, de esta forma
un arreglo completo puede ser pasado al subprograma. Para esto, en la llamada al
subprograma, el nombre del arreglo debe aparecer solo, sin corchetes o índices, como un
argumento actual dentro de la llamada. El correspondiente argumento formal (en la
definición del subprograma) se escribe de la misma manera pero debe ser declarado como un
arreglo dentro de la declaración de argumentos formales (parámetros). En el caso de
prototipos de funciones, el nombre del arreglo es opcional y debe agregarse un par de
corchetes vacíos. El siguiente programa documenta con comentarios en su código, la
información general y algunas particularidades del mismo.
//Programa: Manejo de arreglo unidimensional de 10 números enteros.
//Autor: Dr. Harold Ramiro Gutiérrez Marcenaro.
//Fecha de creación: Domingo, 14 de julio de 2019.
//Fecha de última modificación: Martes, 16 de julio de 2019.
//Objetivo: Permite llenar, imprimir y encontrar el mayor número en
// un arreglo de 10 enteros.
//Contexto: Utilizado para Guía Didáctica nro. 3 del Doctorado en
// Matemática Aplicada, segunda cohorte, FAREM-Carazo.
//Directrices al preprocesador
#include<stdio.h>
#include<conio.h>
//Definición de constantes
#define TAM 10

24. 22
//Prototipos de funciones
voidllenar(int []);
voidimprimir (int []);
int mayor(int []);
void mensaje(); // subprograma como procedimiento que no recibe nada
// ni devuelve nada, puede ponerse u omitirse el void
// entre los paréntesis.
//Variables globales
int i; /*Esta variable i es global o sea que puede ser utilizada por
cualquier otra función de aquí en adelante; pero si una función
tiene declarada otra variable i, esa función no hará uso de la i
global, sino de su i local.*/
voidmain()
{
intmay,A[TAM]; //La declaración del arreglo es local a la función main.
clrscr();
printf("De los datos del arreglon");
llenar(A);
mensaje();
printf("nnLos elementos le%cdos son : n",161);
imprimir(A);
mensaje();
may=mayor(A);
printf("nnEl mayor de los n%cmeros introducidos es %d",163,may);
printf("nnSaliendo del programa.");
mensaje();
}

25. 23
void llenar(int A[])
{
int i; // La variable i es local a la función llenar.
for(i=0;i<TAM;i++)
{
printf("nA[%d] = ",i+1);
scanf("%d",&A[i]);
}
return;
}
voidimprimir(int A[])
{
int i; /*Esta variable i es distinta a la variable i de la función llenar
y distinta a la variable i global.*/
printf("n");
for(i=0;i<TAM;i++)
{
printf("%d ",A[i]);
}
printf("n");
//puede omitirse la sentencia return cuando el subprograma no devuelve
//nada.
}
int mayor(int A[])
{
intmay;
may=A[0];
for(i=1;i<TAM;i++) //Aquí la función mayor hace uso de la
{ //variable i global
if (A[i]>may)

26. 24
{
may=A[i]; //Se actualiza la variable may cada vez que
} //se encuentra un nuevo valor mayor al actual.
}
return(may);
}
void mensaje() //Aquí también puede escribirse u omitirse el void
//entre los paréntesis.
{
printf("nnPresione una tecla para continuar...");
getch();
}
Solución
Expanda el programa con los siguientes procesos, en el orden que se orientan:
a) Calcular e imprimir la suma de los elementos del arreglo A.
b) Copiar todos los elementos del arreglo A en un nuevo arreglo B, pero en orden
inverso.
c) Imprimir el arreglo B.
d) Sumar cada elemento del arreglo A con su correspondiente elemento del arreglo B,
y almacenarlos en las posiciones respectivas de un tercer arreglo C
(C[0]A[0]+B[0]).
e) Imprimir el arreglo C.
f) Invierta sobre sí mismo el orden de los elementos del arreglo C.
g) Imprimir el nuevo arreglo C.
#include<stdio.h>
#include<conio.h>

27. 25
//Definición de constantes
#define TAM 10
int A[TAM], B[TAM], C[TAM];
//Prototipos de funciones
voidllenar(int []);
voidimprimir (int []);
int mayor(int []);
void mensaje(); // subprograma como procedimiento que no recibe nada
// ni devuelve nada, puede ponerse u omitirse el void
// entre los paréntesis.
intcalcSuma(int []);
voidnuevoB(int []);
voidnuevoC(int []);
voidinvertidoC(int []);
voidmostrar();
//Variables globales
int i; /*Esta variable i es global o sea que puede ser utilizada porcualquier otra función deaquí
en adelante; pero si una funcióntiene declarada otra variable i, esa función no hará uso de la
iglobal, sino de su i local.*/
voidmain()
{
intmay,sum; //La declaración del arreglo es local a la función main.
clrscr();
printf("De los datos del arreglon");
llenar(A);
mensaje();

28. 26
printf("nnLos elementos le%cdos son : n",161);
imprimir(A);
mensaje();
may=mayor(A);
printf("nnEl mayor de los n%cmeros introducidos es %d",163,may);
mensaje();
sum = calcSuma(A);//inciso a), suma de los elementos del arreglo A
printf("nnLa suma de los n%cmeros introducidos es %d",163,sum);// Se lee b)
mensaje();//
printf("nnLos elementos de B[] son: n");/*inciso b) y c) */
nuevoB(B);//Nuevo arreglo B, salido del arreglo A en forma invertida
mensaje();
printf("nnLos elementos de C[] son: n");
nuevoC(C);/*inciso d y e, suma de la correspondencia de arreglo A y B, como un nuevo
arreglo C*/
mensaje();
printf("nnLos elementos de C[] invertidos sobre si mismo son: n");/*inciso f y g, invertir
los elementos del mismo arreglo C*/
mostrar();// función que permite decir que está a punto de salir del programa
printf("nnSaliendo del programa.");
mensaje();
}
/*--------------------------------------------------------*/
void llenar(int A[])
{
int i; // La variable i es local a la función llenar.
for(i=0;i<TAM;i++)
{
printf("nA[%d] = ",i+1);
scanf("%d",&A[i]);
}

29. 27
return;
}
void imprimir(intnomArreglo[])
{
int i; /*Esta variable i es distinta a la variable i de la función llenar
y distinta a la variable i global.*/
printf("n");
for(i=0;i<TAM;i++)
{
printf("%d ",nomArreglo[i]);
}
printf("n");
//puede omitirse la sentencia return cuando el subprograma no devuelve
//nada.
}
int mayor(int A[])
{
intmay;
may=A[0];
for(i=1;i<TAM;i++) //Aquí la función mayor hace uso de la
{ //variable i global
if (A[i]>may)
{
may=A[i]; //Se actualiza la variable may cada vez que
} //se encuentra un nuevo valor mayor al actual.
}
return(may);
}
//Incisoa

30. 28
intcalcSuma(intA[])
{
intsuma = 0;
for(i=0;i<TAM;i++)
{
suma+= A[i];
}
return(suma);
}
//Incisob
voidnuevoB(int B[])
{
for(inti=1;i<=TAM;i++)
{
B[i - 1] = A[TAM - i];
}
//Incisoc
imprimir(B);
}
//Inciso d
voidnuevoC(intC[])
{
for(inti=0;i<TAM;i++)
{
C[i] = A[i] + B[i];

31. 29
}
//Incisoe
imprimir(C);
}
//Inicisof
voidinvertidoC(intC[])
{
inti, aux;
for(i=0;i<TAM/2;i++)
{
aux = C[i];
C[i]= C[TAM - 1 - i];
C[i - 1 - i]= aux;
}
}
//Incisog
voidmostrar()
{
for(inti = 0;i < TAM; i++)
{
printf("%d ", C[i]);
}
}

32. 30
void mensaje() //Aquí también puede escribirse u omitirse el void
//entre los paréntesis.
{
printf("nnPresione una tecla para continuar...");
getch();
}

33. 31
II. Conclusiones
Una vez analizado los problemas y después de encontrar un modelo matemático adecuado a
las incógnitas de los mismos y obtenido la información, que de ellos se generó conjuntamente
con el análisis de cada programa, se procede a presentar las siguientes conclusiones, de
acuerdo a los logros, dificultades y aprendizajes obtenidos:
Se destaca la importancia de este trabajo tanto en su condición de investigación así como
de la contribución al fortalecimiento en proceso de aprendizaje en estudiantes
doctorandos.
Se hizo uso de las instrucciones de control (for, while, do – while, switch, break,
return), funciones, recursividad y arreglos. Además de las estructuras selectivas como
los bucles se introdujeron unas dentro de otras.
Dentro de las principales dificultades, se destaca el factor tiempo, para profundizar más
a fondo, también dificultad para encontrar un algoritmo de solución, principalmente en
el segundo problema, en la parte del cálculo del MCD, por el método convencional.
Siguiendo con lo descrito anteriormente, se presentaron los errores relacionados a la
sintaxis, lógicos y tiempo de ejecución.
Se realizó revisión documental vinculada con el tema de investigación, en diferentes
fuentes, tales como libros, sitios web y videos. Ello permitió fundamentar cada problema
hasta llegar a la elaboración y resolución de los mismos.
Como aprendizaje por descubrimiento (Heurística), se constató que la programación
modular es una de las técnicas fundamentales de la programación. Y que se apoya en el
diseño descendente y en la filosofía de "divide y vencerás”. Además, como
descubrimiento se encontró el algoritmo adecuado para evaluar y ejecutar de manera
satisfactoria.

34. 32
Bibliografía
Aguilar, L. J. (2003). Fundamentos de programación-Algoritmos, Estructuras de datos y
Objetos (Segunda ed.). Madrid: McGRAW-HILL/INTERAMERICANA DE
ESPAÑA, S. A. U.
Gottfried, B. S. (2005). PROGRAMACION EN C (Segunda ed.). Madrid, España:
McGRAW-HILLIINTERAMERICANA DE ESPAÑA, S. A. U.