PROYECTO DE LOGICA DE PROGRAMACION: PRIMER CORTE

JOSE MIGUEL MUÑOZ RODRIGUEZ 20142032051

Trabajo presentado como requisito parcial de la asignatura de LOGICA DE

PROGRAMACION al docente:

Adán Beltrán

UNIVERSIDAD DISTRITAL FRANCISCO JOSE DE CALDAS

FACULTAD DE MEDIO AMBIENTE Y RECURSOS NATURALES

PROYECTO CURRICULAR INGENIERIA TOPOGRAFICA

BOGOTA D.C

2015
 Contenido
INTRODUCCION .................................................................................................... 3
OBJETIVOS ............................................................................................................ 4
OBJETIVO GENERAL ......................................................................................... 4
OBJETIVOS ESPECIFICOS................................................................................ 4
1. ALGORITMO PARA CONOCER SI DADOS TRES PUNTOS FORMAN UN
TRIANGULO RECTANGULO.................................................................................. 5
1.1 PSEUDOCODIGO ......................................................................................... 5
1.2 DIAGRAMA DE FLUJO ................................................................................. 6
1.3 ALGORITMO EN VISUAL BASIC .................................................................. 7
1.4 PRUEBAS...................................................................................................... 8
2. ALGORITMO PARA CONOCER (n) NUMEROS PRIMOS............................... 9
2.1 PSEUDOCODIGO ......................................................................................... 9
2.2 DIAGRAMA DE FLUJO ............................................................................... 10
2.3 ALGORITMO EN VISUAL BASIC ................................................................ 11
2.4 PRUEBAS.................................................................................................... 12
ALGORITMO PARA CONOCER CIERTA INFORMACION AL INGRESAR
DISTINTAS TEMPERATURAS ............................................................................. 13
3.1 PSEUDOCODIGO ....................................................................................... 13
3.2 DIAGRAMA DE FLUJO ............................................................................... 13
3.3 ALGORITMO EN VISUAL BASIC ................................................................ 14
3.4 PRUEBAS.................................................................................................... 15
ALGORITMO PARA CONOCER SI UN NUMERO ES ABUNDANTE ................... 16
4.1 PSEUDOCODIGO ....................................................................................... 16
4.2 DIAGRAMA DE FLUJO ............................................................................... 17
4.3 DIAGRAMA EN VISUAL BASIC .................................................................. 18
4.4 PRUEBAS.................................................................................................... 19
CONCLUSIONES.................................................................................................. 20
 INTRODUCCION

En el presente informe se da a conocer cuatro algoritmo realizados en clase, estos

consisten en: primero, al tener tres puntos cualesquiera saber si los datos dados
forman un triángulo, triangulo rectángulo o si no es un triángulo, el siguiente
algoritmo consiste en conocer tantos números primos, el proceso número tres es
en la que al ingresar distintas temperaturas, conocer en que rango se encuentra,
finalmente se da a saber un método en el cual se puede saber si un número es
abundante o no. Para cada uno de estos procesos esta su respectivo
seudocódigo, diagrama de flujo, algoritmo en visual Basic y para concluir las
pruebas finales.
 OBJETIVOS

OBJETIVO GENERAL

 Dar a conocer distintos algoritmos que conllevan diferentes procesos para

la elaboración del fin dado

OBJETIVOS ESPECIFICOS

 Conocer el manejo adecuado del programa usado para efectuar estos

algoritmos, para esto se usara: visual Basic
 Reconocer los distintos procesos en los que se muestran condicionales
anidados, ciclos, definición de variables, etc.
 Identificar a partir de los seudocódigos los diagramas de flujo para un mejor
entendimiento del problema.
 Poder colocar nuestro algoritmo hecho en oficina a la practica en visual
Basic.
 1. ALGORITMO PARA CONOCER SI DADOS TRES PUNTOS FORMAN UN
TRIANGULO RECTANGULO

1.1 PSEUDOCODIGO

1. INICIO
2. Leer x0, y0, x1, y1, x2, y2
3. q= 0
4. w=0
5. s=0
6. T1= false
7. a= Raíz (((x1-x0)^2)+((y1-y0)^2))
8. b= Raíz (((x1-x2)^2)+((y1-y2)^2))
9. c= Raíz (((x0-x2)^2)+((y0-y2)^2))
10. z=((((X0 * Y1) + (X1 * Y2) + (X2 * Y0)) - ((Y0 * X1) + (Y1 * X2) + (Y2 * X0))) /
2)
11. Si ((a > b) and (a > c))
11.1. q = SQRT((a * a) + (b * b)))
11.2. si (a == q)
11.2.1. t1 = true
11.2.2. Imprimir "Los 3 puntos forman un triángulo Rectángulo"
12. si ((b > a) and (b > c))
12.1. w = SQRT ((a * a) + (c * c))
12.2. si (b == w)
12.2.1. t1 = true
12.2.2. Imprimir "Los 3 puntos forman un triángulo Rectángulo”
13. Si ( c > a and c > b)
13.1. s = Raíz ((a * a) + (b * b))
13.2. si (c == s)
13.2.1. t1 = true
13.2.2. Imprimir "Los 3 puntos forman un triángulo Rectángulo"
14. Si (z > 0 and t1 == false)
14.1. Imprimir "Los 3 puntos forman un triángulo"
14.2. Si no
14.2.1. si (t1 == false)
14.2.1.1. Imprimir "Los 3 puntos no forman un triángulo "
15. FIN
1.2 DIAGRAMA DE FLUJO

INICIO

x0, y0, x1,

y1, x2, y2

q= 0
w=0
s=0
T1= false
a= Raíz (((x1-x0)^2)+((y1-y0)^2))
b= Raíz (((x1-x2)^2)+((y1-y2)^2))
c= Raíz (((x0-x2)^2)+((y0-y2)^2))
z= ((((X0 * Y1) + (X1 * Y2) + (X2 * Y0)) - ((Y0 * X1) + (Y1
* X2) + (Y2 * X0))) / 2)
1.3 ALGORITMO EN VISUAL BASIC

namespace Triangulos
{
public partial class frmTriangulos : Form
{
public frmTriangulos()
{
InitializeComponent();
}

private void cmdMostrarafirmacion_Click(object sender, EventArgs e)

{
lstSalida.ClearSelected();
int XO = Convert.ToInt32(txtvalorX0.Text);
int YO = Convert.ToInt32(txtvalorY0.Text);
int X1 = Convert.ToInt32(txtvalorX1.Text);
int Y1 = Convert.ToInt32(txtvalorY1.Text);
int X2 = Convert.ToInt32(txtvalorX2.Text);
int Y2 = Convert.ToInt32(txtvalorY2.Text);
double a = (Math.Sqrt(((Y1 - YO) * (Y1 - YO)) + ((X1 - XO) * (X1 -
XO))));
double b = (Math.Sqrt(((Y1 - Y2) * (Y1 - Y2)) + ((X1 - X2) * (X1 -
X2))));
double c = (Math.Sqrt(((YO - Y2) * (YO - Y2)) + ((XO - X2) * (XO -
X2))));
double z = ((((XO * Y1) + (X1 * Y2) + (X2 * YO)) - ((YO * X1) + (Y1 *
X2) + (Y2 * XO))) / 2);
double q = (0);
double w = (0);
double s = (0);
bool t1 = false;
if ((a > b) && (a > c))
{
q = (Math.Sqrt((a * a) + (b * b)));
if (a == q)
{
t1 = true;
lstSalida.Items.Add("Los 3 puntos forman un triangulo
Rectangulo");
}
}

if ((b > a) && (b > c))

{
w = (Math.Sqrt((a * a) + (c * c)));
if (b == w)
{
t1 = true;
lstSalida.Items.Add("Los 3 puntos forman un triangulo
Rectangulo");
}
}
 if ( c > a && c > b)
{
s = (Math.Sqrt((a * a) + (b * b)));
if (c == s)
{
t1 = true;
lstSalida.Items.Add("Los 3 puntos forman un triangulo
Rectangulo");
}
}

if (z > 0 && t1 == false)

{
lstSalida.Items.Add("Los 3 puntos forman un triangulo");
}
else
{
if (t1 == false)
lstSalida.Items.Add("Los 3 puntos no forman un triangulo
");
}
}

}
}

1.4 PRUEBAS
 2. ALGORITMO PARA CONOCER (n) NUMEROS PRIMOS

2.1 PSEUDOCODIGO

1. Inicio
2. Leer n
3. I contadorPrimos=0
iDivisor
iNumero = 1
4. MQ (icontadorPrimos < n)
4.1 iNumero++
4.2 EsPrimo= True
4.3 iDivisor = 2
4.4 MQ ( iDivisor < iNumero and Es primo = True)
4.4.1 r = iNumero % iDivisor
4.4.2 si ( r == 0)
4.4.2.1 EsPrimo=False
4.4.2.2 iDivisor ++
4.5 Si (EsPrimo=True)
4.5.1 iContadorPrimos ++
4.5.2 Imprimir “iNumero”
5. Fin
2.2 DIAGRAMA DE FLUJO
INICIO

Ingresa
rn

IcontadorPrimos =
0
INumero = 1

idivisor

iContadorPrimos
no <n

si
Inumero++

Es primos =True

Idivisor = 2

si
Idivisor <
Inumero
no
and Es esPrim
primo= True o=
True
no
no
si iNumero
r = inumero % idivisor r == 0

si
esPrimo = False FIN
2.3 ALGORITMO EN VISUAL BASIC

namespace Numeros_Primos
{
public partial class frmnumerosprimos : Form
{
public frmnumerosprimos()
{
InitializeComponent();
}

private void listBox1_SelectedIndexChanged(object sender, EventArgs e)

{

private void cmdmostrarprimos_Click(object sender, EventArgs e)

{
lstSalida.Items.Clear();
int n = Convert.ToInt16(txtingresarnumero.Text);

int iContadorPrimos = 0;
int iDivisor;
int iNumero = 1;
while (iContadorPrimos < n)
{
iNumero++;
Boolean Esprimo = true;
iDivisor = 2;

while ((iDivisor < iNumero) && (Esprimo == true))

{
int r = iNumero % iDivisor;
if (r == 0)
{
Esprimo = false;
}

iDivisor++;
}

if (Esprimo == true)
{
iContadorPrimos++;
lstSalida.Items.Add(iNumero);
}

}
}
}
2.4 PRUEBAS
 ALGORITMO PARA CONOCER CIERTA INFORMACION AL INGRESAR
DISTINTAS TEMPERATURAS

3.1 PSEUDOCODIGO

1. INICIO
2. Leer a
3. si (a>=100)
4. imprimir ("Temperatura muy alta – Mal funcionamiento")
4.1. Si no
4.1.1. Si (a>=91 && a < 100)
4.1.2. Imprimir ("Rango normal")
4.1.3. Si no
4.1.4. if (a >= 51 && a < 91)
4.1.4.1. Imprimir ("Bajo el rango normal");
4.1.4.2. Si no
4.1.4.2.1. if (a <= 50)
4.1.4.2.2. Imprimir ("Muy frío – Apague el equipo");
5. FIN

3.2 DIAGRAMA DE FLUJO

3.3 ALGORITMO EN VISUAL BASIC

namespace Temperaturas
{
public partial class frmtemperaturas : Form
{
public frmtemperaturas()
{
InitializeComponent();
}

private void cmdmostrarresultado_Click(object sender, EventArgs e)

{
lstSalida.Items.Clear();
int n = Convert.ToInt32(txtvalorn.Text);
if (n >= 100)
{
lstSalida.Items.Add("Temperatura muy alta – Mal funcionamiento");

}
else
{
if (n >= 91 && n < 100)
{
lstSalida.Items.Add("Rango normal");
}
else
{
if (n >= 51 && n < 91)
{
lstSalida.Items.Add("Bajo el rango normal");
}
else
{
if (n <= 50)
{
lstSalida.Items.Add("Muy frío – Apague el equipo");
}
}
}
}
}

private void lstSalida_SelectedIndexChanged(object sender, EventArgs e)

{

}
}
}
3.4 PRUEBAS
 ALGORITMO PARA CONOCER SI UN NUMERO ES ABUNDANTE

4.1 PSEUDOCODIGO

1. Inicio
2. Leer n
3. iContador = 1
s=0
4. MQ (iContador <=n/2)
4.1 Si ( n % iContador = 0)
4.1.2 s = s + iContador
4.1.3 iContador ++

4.2 Si ( s > n)

4.2.1 imprimir = “Es abundante”

4.3 Sino

4.3.1 imprimir “No es abundante”

5. Fin
4.2 DIAGRAMA DE FLUJO

Inicio

Leer n

iContador = 1
Es
abundante
S=0

si

iContador No es
n/2 S> No abundante
n

si
n% si S=s+
iContador iContador

No iContador ++
iContador ++

FI
N
4.3 DIAGRAMA EN VISUAL BASIC

namespace Numero_abundante
{
public partial class frmNumeroabundante : Form
{
public frmNumeroabundante()
{
InitializeComponent();
}

private void listBox1_SelectedIndexChanged(object sender, EventArgs e)

{

private void cmdMostrarafirmacion_Click(object sender, EventArgs e)

{
lstSalida.Items.Clear();
int n = Convert.ToInt32(txtingresarn.Text);
int iContador = 1;
int s = 0;
int x = n / 2;
int r = n % iContador;
while (iContador <= x)
{
if (r == 0)
{
s = s + iContador;
iContador++;
}

}
{
if (s > n)
{
lstSalida.Items.Add("Es numero abundante");
}
else
{
lstSalida.Items.Add("No es numero abundante");
}
}
}
}
}
4.4 PRUEBAS
 CONCLUSIONES

Al finalizar de reconocer, digitar y hacer los algoritmos se logro dar a

conocer distintos algoritmos con diferente metodología, además se dio un
manejo adecuado del programa usado para estos fines, igualmente se
identificaron y se procesaron los problemas dados en diagramas de flujo
para así mismo poder usar estos algoritmos en la vida laboral y estudiantil.