INSTITUTO POLITCNICO NACIONAL

ESCUELA SUPERIOR DE FISCA Y MATEMTICAS

PROYECTO 3 PARCIAL

INTEGRANTES DEL EQUIPO:

GARCA MANDUJANO FERNANDO ANGEL
MORENO GALLEGOS ULISES ALDAIR
ROJAS SALINAS JESSICA MICHELLE
VALENCIA CARMONA DAVID OSVALDO

MATERIA: INTRODUCCIN A LA INFORMATICA

PROFESOR: JOAQUIN IBARRA BAEZ

GRUPO: 1MM1
08 DE ENERO DE 2016

ndice

Pg.
Introduccin..3
Objetivo............4
Justificacin del programa.....5
Funcin: La circunferencia y sus problemas..6
Funcin: La elipse y sus problemas........7
Funcin: Prueba de primalidad.8
Funcin: Clculo de mximo comn divisor y mnimo comn
mltiplo.....9
Funcin: Conjetura de Goldbach para un nmero9
Funcin: Simplificacin de fracciones...10
Funcin: Raz ensima de la unidad.10
Cdigo del programa11
Conclusin..32

Introduccin

Actualmente nos encontramos en un mundo lleno de tecnologa y

vanguardia que exige alta competitividad, la utilizacin de los avances
tecnolgicos para hacer la vida ms fcil y eficiente es una realidad.
Es por esto que la creacin de programas que resuelvan de forma
rpida y eficiente los problemas que se presentan constantemente en
la sociedad, facilitan enormemente la obtencin de estos resultados,
adems de que se asegura, sean correctos y precisos.
Llevar el problema real a un cdigo y lenguaje que permita ser
programado y que adems considere todos los casos posibles que se
puedan presentar implica una habilidad que se adquiere con la
prctica y es necesaria para la solucin de programas de mayor
complejidad.
Haciendo nfasis en la obtencin de esta habilidad, se desarroll un
programa de apoyo referente a la matemtica que nos permite obtener
resultados de problemas que constantemente se presentan y que el
mtodo de solucin manual posee cierto grado de complejidad.

Objetivo:

Obtener la solucin de problemas que se han presentado en el

transcurso de la trayectoria acadmica de una forma instantnea y
eficiente, haciendo uso de conocimientos bsicos en algebra y
geometra, adems de conocimientos de programacin bsica,
logrando as un aprendizaje ms eficiente al contar con esta
herramienta que proporciona apoyo para el estudio de los temas que
aborda, adems del perfeccionamiento de los conocimientos
previamente adquiridos sobre programacin en lenguaje C.

Justificacin del proyecto

El presente proyecto est formado por una compilacin de pequeos
subprogramas cada uno resolviendo un cuestionamiento de un tema en particular.
Los temas que aborda son:
La circunferencia y sus problemas
La elipse y sus problemas
Prueba de primalidad
Calculo de mximo comn divisor y mnimo comn mltiplo
Conjetura de Goldbach para un numero
Simplificacin de fracciones
Raz ensima de la unidad
El proyecto posee un men principal donde se despliegan mediante el uso de
switch() case los temas que aborda, proporcionando as, al usuario, la facultad de
elegir el que necesite en ese momento.
El desarrollo del cdigo comienza con la declaracin de las libreras de acuerdo a
las necesidades del programa, se utiliz stdio.h, que contiene las definiciones
de macros, las constantes, las declaraciones de funciones y la definicin
de tipos usados por varias operaciones estndar de entrada y salida; tambin se
utiliz math.h que contiene las funciones matemticas necesarias para las
operaciones, usando sqrt() para obtener races cuadradas y pow(x,y) para las
potencias;
la
librera
conio.h
se
us
por
las
funciones
de
getch() que hace que el programa cierre hasta que se presione una tecla, cls para
borrar los datos de la pantalla y comenzar con unos nuevos; y windows.h para
crear el inicio de nuestro programa.
Posteriormente se declaran las variables, estas son de carcter global, se hace
nfasis en esto, pues existen las locales que estn contenidas en las funciones de
temas que anteriormente se citaron y que solo tienen su funcionamiento en su
respectiva parte del cdigo, adems de las funciones prototipo mediante void que
contienen el cdigo de los temas desarrollados.
Inicialmente, y por nica ocasin al ejecutar el programa, se muestra en pantalla
una sencilla animacin con texto de color intermitente, que, posteriormente
desaparece y da lugar al men inicial. Esto se logra de una manera muy fcil,

recurriendo a la funcin Sleep(), contenida en la cabecera Windows.h, que forma

parte de la misma interfaz de aplicacin del sistema Windows. El funcionamiento
de Sleep() es bsico, el argumento numrico (entre parntesis) especifica un
retardo en milisegundos del flujo del programa.
A travs del bucle while, se genera 6 ciclos definidos por el decremento en 1, de
un variable de tipo entero definida en 6. Por cada ciclo sucedido se imprimir
cierto texto, cambiar el color de texto utilizando la funcin system(color n)
definida en la biblioteca estndar de C y se generar un retardo por 800
milisegundos. Finalmente, la pantalla se limpia con system(cls) y se mostrar el
men inicial.
A continuacin se desarrolla la justificacin y se explica cada opcin del men.

Funcin: La circunferencia y sus problemas

El estudio de la circunferencia es sin duda un conocimiento que no debemos dejar
pasar, pues gracias a los conocimientos que te proporciona, es ms fcil el estudio
de temas ms complicados de geometra analtica e inclusive de algunas otras
materias alusivas a la matemtica, es por eso que se ha decidido crear un
programa que ayude a la comprensin de este tema, adems de que proporcione
respuestas a problemas que el usuario tenga, haciendo posible la comparacin de
los resultados y verificacin de la respuesta correcta, as el usuario pobra hacer
manualmente las operaciones y obtener sus resultados para posteriormente
hacerlo con el programa y comparar si sus resultados son correctos, o tambin
obtener rpidamente los resultados sin necesidad de hacerlo manual.
El presente programa nos permite obtener mediante un men diferentes tipos de
datos de acuerdo a lo que desee el usuario, una opcin del men es para obtener
definiciones relacionadas con la circunferencia y as crear las bases para el fcil
manejo y entendimiento de las dems opciones del programa. La segunda opcin
del men engloba la explicacin de las ecuaciones de la circunferencia,
nuevamente bases para el manejo del programa. La tercera opcin del men
hace referencia a encontrar proporcionando diversos tipos de datos con los que se
cuente, tres puntos de la misma, equidistantes del centro, el centro y el radio, el
centro y un punto en ella; el radio, el centro y las ecuaciones de la circunferencia
segn sea el caso.
La cuarta opcin del men sirve para hallas la ecuacin de la recta tangente a una
circunferencia, proporcionando el punto de tangencia conocido y la ecuacin
general de la circunferencia. Por ltimo la opcin cinco de nuestro men
proporciona la posibilidad de encontrar la longitud de una circunferencia
proporcionando el radio.

Descripcin de variables
b es la variable del men principal, a esta se le asigna un numero entero de
acuerdo a la opcin que el usuario desea elegir.
c es la variable del men interno que corresponde a definiciones de la
circunferencia, al igual que el caso anterior, el usuario decide que numero entero
del men desea ingresar de acuerdo a lo que necesita.
e es la variable del men interno que corresponde a las opciones con las cuales
podemos hallar la ecuacin de la circunferencia, su centro y su radio, el usuario
elige una de las opciones que se despliegan de acuerdo a los datos con los que
cuenta.
r representa el radio de la circunferencia.
h representa la abscisa en la coordenada de centro de la circunferencia
k representa la ordenada en la coordenada del centro de la circunferencia dada.
r2 representa el radio de la circunferencia elevado al cuadrado.
En la ecuacin usual tenemos la suma de dos binomios elevados al cuadrado.
Al elevar al cuadrado obtenemos que x2 + 2xh + h2 y y2 + 2yk + k2, as utilizamos
j=2*h
l=2*k
y s para expresar la suma de todos los cuadrado que no contuvieran incgnitas y o
x
s= k2+h2+r2

Funcin: La elipse y sus problemas

La herramienta de apoyo elipse es un programa desarrollado para una mejor
comprensin destinado a personas que se encuentran en el mbito estudiantil en
la materia de geometra analtica. Su elaboracin radica en que en algunos
procesos para la solucin de una elipse se pueden llegar a tornar confusos en
ciertos aspectos provocando un mal aprendizaje o un conocimiento momentneo
sobre el tema abordado, sin embargo con el tipo tutorial que se ofrece, se
pretende dar a conocer de manera ms detallada las partes que estn contenidas
en la elipse, as como la forma en que se obtienen, y la misma solucin a las
ecuaciones que el usuario ingrese a la herramienta aportada.

El programa est constituido por dos opciones de solucin de ecuaciones tales

que satisfacen la mayora de los diferentes problemas que se podran presentar al
momento de querer dar solucin a las ecuaciones de una elipse. Es algo posible
que el usuario se encuentre con algn caso en el que no pueda conseguir la
solucin a su problema, esto es debido a que es un caso de razonamiento, y es
necesario que el usuario cuente con ms conocimientos acerca de este tema, ya
que existen casos en los que el usuario tiene un problema que al momento de
ingresar los datos en esta forma de apoyo piensa que no tiene los requisitos para
su funcionalidad, pero es esencial que se verifiquen detalladamente todos los
datos otorgados al usuario, esto con el fin de alcanzar la forma en que su
problema se pueda ingresar en el aporte que se brinda con la realizacin del
software elipse.

Todos los valores obtenidos al momento de dar la solucin a la variedad de

ecuaciones otorgadas por parte del usuario son las distintas partes que dar
conformacin a las elipses, las mismas soluciones estn especificadas de forma
escrita y as mismo en expresin matemtica, por lo que es una herramienta de
fcil comprensin y establecida para un buen aprendizaje, destinado a la
comunidad con necesidad y/o inters hacia la geometra analtica.

Funcin: Prueba de primalidad

Saber si un nmero es primo o conocer todos sus divisores resulta una tarea
complicada, envuelta en algoritmos mecnicos que se vuelven tediosos e inclusive
proclive a obtener fallas, y ms an cuando el nmero en cuestin es
posiblemente compuesto por factores primos cada vez ms grandes.
Basndose en una de las propiedades de los nmeros primos: se dice que x es
primo si sus nicos divisores son 1 y x. De sta manera se disea el algoritmo
para el programa.
Primeramente se lee el nmero entero x, a travs de una sentencia condicional se
comprueba que sea mayor que 1 (1 no es primo), posteriormente se utiliza
iteraciones (ciclo for) desde 2 hasta el nmero x, utilizando una variable de
incremento en 1 por ciclo. Esta variable (i), es comparada de dos formas con x, se
hace uso de dos mtodos (diferente que (!=) e igual que (==)) de la siguiente
manera: si i es diferente de x y el residuo de dividir x en i es 0 entonces el

nmero de divisores aumenta en 1 y este i se imprime en pantalla, completando

as x 3 ciclos. En caso de que el nmero de divisores (t) sea 0, entonces se
imprimir que x es un nmero primo.

Funcin: Clculo de mximo comn divisor y

mnimo comn mltiplo
La obtencin del M.C.D. y el m.c.m. de dos nmeros enteros es una tarea extensa,
y excesivamente atenuante, proceso en el cul es sencillo confundirse y perder
tiempo til.
El proceso ideado es realmente la implementacin del conocido algoritmo de
Euclides para la obtencin del Mximo Comn Divisor de dos nmeros enteros
positivos, y el hecho (cuya demostracin se obvia) de que la divisin del producto
de los dos nmeros entre su mximo comn divisor es el mnimo comn mltiplo.
El algoritmo de Euclides consiste en divisiones consecutivas hasta llegar a un
residuo 0 iniciando como dividendo el mayor de los dos nmeros entre el menor,
as alternando hasta obtener el residuo 0, siendo el ltimo dividendo el mximo
comn divisor.
Primeramente se leen ambos nmeros, y a travs de dos condicionales se
determinan el nmero mayor m1 y el menor m2 (si ambos son iguales, entonces
cualquiera de esos son los nmeros buscados). Se inicia un bucle condicional (do
- while), donde se realiza el clculo de residuo entre m1 y m2, asignando valores
de m1 por m2 y m2 por el residuo. El bucle se cierra hasta que el residuo sea 0,
as, se muestra el ltimo m1 como mximo comn divisor. Posteriormente se
calcula el mnimo comn mltiplo obteniendo el producto entre el par de nmeros
iniciales dividido entre el m1 (mximo comn divisor), mostrando el resultado en
pantalla.

Funcin: Conjetura de Goldbach para un nmero

La conjetura fuerte de Christian Goldbach (an no demostrada) versa as: Todo
numero par mayor que 2 puede escribirse como suma de dos nmeros primos.
Si bien, no posee una utilidad prctica, es claramente interesante, y funciona como
una introduccin agradable al estudio de la teora de nmeros y la fascinacin por
los nmeros primos.
Se inicia el algoritmo leyendo y comprobando el nmero x en cuestin (par y
mayor a dos) con un condicional. Posteriormente se generan y guardan (en un
arreglo unidimensional de longitud x) todos los primos hasta el numero x,
utilizando dos bucles for, El primer ciclo analiza cada nmero j desde 2 hasta x

1, dentro de ste se encuentra el otro ciclo, contando los divisores de j desde 2

hasta j al ser 0 el residuo j entre i. Cuando el nmero de divisores desde 2 hasta j
1 de un j es 0, significa que es primo, por lo que se almacena en el arreglo
primos[ y ], donde y es el nmero de primos, iniciando en 0, aumentado en 1 por
cada nuevo ingresado.
Posteriormente, con el arreglo de primos listo, se consigue comprobar a travs a
dos ciclos for, uno desde j igual a 1 hasta y (creciendo) el otro (anidado) desde i
igual a y hasta 1 (decreciendo), con la condicin: primos[ j ] + primos[ i ] es igual a
el nmero ingresado, entonces se imprime la combinacin de nmeros,
cumplindose as la conjetura.

Funcin: Simplificacin de fracciones

El proceso de simplificacin fracciones consiste en factorizar numerador y
denominador de un racional, obteniendo un factor cuyo denominador y numerador
sea el mximo comn mltiplo de ambas cantidades, por lo que se forma un 1 de
factor, as simplificando la expresin para su cmodo manejo. Si bien, la tarea en
si no es complicada, al tratarse de cantidades grandes, se vuelve tediosa y
proclive a errores.
Primeramente se lee ambos nmeros, numerador M y denominador N, se elige el
menor de ellos. Posteriormente, a travs del control de flujo do while y un while
anidado, se identifican los divisores comunes de ambos, al considerar el residuo 0
de M entre i y N entre i, al encontrar un divisor, el ciclo se rompe, se imprime en
pantalla el resultado en forma racional de M/i entre N/i.
El proceso continua hasta que i es igual al menor de ambas cantidades.

Funcin: Raz ensima de la unidad

La raz ensima de un nmero es aquel valor que al elevarse a la potencia cuyo
ndice indica la raz se obtiene el mismo nmero.
La raz quinta de 32 es 2 porque al elevar 2 a la quinta potencia (2^5 = 2 * 2 * 2 * 2
* 2) se obtiene 32.
Si el ndice de la raz es par (cuadrada, cuarta, sexta...), habr dos resultados
posibles (el positivo y el negativo). No se puede sacar raz par de un nmero
negativo en los nmeros reales.

10

Si el ndice de la raz es impar (cbica, quinta, sptima...), habr solo un resultado.

Si el nmero es positivo, el resultado ser positivo; si es negativo, ser negativo.
As como la raz cuadrada es lo que se multiplica dos veces para tener el valor
original, y la raz cbica es lo que se multiplica tres veces para tener el valor
original, la raz n-sima es lo que se multiplica n veces para tener el valor original.
Para empezar declaramos las libreras, las cuales son stdio.h y math.h, despus el
int main de cada programa, seguimos con declarar las variables, para empezar
tenemos 2 de tipo float y 6 de tipo entero, despus imprimimos y registramos el
radicando, el ndice de la raz, declaramos tres variables ms, para por cualquier
otro tipo de raz con caractersticas diferentes
Ahora pasamos con la parte de las matemticas, damos a M igual al redondeo y a
N como la aproximacin, le pedimos al ordenador que nos d un nmero a
calcular su raz, damos un do para tener varias opciones, y damos un if si y solo
si, la primera es que si M es menos que N, M ser igual al menor, pero si no se
cumple N ser el menor, damos el nmero mayor que, el cual es el dos, poner
while para dar la condicin, despus de la condicin dada, damos otro if para
cumplir condicin ms, el mltiplo debe ser igual que i, se le suma uno ms cada
vez hasta que alcancemos un valor prximo
Como tenemos a i en 2, si la fraccin se puede dividir lo va a ser, puesto que hay
mltiplo como lo indica el programa, y as sucesivamente con el while, si no es 2,
ser 3, o 5 etc.

Cdigo del programa

#include <stdio.h>
#include <math.h>
#include<conio.h>
#include<windows.h>
void prime(void);
void mdmm(void);
void circunferencia(void);
void goldbach(void);
void fraccion(void);

11

void raiz(void);
void elipse(void);
int g,b;
int main(){
int i;
system("cls");
i=7;

printf("\n\t\t\t\t ----------------------------------------------");
printf("\n\t\t\t\t*|| INSTITUTO POLITECNICO NACIONAL
||*");
printf("\n\t\t\t\t*|| ESCUELA SUPERIOR DE FISICA Y MATEMATICAS ||*");
printf("\n\t\t\t\t*|| INGENIERIA MATEMATICA - 1MM1
||*");
printf("\n\t\t\t\t*|| INTRODUCCION A LA INFORMATICA
||*");
printf("\n\t\t\t\t*|| PROYECTO PARA TERCER PARCIAL
||*");
printf("\n\t\t\t\t ----------------------------------------------");
while(--i){
Sleep(800);
if(i==1){
system("color 6");
}
if(i==2){
printf("\n\t\t\t*Ulises Aldair Moreno\n");
system("color 2");
}
if(i==3){
printf("\n\t\t\t*David Valencia Carmona\n");
system("color 3");
}
if(i==4){
printf("\n\t\t\t*Fernando Angel Garcia Mandujano\n");
system("color 4");
}
if(i==5){
printf("\n\t\t\t*Jessica Michelle Rojas Salinas\n");
system("color 5");
}
if(i==6){

12

printf("\n\t\t\tDesarrollado por: \n");

system("color 7");
}
}
do{
system("cls");
system("color f");
printf("\n\t\t\t\t\t **MENU PRINCIPAL**");
printf("\n\t_____________________________________________________
__________________________________");
printf("\n\n\t\tIntroduzca el numero de acuerdo a lo que desea hacer:\n\n");
printf("\t\t1.- La circunferencia y sus problemas.\n");
printf("\t\t2.- La elipse y sus problemas.\n");
printf("\t\t3.- Prueba de primalidad.\n");
printf("\t\t4.- Calculo de MCD y mcm de dos numeros.\n");
printf("\t\t5.- Conjetura de Goldbach para un numero.\n");
printf("\t\t6.- Simplificar una fraccion.\n");
printf("\t\t7.- Calcular raiz n-esima.\n");
printf("\t\t8.- Salir.\n\n");
printf("\t\tOpcion: ");
scanf("%d", &b);
switch(b){
case 1:
circunferencia();
break;
case 2:
elipse();
break;
case 3:
prime();
break;
case 4:
mdmm();
break;
case 5:
goldbach();
break;
case 6:
fraccion();

13

break;
case 7:
raiz();
break;
default:
printf("\t\tEntrada no valida\n\n");
break;
}
system("cls");
printf("\n\n\t________________________________________________________
_____________________________________________");
printf("\n\t\t\t*Presione 1 para volver al menu inicial u otra tecla para salir del
programa: ");
scanf("%d",&g);
}while(g==1);
}
void circunferencia(){
float a, p, A, B, R, D, E, F, mtg, G, V, matriz3x4[3][4],C,C1,C2;
int b,c,d,e, r, h, k, r2, s, j, l, i, o, radio, u, w;
char x,y;
do{
system("cls");
system("color 0B");
printf("\n\t\t\t\tLa Circunferencia");
printf("\n\t__________________________________________________________
___________________");
printf("\n\n\t\tIntroduzca el numero de acuerdo a lo que desea hacer:\n\n");
printf("\t\t1.- Obtener alguna definicion referente a cincunferencia.\n");
printf("\t\t2.- Ver la forma de las ecuaciones de una cincunferencia.\n");
printf("\t\t3.- Hallar la ecuacion, centro y radio de alguna circunferencia.\n");
printf("\t\t4.- Hallar la ecuacion de la recta tangente a alguna
circunferencia.\n");
printf("\t\t5.- Hallar la longitud de alguna circunferencia.\n");
printf("\t\t6.- Salir.\n\n");
scanf("%d", &b);
if(b==1)
{

14

system("cls");
system("color 0D");
printf("\nQue definicion deseas obtener?\n\n");
printf("1.- Circunferencia\n");
printf("2.- Centro de la circunferencia\n");
printf("3.- Radio de la circunferencia\n");
printf("4.- Tangente a la circunferencia\n\n");
scanf("%d", &c);
if(c==1){
system("cls");
system("color AF");
printf("\n\tCircunferencia:\n");
printf("Conjunto de todos los puntos del plano que equidistan de un punto
fijo.\n\n");
}
if(c==2){
system("cls");
system("color 2D");
printf("\n\tCentro de la circunferencia:\n");
printf("Es el punto fijo del que equidistan todos los puntos de la
circunferencia.\n");
printf("Se expresa como C(h,k)\n \tDonde h es la abscisa y k es la
ordenada.\n\n");
}
if(c==3){
system("cls");
system("color BF");
printf("\n\tRadio de la circunferencia:\n");
printf("Distancia del centro a los puntos de la circunferencia.\nSe simboliza
por la letra r y siempre es positivo.\n\n");
}
if(c==4){
system("cls");
system("color 85");
printf("\n\tTangente a la circunferencia:\n");
printf("Es una recta que toca a la circunferencia en un solo punto.\n\n");
}
}

15

if(b==2){
system("cls");
system("color F5");
printf("\n\tEcuaciones:\n\n\n");
printf("Forma usual, ordinaria o canonica\n\n");
printf("(x-h)^2+(y-k)^2= r^2\n");
printf("Donde\tr es el radio\n");
printf(" \t(x,y) es un punto de la circunferencia\n");
printf(" \t(h,k) es el centro de la circunferencia\n\n\n\n");
printf("Ecuacion General\n\n");
printf("(x^2)+(y^2)+Dx+Ey+F=0\n\n");
}
if(b==3) {
system("cls");
system("color 09");
printf("\nSeleccione con que datos cuenta\n\n");
printf("1.- Centro y Radio\n");
printf("2.- Centro y punto de la circunferencia\n");
printf("3.- Los puntos extremos de un diametro de la circunferencia\n");
printf("4.- Tres puntos de la circunferencia\n");
scanf("%d", &e);
if(e==1){
system("cls");
printf("Introducir el valor del radio r\n");
scanf("%d", &r);
printf("Introduce las coordenadas del centro C(h,k)\n");
printf("h=");
scanf("%d", &h);
printf("k=");
scanf("%d", &k);
r2=pow(r,2);
printf("La ecuacion usual de la circunferencia es:(x-%d)^2 + (y%d)=%d\n", h,k,r2);
j=2*h;
l=2*k;
s= pow(h,2)+pow(k,2)-r2;
printf("La ecuacion general de la circunferencia es:
x^2+y^2+%dx+%dy+%d=0", j,l,s);
}
if(e==2){

16

system("cls");
printf("Introduce las coordenadas del centro C(h,k)\n");
printf("h=");
scanf("%d", &h);
printf("k=");
scanf("%d", &k);
printf("Introduce las coordenadas del punto P(x,y)\n");
printf("x=");
scanf("%d", &i);
printf("y=");
scanf("%d", &o);
radio=sqrt(pow((i-h),2)+pow((o-k),2));
printf("El radio es:%f", radio);
printf("La ecuacion usual de la circunferencia es: (x-%d)^2+(y%d)^2=%d", h,k, pow(radio,2));
j=2*h;
l=2*k;
s= pow(h,2)+pow(k,2)-r2;
printf("La ecuacion general de la circunferencia es:
x^2+y^2+%dx+%dy+%d=0", j,l,s);
}
if(e==3){
system("cls");
printf("Introduce las coordenadas del primer punto P(x,y)\n");
printf("x=");
scanf("%d", &i);
printf("y=");
scanf("%d", &o);
printf("Introduce las coordenadas del segundo punto P(x,y)\n");
printf("x=");
scanf("%d", &u);
printf("y=");
scanf("%d", &w);
r=(sqrt(pow(u-i,2)+pow(w-o,2)))/2;
printf("El radio de la circunferencia que tiene su diametro en esos
dos puntos es:%f\n",r);
h=(i+u)/2;
k=(o+w)/2;
printf("El centro de la circunferencia es:\n");

17

printf("C(%f, %f)",h,k);
printf("La ecuacion usual de la circunferencia proporcionada
es:\n");
r2=pow(r,2);
printf("(x-%f)^2+(y-%f)^2=%f",h, k,r2);
}
if(e==4) {
//tres puntos de la circunferencia
system("cls");
printf("Introduce las coordenadas del primer punto\n");
printf("x=");
scanf("%f", &matriz3x4[0][0]);
printf("y=");
scanf("%f", &matriz3x4[0][1]);
matriz3x4[0][2]=1;
matriz3x4[0][3]=pow(matriz3x4[0][0],2)+pow(matriz3x4[0][1],2);
printf("Introduce las coordenadas del segundo punto\n");
printf("x=");
scanf("%f", &matriz3x4[1][0] );
printf("y=");
scanf("%f", &matriz3x4[1][1] );
matriz3x4[1][2]=1;
matriz3x4[1][3]=pow(matriz3x4[1][0],2)+pow(matriz3x4[1][1],2);
printf("Introduce las coordenadas del tercer punto \n");
printf("x=");
scanf("%f", &matriz3x4[2][0] );
printf("y=");
scanf("%f", &matriz3x4[2][1] );
matriz3x4[2][2]=1;
matriz3x4[2][3]=pow(matriz3x4[2][0],2)+pow(matriz3x4[2][1],2);
//Resolviendo sistema con base en metodo de Gauss-Jordan
matriz3x4[0][1]=matriz3x4[0][1]/matriz3x4[0][0];
matriz3x4[0][2]=matriz3x4[0][2]/matriz3x4[0][0];
matriz3x4[0][3]=matriz3x4[0][3]/matriz3x4[0][0];
matriz3x4[0][0]=matriz3x4[0][0]/matriz3x4[0][0];// Se hace 1
//---------------------------------------------matriz3x4[1][1]=((matriz3x4[1][0])*matriz3x4[0][1])+matriz3x4[1][1];
matriz3x4[1][2]=((matriz3x4[1][0])*matriz3x4[0][2])+matriz3x4[1][2];

18

matriz3x4[1][3]=((matriz3x4[1][0])*matriz3x4[0][3])+matriz3x4[1][3];
matriz3x4[1][0]=((matriz3x4[1][0])*matriz3x4[0][0])+matriz3x4[1][0];// Se hace 0
matriz3x4[2][1]=((matriz3x4[2][0])*matriz3x4[0][1])+matriz3x4[2][1];
matriz3x4[2][2]=((matriz3x4[2][0])*matriz3x4[0][2])+matriz3x4[2][2];
matriz3x4[2][3]=((matriz3x4[2][0])*matriz3x4[0][3])+matriz3x4[2][3];
matriz3x4[2][0]=((matriz3x4[2][0])*matriz3x4[0][0])+matriz3x4[2][0];// Se hace 0
//------------------------------------------------------------------matriz3x4[1][2]=matriz3x4[1][2]/matriz3x4[1][1];
matriz3x4[1][3]=matriz3x4[1][3]/matriz3x4[1][1];
matriz3x4[1][1]=matriz3x4[1][1]/matriz3x4[1][1];// Se hace 1
//---------------------------------------------matriz3x4[0][2]=((matriz3x4[0][1])*matriz3x4[1][2])+matriz3x4[0][2];
matriz3x4[0][3]=((matriz3x4[0][1])*matriz3x4[1][3])+matriz3x4[0][3];
matriz3x4[0][1]=((matriz3x4[0][1])*matriz3x4[1][1])+matriz3x4[0][1];// Se hace 0
matriz3x4[2][2]=((matriz3x4[2][1])*matriz3x4[1][2])+matriz3x4[2][2];
matriz3x4[2][3]=((matriz3x4[2][1])*matriz3x4[1][3])+matriz3x4[2][3];
matriz3x4[2][1]=((matriz3x4[2][1])*matriz3x4[1][1])+matriz3x4[2][1];// Se hace 0
//------------------------------------------------------------------matriz3x4[2][3]=matriz3x4[2][3]/matriz3x4[2][2];//Solucion variable
z
matriz3x4[2][2]=matriz3x4[2][2]/matriz3x4[2][2];
//------------------------------------------------------------------matriz3x4[0][3]=((matriz3x4[0][2])*matriz3x4[2][3])+matriz3x4[0][3];//Solucion variable x
matriz3x4[0][2]=((matriz3x4[0][2])*matriz3x4[2][2])+matriz3x4[0][2];
matriz3x4[1][3]=((matriz3x4[1][2])*matriz3x4[2][3])+matriz3x4[1][3];//Solucion variable y

19

matriz3x4[1][2]=((matriz3x4[1][2])*matriz3x4[2][2])+matriz3x4[1][2];
//------------------------------------------------------------------D=matriz3x4[0][3];
E=matriz3x4[1][3];
F=matriz3x4[2][3];
printf("\nEl centro de la circunferencia que pasa por los 3 puntos
proporcionados es:\n");
C1=(D/2);
C2=(E/2);
printf("\tC(%f,%f)\n", C1,C2);
R=(sqrt((pow(D,2))+(pow(E,2))-(4*F)))/2;
printf("\nEl radio de la circunferencia que pasa por los 3 puntos
proporcionados es:\n");
printf("\nr=%f", R);
}
}
if(b==4){
system("cls");
system("color F3");
printf("\nIntroduce las coordenadas del punto que se conoce\n");
printf("x=");
scanf("%d", &b);
printf("y=");
scanf("%d",&c);
printf("Recordemos que la ecuacion de la circunferencia es de la
forma:\n");
printf("\tx^2 + y^2 + Dx + Ey+ F = 0 \n\n");
printf("Introduce el valor de D\n");
scanf("%f",&D);
printf("Introduce el valor de E\n");
scanf("%f",&E);
printf("Introduce el valor de F\n");
scanf("%f",&F);
A=-1*(D/2);
B=-1*(E/2);
printf("\nEl centro de la circunferencia proporcionada es:\n");
printf("\tC(%.2f,%.2f)\n\n", A, B);
R=(sqrt(pow(D,2)+pow(E,2)-(4*F)))/2;
printf("El radio de la circunferencia proporcionada es:\n");
printf("\tr=%.2f\n\n", R);

20

mtg=((b-A)/(c-B));
G=1*c;
V=1*b;
printf("La ecuacion de la recta tangente a la circunferencia proporcionada
es:\n");
printf("y-%.0f=%.2f(x-%.0f)", G, mtg, V);
}
if(b==5){
system("cls");
system("color F8");
printf("\n\nIntroduce el radio de la circunferencia\n\n");
printf("r=");
scanf("%f", &a);
p=2*3.1416*a;
printf("\n\n\nLa longitud de la circunferencia dada es: %.3f\n",p);
}

printf("\n\n\t________________________________________________________
_____________________");
printf("\n\t\t\t*Presione 1 para repetir u otra tecla para salir: ");
scanf("%d", &d);
}while(d==1);
return 0;
}
void elipse (void){
int a[5],i,j,s,h;
float b[5],d[6],e[2],f,k[3],n[6],m[10];
//SE DAN A CONOCER LAS OPCIONES DISPONIBLES PARA EL USUARIO
//PONEMOS EJEMPLIFICACIONES PARA UNA MEJOR COMPRENSION
do{
system("cls");
printf("\n\t\tLA ELIPSE");
printf("\n\t\t_________________________________________________________
___\n\n");
printf("\t\tObtener los valores de la elipse cuando se tienen las ecuaciones:\n");
printf("\n\t\t1.-De la forma:\n\t\t n1x^2 + n2y^2 + n3x + n4y + n5 = n6 \n");
printf("\t\tEjemplo:\n\t\t3x^2 + 5y^2 + -6x + 20y + 8 = 0 \n\n");

21

printf("\n\t\t2.-De la forma:\n\t\t ((x - a1)^2 / a2)+((y - a3)^2 / a4)= a5\n");

printf("\t\tEjemplo:\n\t\t((x - 0)^2 / 3)+((y - 0)^2 / 8)= 1 \n\n");
printf("\t\tOpcion: ");
//SEGUN SEA LA OPCION QUE ELIJA EL USUARIO SERA LA PARTE EN LA
QUE SIGA EL PROGRAMA
scanf("%d",&s);
switch (s){
case 1:{
//SE ESTABLECERAN LOS PASOS PARA LLEGAR A LA ECUACION QUE ESTA
EN LA OPCION DOS DE ESTA HERRAMIENTA
printf("LA ECUACION DEBE INTRODUCIR DE LA SIGUIENTE
MANERA\n");
printf(" n1x^2 + n2y^2 + n3x + n4y + n5 = n6 \n");
for (i=1;i<=6;i++){
printf("ingrese el valor n%d\n",i);
scanf("%f",&n[i]);
}
m[2]=n[3]/n[1];
m[4]=n[4]/n[2];
m[5]=n[6]-n[5];
//ORGANIZAMOS LOS VALORES QUE SE INGRESARON PARA LA
COMPRENSION DEL USUARIO
printf("Juntamos los terminos con la misma literal\n");
printf("%fx^2 + %fx + %fy^2 + y%f + %f = %f\n\n",n[1],n[3],n[2],n[4],n[5],n[6]);
printf("Factorizamos los terminos y despejamos el coeficiente independiente (si
hay alguno)\n");
printf("%f(x^2 + %fx) + %f(y^2 + %fy) = %f\n\n",n[1],m[2],n[2],m[4],m[5]);
printf("Factorizamos nuevamente los terminos de tal forma que obtengamos un
binomio al cuadrado\n");
printf("Sumamos los valores del lado derecho de la ecuacion para que esta siga
cumpliendose ");
printf("yaque se agregaron numeros del lado izquierdo al hacer el binomio al
cuadrado\n");
m[6]=m[2]/2;
m[7]=m[4]/2;
m[8]=m[5]+n[1]*pow(m[6],2)+n[2]*pow(m[7],2);

22

printf("%f(x + %f)^2 + %f(y + %f)^2 = %f\n\n",n[1],m[6],n[2],m[7],m[8]);

printf("Por ultimo dividimos los terminos entre el termino independiente resultante a
la derecha\n");
m[9]= m[8]/n[1];
m[10]= m[8]/n[2];
printf("((x + %f)/ %f ) + ((y + %f)/ %f ) = 1",m[6],m[9],m[7],m[10]);
//SE DA UNA INDICACION AL USUARIO PARA QUE NO SEA NECESRIA UNA
DOBLE COMPRENSION DE CODIGO EN EL PROGRAMA
printf("\n Para seguir con la solucion de la ecuacion continue en la opcion -2-");
break;
}
case 2:{
printf("LA ECUACION DEBE INTRODUCIR DE LA SIGUIENTE
MANERA\n");
printf("((x - a1)^2 / a2)+((y - a3)^2 / a4)= a5\n\n");
for (i=1;i<=5;i++){
printf("ingrese el valor a%d\n",i);
scanf("%d",&a[i]);
}

d[1]=sqrt(a[2]);
d[2]=sqrt(a[4]);
//DAMOS UNA SERIE DE CONDICIONES EN EL CODIGO YA QUE EXISTEN
DOS POSIBLES SOLUCIONES A LOS PROBLEMAS
//PERO SOLO UNA ES VALIDA
if (a[2]<a[4]){
d[3]=sqrt(pow(d[2],2)-pow(d[1],2));
}
else {
d[3]=sqrt(pow(d[1],2)-pow(d[2],2));
}

if (a[2]<a[4]){
e[1]=a[3]+d[3];
e[2]=a[3]-d[3];

23

}
else {
e[1]=a[1]+d[3];
e[2]=a[1]-d[3];
}
// SE DAN A CONOCER LAS PARTES DE LA ELIPSE CON EXPLICACIONES
printf("LOS VALORES DE LA ELIPSE SON LOS SIGUIENTES\n\n");
printf("Si el valor mas grande se encuentra debajo de x^2");
printf(" entonces es una parabola Horizontal\n De lo contrario es Vertical\n");
printf("El valor de -a- estara definido por la raiz del valor del numero mayor\n");
printf("El valor de -b- estara definido por la raiz del valor del numero menor\n");
printf("El valor de -c- se define como la raiz del valor de -a- al cuadrado menos -bal cuadrado\n ");
printf("\nTenemos que...\n");
if (a[2]<a[4]){
printf("Es una elipse vertical\n");
printf("a=%f\n",d[2]);
printf("b=%f\n",d[1]);
}
else {
printf("Es una elipse horizontal\n");
printf("a=%f\n",d[1]);
printf("b=%f\n",d[2]);
}
printf("c=%f\n",d[3]);
printf("El eje mayor esta definido como el doble del valor de a\n");
printf("El eje menor esta definido como el doble del valor de b\n");
if (a[2]<a[4]){
d[4]=2*d[2];
printf("\nEje mayor = %f \n",d[4]);
d[5]=2*d[1];
printf("Eje menor = %f \n",d[5]);
}
else {
d[4]=2*d[1];
printf("\nEje mayor = %f \n",d[4]);

24

d[5]=2*d[2];
printf("Eje menor = %f \n",d[5]);
}
d[6]=2*d[3];
printf("Asi mismo La distancia entre los focos se define por el doble de c\n");
printf("La distancia entre los focos = %f\n\n",d[6]);
printf("Los vertices se definen segun el tipo de la elipse\n");
printf("Si es horizontal se le suma y resta el valor de -a- al eje de las x\n");
printf("Si es vertical se le suma y resta el valor de -a- al eje de las
y\n");
printf("Las coordendas mencionadas se tienen al obtener el centro\n");
if (a[2]<a[4]){
k[1]=a[3]+d[2];
k[2]=a[3]-d[2];
printf("Los vertices son:\nv1 ( %d , %f)\nv2 ( %d , %f)\n\n",a[1],k[1],a[1],k[2]);
k[3]= (2*(pow(d[1],2)))/d[2];
printf("El Lado Recto = %f\n ",k[3]);
}
else {
k[1]=a[1]+d[1];
k[2]=a[1]-d[1];
printf("Los vertices son:\nv1 ( %f , %d)\nv2 ( %f , %d)\n\n",k[1],a[3],k[2],a[3]);
k[3]= (2*(pow(d[2],2)))/d[1];
printf("El lado recto es la cuerda que pasa por un foco y es perpendicular al
eje focal");
printf(">Nos puede ayudar a trazar la elipse< ");
printf("El Lado Recto = %f\n ",k[3]);
}

printf("\n\n");
printf("El centro es algo facil de localizar\n Se obtiene al extraer el numero sumado
a ");
printf("la x al cuadrado para ubicar el eje de las x, y asi mismo la coordenada de
las y se obtiene");
printf("al extraer el numero sumado a la y elevada al cuadrado (en la ecuacion)\n");

25

printf("El centro es (%d , %d)\n\n",a[1],a[3]);

printf("Similar que los vertices, los focos se localizan al sumar y restar el valor de c-");
printf(" al eje de las x's o de las y's' segun sea el tipo de elipse\n");
if (a[2]<a[4]){
e[1]=a[3]+d[3];
e[2]=a[3]-d[3];
printf("Los focos son:\nf1 ( %f , %f)\nf2 ( %f , %f)\n\n",a[1],e[1],a[1],e[2]);
}
else {
e[1]=a[1]+d[3];
e[2]=a[1]-d[3];
printf("Los focos son:\nf1 ( %f , %f)\nf2 ( %f , %f)\n\n",e[1],a[3],e[2],a[3]);
}
printf("La exentricidad nos indica que tan apegada a una circunferencia esta la
elipse\n");
printf("Si el valor se acerca al 1 indica que es casi una circunferencia");
printf("La exentricidad siempre es menor que 1 y mayor que 0");
if (a[2]<a[4]){
f=d[3]/d[2];
printf("\nLa exentricidad es = %f/%f\n o %f\n",d[3],d[2],f);
}
else {
f=d[3]/d[1];
printf("La exentricidad es = %f/%f\n o %f",d[3],d[1],f);
printf("Gracias por utilizar esta herramienta de apoyo estudiantil!!! :D");
}
break;
}
default:{
printf("\n\n >>Opcion no valida<< \n\n");
break;
}
}

26

printf("\n\n\t________________________________________________________
_____________________");
printf("\n\t\t\t*Presione 1 para repetir u otra tecla para salir: ");
scanf("%d",&g);
}while(g==1);
return 0;
}
void prime(void){
int x,i,t;
do{
system("cls");
printf("\n\tPrueba la primalidad del numero natural dado, si es
compuesto\n\tmostrara sus divisores.");
printf("\n\t__________________________________________________________
__\n\n");
printf("\t\tIntroduce el numero: ");
scanf("%d",&x);
t=0;
for(i=2;i<x;i++){
if(i!=x&&x%i==0){
t=t+1;
if(t==1){
printf("\t\tNo es primo, y sus divisores son:\n\n");
}
printf("\t\t%d",i);
printf("\n");
}
}
printf("\n");
if(x!=1&&t==0){
printf("\t\tEs primo.\n\n");
}
if(x==1){
printf("\t\tEl uno, por definicin, no es primo.\n\n");
}
printf("\n\n\t________________________________________________________
_____________________");

27

printf("\n\t\t\t*Presione 1 para repetir u otra tecla para salir: ");

scanf("%d",&g);
}while(g==1);
return 0;
}
void mdmm(void){
int x,y,m1,m2,r;
do{
mod:
system("cls");
printf("\n\tCalcula el maximo comun divisor y el maximo comun
multiplo\n\tdado dos numeros naturales.");
printf("\n\t__________________________________________________________
__\n\n");
printf("\t\tPrimer numero: ");
scanf("%i",&x);
printf("\t\tSegundo numero: ");
scanf("%i",&y);
if(x>y){
m1=x;
m2=y;
}
if(x<y){
m1=y;
m2=x;
}

r=m1%m2;
while(r!=0){
r=m1%m2;
m1=m2;
m2=r;
}
printf("\t\tEl maximo comun divisor es: %d\n",m1);
printf("\t\tEl minimo comun multiplo es: %d\n\n",(x*y)/m1);

28

printf("\n\n\t___________________________________________________
__________________________");
printf("\n\t\t\t*Presione 1 para repetir u otra tecla para salir: ");
scanf("%d",&g);
}while(g==1);
return 0;
}
void goldbach(){
do{
mod:
system("cls");
int x,y=0,j,i,a;
printf("\n\tTodo numero par mayor que 2 puede escribirse como suma de dos
numeros primos.");
printf("\n\n\t\t\t\t\t\tChristian Goldbach (1742)");
printf("\n\t__________________________________________________________
___________________");
printf("\n\n\n\t\tIntroduce un numero: ");
scanf("%d",&x);
int primos[x];
if(x<=2||x%2!=0){
printf("\n\n\n\t\t\tNumero no valido.\n\n ");
system("pause");
goto mod;
}
for (j=2;j<=x;j++){
a=0;
for(i=2;i<j;i++){
if(j%i==0)
a=1;
}
if (a==0){
y++;
primos[y]=j;
}
}
printf("\n\t\t\tLos primos hasta %d son: \n",x);
for(j=1;j<=y;j++){

29

printf("\t\t\t\t%d\n",primos[j]);
}
printf("\n");
for(j=1;j<=y;j++){
for(i=y;i>=1;i--){
if((primos[j]+primos[i])==x){
printf("\t\t\t\tUna posibilidad de suma es: %d + %d = %d,
entre %d primos.\n",primos[j],primos[i],x,y);
j=y+1;
}
}
}
printf("\n\n\t________________________________________________________
_____________________");
printf("\n\t\t\t*Presione 1 para repetir u otra tecla para salir: ");
scanf("%d",&g);
}while(g==1);
return 0;
}
void fraccion(){
int M,N,i,menor, multiplo, hay_multiplo;
do{
system("cls");
printf("\n\tSimplifica fracciones.");
printf("\n\t__________________________________________________________
___________________");
printf("\n\n\tIntroduzca el numerador: ");
scanf("%d", &M);
printf("\n\n\tIntroduzca el denominador: ");
scanf("%d", &N);
printf("\n\n\t%d/%d", M,N);
do {
if (M < N )
menor = M;

30

else
menor = N;
i=2;
hay_multiplo=0;
while (i <= menor && hay_multiplo == 0){
if (M % i == 0 && N % i == 0){
multiplo = i;
hay_multiplo = 1;
}
i++;
}
if (hay_multiplo == 1){
M=M/multiplo;
N=N/multiplo;
printf(" = %d/%d", M, N);
}
}while (hay_multiplo==1);

printf("\n\n\t________________________________________________________
_____________________");
printf("\n\t\t\t*Presione 1 para repetir u otra tecla para salir: ");
scanf("%d",&g);
}while(g==1);
return 0;
}
void raiz(){
float x;
float raiz,redondeo,y;
int aprox,M,N,i,menor, multiplo, hay_multiplo;
do{
system("cls");
printf("\n\tCalcula la raiz n-esima de un numero, representada en decimal y
racional.");
printf("\n\t__________________________________________________________
___________________");
printf("\n\n\tRadicando: ");

31

scanf("%f",&x);
printf("\n\n\tIndice raiz: ");
scanf("%f",&y);
aprox = pow(10,6);
raiz = pow(sqrt(pow(x,2)),1/y); /* La raz es exponente fraccionario */
redondeo = round(aprox*raiz);
if(x>=0)
printf("\n\n\tDecimal: %f",raiz);
else
printf("\n\n\tDecimal: %fi",raiz);
/*A partir de aqui es generar la representacion y simplificacin en forma
reacional*/
M = redondeo;
N = aprox;
if(x>=0)
printf("\n\n\tFraccion: %d/%d", M,N);
else
printf("\n\n\tFraccion: %di/%d", M,N);
do {
if (M < N )
menor = M;
else
menor = N;
i=2;
hay_multiplo=0;
while (i <= menor && hay_multiplo == 0){
if (M % i == 0 && N % i == 0){
multiplo = i;
hay_multiplo = 1;
}
i++;
}
if (hay_multiplo == 1){
M=M/multiplo;
N=N/multiplo;
if(x>=0)
printf(" = %d/%d", M, N);
else
printf(" = %di/%d", M, N);
}

32

}while (hay_multiplo==1);
printf("\n\n\t________________________________________________________
_____________________");
printf("\n\t\t\t*Presione 1 para repetir u otra tecla para salir: ");
scanf("%d",&g);
}while(g==1);
return 0;
}

33

Conclusin

Como resultado del proyecto presentado, es posible concluir que

mediante la realizacin de este, los conocimientos previamente
adquiridos en materia de programacin bsica fueron puestos a
prueba, logrando as, implementarlos exitosamente.
Cabe mencionar que adems de esto, estos conocimientos fueron
reforzados y complementados, gracias a la necesidad de la obtencin
de un cdigo que proporcionara respuestas adecuadas a los
problemas previamente elegidos, es decir, se realiz un anlisis sobre
los temas elegidos para posteriormente crear un algoritmo que diera
solucin y presentara los resultados de la forma requerida.

34