Separata Unidad 1 Aed Introduccion A La Estructura de Datos Estructura Condicionales Estructura
Separata Unidad 1 Aed Introduccion A La Estructura de Datos Estructura Condicionales Estructura
Facultad de Ingeniería de
Sistemas
Semestre: 2015-II
INDICE
PRIMERA UNIDAD TEMATICA
PRIMERA SEMANA
MARCO TEORICO
MARCO PRÁCTICO
Actividades.......................................................................................................... 29
SEGUNDASEMANA
MARCO TEORICO
TERCERA SEMANA
MARCO TEORICO
CUARTA SEMANA
MARCO TEORICO
ESTRUCTURA DE DATOS Y ARREGLOS
Importancia de las estructuras de datos….......................................................... 57
Logro
Comprende los principales conceptos de la programación y la forma
como trabajan los lenguajes de programación. Reconoce los distintos
elementos que conforman un programa.
Resumen
La labor de la programación consiste en instruir al computador sobre
como debe desa-rrollar un determinado proceso o tarea, para este fin
contamos con los Lenguajes de Programación que son softwares que
nos permiten escribir nuestros programas (Código fuente),
compilarlos (traducirlos a un lenguaje de máquina) y ejecutarlos.
Los datos pueden ser numéricos, Cadenas de texto y valores lógicos.
Los datos que son manejados por el computador pueden ser
almacenados temporalmente en variables durante el tiempo en que
se ejecuta el programa.
Podemos construir dos tipos instrucciones para que el computador las
obedezca (Instrucciones Aritméticas y Instrucciones lógicas). Las
instrucciones aritméticas pueden usar los siguientes operadores
matemáticos: +,-,*,/. Y las instrucciones lógicas son aquellas que nos
devuelven un valor true o false y son el resultado de comparaciones
hechas con los operadores de comparación (>,<, <=, >=, =)
1. CONCEPTO DE ALGORITMO
Es la secuencia de instrucciones o pasos que deben seguirse para resolver un
problema.
Características de un Algoritmo
Un algoritmo debe ser preciso e indicar el orden de realización de cada paso.
Un algoritmo debe estar definido. Si se sigue un algoritmo dos veces, se debe
obtener el mismo resultado cada vez.
Un algoritmo debe ser finito. Si se sigue un algoritmo, se debe terminar en
algún momento, o sea, debe tener un número finito de pasos.
Programar:
Es la acción de instruir o especificar a través de instrucciones o comandos a un
computador sobre cómo debe desarrollar una determinada labor o tarea. La labor
de la programación se desarrolla utilizando un Lenguaje de Programación.
Programa:
Serie de instrucciones que el computador debe ejecutar secuencialmente. Un
programa es desarrollado por un programador a través de un Lenguaje de
Programación. Un programa se puede encontrar en Código Fuente o Código
Ejecutable.
Compilar Un Programa:
La acción de compilar un programa es la de traducir el programa basado en
CODIGO FUENTE a un programa en CODIGO EJECUTABLE (o en código
binario), de esta forma el computador podrá entender el programa que fue
previamente escrito por el programador. Entonces todo programa para ser
ejecutado por el computador necesita ser compilador previamente.
3.A. Datos
El primer objetivo de toda computadora es el manejo de la información o datos.
Estos datos pueden ser las cifras de ventas de un supermercado o las
calificaciones e una clase.
Un dato es la expresión general que describe los objetos con los cuales opera
una computadora.
4.A. VARIABLE
Una variable es un espacio reservado en la memoria principal del computador
identificado por un nombre, contiene un valor que puede cambiar a lo largo del
programa.
Existe una serie de palabras reservadas las cuales tienen un significado especial
para Java y por lo tanto no se pueden utilizar como nombres de variables. Dichas
palabras son:
4.B. CONSTANTES
Una constante es una variable que recibe un valor inicial al momento de ser
declarada, y luego de esta no admite cambios, ni alteraciones a dicho dato.
Ejemplo:
int edad; //Declaración de la variable
edad=23; //Asignación de un dato hacia la variable edad
Los operadores más (+) y menos (-) unarios sirven para mantener o cambiar el
signo de una variable, constante o expresión numérica.
Ejemplo:
int total;
total=-12; //A la variable total se le asigna un dato numérico negativo
int x,y,z;
x=1; y=10; z=(x<y)?x+3:y+8;
System.out.println(z);
/= Divide y asigna
Operador Significa
== Igual que
< Menor que
<= Menor igual que
> Mayor que
>= Mayor igual que
!= Diferente
Ejemplo:
int x=10;
int y=12;
int z=15;
System.out.println(x<y && z>x); // Dos expresiones lógicas unidas por el
//conector lógico AND
Devuelve como resultado true por ambas comparaciones han dado verdadero.
4.D. EXPRESIONES
Ejemplo:
int x=32;
int y=12;
System.out.println(x<y); //Estamos visualizando el resultado de una
//Expresión Lógica
int a=32;
int b=12;
int c=4;
System.out.println(a<b && a<c); //Evalúa si a es menor que b y si a es
// menor que c, estas dos
expresiones
// lógicas están vinculadas con un
// operador lógico AND.
// El resultado final es FALSE
int a=32;
int b=12;
int c=4;
int d;
4. E Comentarios
Los comentarios son tremendamente útiles para poder entender el código
utilizado, facilitando de ese modo futuras revisiones y correcciones.
Además permite que cualquier persona distinta al programador original
pueda comprender el código escrito de una forma más rápida. Se
recomienda acostumbrarse a comentar el código desarrollado. De esta
forma se simplifica también la tarea de estudio y revisión posteriores.
Java interpreta que todo lo que aparece a la derecha de dos barras “//” en
una línea cualquiera del código es un comentario del programador y no lo
tiene en cuenta. El comentario puede empezar al comienzo de la línea o a
continuación de una instrucción que debe ser ejecutada. La segunda
forma de incluir comentarios consiste en escribir el texto entre los
símbolos /*…*/. Este segundo método es válido para comentar más de
una línea de código. Por ejemplo:
/* Esta segunda forma es mucho más cómoda para comentar un número elevado
de líneas ya que sólo requiere modificar
el comienzo y el final. */
Ejemplo:
int a;
a=345;
Ejemplo:
Objetivo del Problema: Hallar el Área de un Rectángulo
Entrada de Datos Proceso Salida de Información
- Altura (h) a=b*h - area (a)
- Base (b)
B. DISEÑO DEL ALGORITMO (Diagrama de flujo, Pseudocodigo)
Ahora que conocemos exactamente los procesos que tendremos que programar y
conocemos los datos que estarán siendo entregados y la información que
debemos generar como resultado del proceso, estamos en condiciones de
diseñar nuestra solución.
ALGORITMO:
Es el conjunto de instrucciones que se deben seguir secuencialmente a fin de
desarrollar un determinado proceso. Un algoritmo es construido por un
programador antes de codificar el programa en código fuente, como un prototipo
o ensayo a fin de garantizar la eficacia del proceso y de los resultados que
deriven de este.
INICIO
Leer:
b,h
a=b*h
Escribir
a
FIN
Pseudocódigo:
Es un lenguaje de especificación (descripción) de algoritmos. Generalmente se
escribe en el idioma natural del usuario, es muy semejante al código fuente de un
programa.
Se considera un primer borrador, dado que el pseudocódigo tiene que traducirse
posteriormente a un lenguaje de programación. El pseudocódigo no puede ser
ejecutado por el computador.
INICIO
Leer b,h
a=b*h
Escribir
a
FIN
/
/I
NGRESODEDAT
OS
b
=12;
h
=4;
/
/
PROCESODEDAT
OS
a
=b*
h;
//
SALIDADEINFORMACION
Syst
em.ou
t.
pr
int
l
n("
Elá
reaes
:"+a
);
}
}
Nota: Java si hace diferencia entre las mayúsculas y minúsculas, por lo que
debemos ser cuidados al escribir el código fuente, por lo general los nombres de
las clases siempre empiezan con mayúsculas.
Error de Ejecución: El programa puede ejecutarse, pero por un mal manejo del
programa o un ingreso indebido, el programa colapsa o cierra repentinamente,
estos tipos de errores deben evitarse y debe ser el programa quien pueda
controlarlos.
Todos estos tipos de errores deben examinarse antes de dar por concluido el
proceso de desarrollo del programa. De presentarse un error de lógica se debe
realizar un Feedback (Retroalimentación) y debemos volver al PASO Nro. 1
a. RECONOCER EL ENTORNO
Luego de descargar el instalador de la dirección antes mencionada e instalarlo en
nuestro equipo, Ud. podrá ingresar al programa a través del icono del programa,
semejante a este:
b. CREACION DE UN PROGRAMA
Para crear un programa, primero es necesario:
1. Crear un Proyecto
Pasos:
1. Acceda al Menu File / Escoja: New Project
2. Seleccione la categoría: General – Java Application
3. Botón Next
4. Coloque un nombre al proyecto:
}
}
3
5
6
Nota: La palabra reservada (int) como prefijo a una expresión aritmética permite
que solo se captura la parte entera de dicha operación. Ejemplo:
int c;
c=(int)n/100; // Divide el valor n entre 100, pero la variable c solo recibe
//la parte entera. Ejemplo: 353/100. El valor de c sería 3
INICIO
Leer:
n
c=(int) n/100
r=n%100
d=(int)r/10
u=r%10
Escribir
c,d,u
FIN
Pseudocódigo:
INICIO
Leer n
c=(entero)n/100
r=n % 100
d=(entero) r/10
u=r%10
Escribir
c,d,u
FIN
p
u b
li
ccl
assDesc
ompos
ic
ion{
p
u b
li
cst
ati
cvo
idmai
n(
Str
in
ga r
gs[
]
)
{
/
/DECLARACI
ONDEVARI ABLES
i
ntn,
c,
r,
d,
u;
/
/I
NGRESODEDAT
OS-
Est
osd
atoss
onc
apt
ura
dosc
omoSt
ri
ng
St
r
ingn
n=J
Opt
i
onPa
ne.
sho
wIn
put
Di
al
og(
"I
ngr
esen
úme
ro:
");
/
/LOSDATOSRECEPCI
ONADOSDEBERANSERCONVERTI
DOSAlTI
POQUECORRESPONDEN
n=I
nt
eger.
par
seI
nt
(nn)
;
//
PROCESODEDAT OS
c=(
in
t)
n /
100;
r=
n%1 00;
d=(
int
)r/
10;
u=r
%1 0;
//
SALIDADEI NFORMACION
Syst
em.out
.p
ri
n t
l
n("
Laci
f
race
ntenae
s:"+c)
;
Syst
em.out
.p
ri
n t
l
n("
Laci
f
radec
enaes:"+d
);
Syst
em.out
.p
ri
n t
l
n("
Laci
f
rauni
dades
:"+u)
;
}
}
Introducción a Java
Java surgió en 1991 cuando un grupo de ingenieros de Sun Microsystems trataron
de diseñar un nuevo lenguaje de programación destinado a electrodomésticos. La
reducida potencia de cálculo y memoria de los electrodomésticos llevó a desarrollar
un lenguaje sencillo capaz de generar código de tamaño muy reducido.
Debido a la existencia de distintos tipos de CPUs y a los continuos cambios, era
importante conseguir una herramienta independiente del tipo de CPU utilizada.
Desarrollaron un código “neutro” que no dependía del tipo de CPU y
electrodoméstico, el cual se ejecutaba sobre una “máquina hipotética o virtual”
denominada Java Virtual Machine (JVM). Era la JVM quien interpretaba el código
neutro convirtiéndolo a código particular de la CPU utilizada. Esto permitía lo que
luego se ha convertido en el principal lema del lenguaje: “Write Once, Run
Everywhere”. A pesar de los esfuerzos realizados por sus creadores, ninguna
empresa de electrodomésticos se interesó por el nuevo lenguaje.
Java como lenguaje de programación permitía desde aquel tiempo algo muy
singular: codificar en una plataforma (como por ejemplo Windows) y ejecutar la
misma aplicación en otra plataforma totalmente distinta (como por ejemplo Solaris),
¿Cómo podía lograrse esto? Gracias a que las aplicaciones ejecutables de Java no
dependen de un Sistema Operativo en particular, puesto que no se ejecutan
directamente sobre este. La tecnología Java dispone de una maquina virtual llamada
JVM (Java Virtual Machine) sobre la cual se ejecutan las aplicaciones, por lo que no
interesa el sistema operativo que este activo en el equipo y es esta máquina virtual
la que ejecuta la aplicación y no el CPU de nuestro equipo, característica que le da a
las aplicaciones JAVA la libertad de ejecutarse en cualquier equipo.
B. Es un lenguaje OpenSource
Java a diferencia de otros lenguajes de programación tiene su código fuente
abierto, es decir se encuentra a disposición de que cualquier persona pueda
explorar la manera como han sido programadas los diferentes clases internas de
Java, también es posible que el programador añada funcionalidades a Java y
personalice Java a sus necesidades.
C. Es un lenguaje Multiplataforma
Tal como lo hemos explicado anteriormente Java puede desarrollarse en una
plataforma y puede ejecutarse en otra plataforma distinta sin ningún problema,
gracias a que las aplicaciones corren en su propia máquina virtual (JVM) lo que
permite que las aplicaciones no dependan exclusivamente de un sistema
operativo y equipo en especial.
TRABAJO PRÁCTICO 1
“Si deseas ser grande, empieza a crecer desde hoy... Esfuérzate por llegar
lejos.”
Logro
Diferencia y determina cuando utilizar la estructura condicional SI
(Simple y Doble) en la construcción de sus programas.
Resumen
La estructura si (estructura IF) es una estructura condicional que
evalúa una expresión lógica, de ser el resultado verdadero realiza un
bloque de instrucciones y de ser falso realiza otro bloque de
instrucciones.
Se pueden usar estructura si dentro de otras estructuras si, a esta
clase de estructuras se le conoce como estructuras si anidadas
DEFINCION: Es una estructura que evalúa una expresión lógica y dependiendo del
resultado escoge entre realizar uno u otro bloque de código.
En nuestra vida cotidiana a diario tomamos una serie de decisiones y todas tienen
que ver con: Evaluar una premisa y de acuerdo a su resultado podemos tomar una
u otra decisión.
Ejemplo:
- Deseo ir al cine.
Las estructuras selectivas se utilizan para tomar decisiones lógicas, de ahí que se
suelan denominar también estructuras de decisión o alternativas
Clasificación de las Estructuras Selectivas:
Estructura Selectiva Simple
Estructura Selectiva Doble
Estructura Selectiva Anidada
Estructura Selectiva Múltiple
Este tipo de estructura evalúa una condición (expresión lógica) y de ser verdadera
ejecuta un bloque de instrucciones en caso contrario no hace absolutamente nada.
2. SU REPRESENTACIÓN EN EL PSEUDOCÓDIGO:
Si <condición> entonces
<acción 1>
<acción 2>
<acción n>
fin si
3. SU REPRESENTACIÓN EN LA CODIFICACION:
If monto>=300
{ d=monto*0.30; }
else
{ d=0; }
Este tipo de estructura presenta de igual forma una condición o (expresión lógica),
2. SU REPRESENTACIÓN EN PSEUDOCÓDIGO:
Si <condición> entonces
<acción a>
<acción b>
sino
<acción x>
<acción y>
fin s
i
3. SU REPRESENTACIÓN EN LA CODIFICACION:
if <condición>
{ <acción a>;
<acción b>; }
else
{ <acción x>;
<acción y>;
}
EJERCICIOS PRACTICOS
a. Calcular el promedio de tres notas y determinar la situación académica del
alumno (Aprobado o Desaprobado)
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Declaracion de variables
float n1,n2,n3,prom;
String ea;
//Entrada
n1 = 12;
n2 = 16;
n3 = 10;
//Proceso
prom=(n1+n2+n3)/3;
if(prom>=10.5){
ea="Aprobado";
}
else{
ea="Desaprobado";
}
//Salida
System.out.println("El promedio del alumno es "+prom);
System.out.println("La Situacion academica del alumno es "+ea);
}
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Declaracion de variables
double pu,cant,pt,pd,d;
//Entrada
pu=12.25;
cant=12;
//Proceso
pt=cant*pu;
if(cant>=12){
d=pt*0.05;
}
else{
d=0;
}
pd=pt-d;
//Salida
System.out.println("El Total es "+pt);
System.out.println("El descuento obtenido es "+d);
System.out.println("El Total con descuento es "+pd);
}
EJERCICIOS DE REFUERZO
EJEMPLO 1 -
package semana8;
/**
*
* @author Pepe
*/
public class Notas {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Declaracion de variables
float n1,n2,n3,prom;
String ea;
//Entrada
n1 = 12;
n2 = 16;
n3 = 10;
//Proceso
prom=(n1+n2+n3)/3;
if(prom>=10.5){
ea="Aprobado";
}
else{
ea="Desaprobado";
}
//Salida
System.out.println("El promedio del alumno es "+prom);
System.out.println("La Situacion academica del alumno es "+ea);
}
EJEMPLO 2 -
// Calcular el total de la compra de n productos adquiridos, además
// considere que si el cliente compra a partir de 12 unidades la
// empresa le otorga un descuento del 5% del total
//*************************************************************************
***
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package ventas;
/**
*
* @author Pepe
*/
public class Descuento {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
//Declaracion de variables
double pu,cant,pt,pd,d;
//Entrada
pu=12.25;
cant=12;
//Proceso
pt=cant*pu;
if(cant>=12){
d=pt*0.05;
}
else{
d=0;
}
pd=pt-d;
//Salida
System.out.println("El Total es "+pt);
System.out.println("El descuento obtenido es "+d);
System.out.println("El Total con descuento es "+pd);
}
package mayormenor;
/**
*
* @author Pepe
*/
public class Caso1 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Declarar variables
int a,b,mayor,menor;
String r;
//Entrada
a=23;
b=12;
//Proceso
if (a>b) {
mayor=a;
menor=b;
} else {
mayor=b;
menor=a;
}
//Salida
System.out.println("El mayor es "+mayor);
System.out.println("El menor es "+menor);
}
}
//Proceso
if(p3>=10 && p3<=18){
p3=p3+2;
}
p=(p1+p2+p3)/3;
//Salida
System.out.println("El promedio del alumno es: "+p);
}
}
p
u b
li
ccl
assCompa
ra{
p
u b
li
cst
at
icvoi
dmai
n(
Str
i
nga r
gs[
]
)
{
/
/DECLARACIONDEVARIABLES
i
nta,
b,
c,
ma y
or;
//
INGRESODEDAT OS-Estosdatossoncapt
ura
dosc omoStri
ng
St
rin
gaa=JOp
ti
onPane.
showInpu
tDial
og(
"I
ngr
esapr
imernúmero:"
);
St
rin
gbb=JOp
ti
onPane.
showInpu
tDial
og(
"I
ngr
esasegun
d onú
me r
o:")
;
St
rin
gcc=J
Opti
onPa
n e
.sho
wI np
utDial
og(
"I
ngr
esat
erce
rn úme
ro:")
;
/
/LOS DATOS RECEPCI
ONADOS DEBERAN SER CONVERTI
DOS Al TI
PO QUE
CORRESPONDEN
a=I
nt
eger.
par
seI
nt
(a
a);
b
=Int
eger
.
par
seI
nt
(bb
);
c
=In
tege
r.
par
seI
nt
(c
c);
/
/PROCESODEDAT
OS
i
f(a>
b&&a>c)
{ ma y
or=
a;}
i
f
(b>a&&b>c)
{ ma y
or=
b;}
i
f
(c>a&&c>b)
{ ma y
or=
c;}
i
f(
a<b&&a<c)
{ menor
=a;}
i
f(
b<a&&b<c)
{ menor
=b;}
i
f(
c<a&&c<b
)
{ menor
=c;}
//
SALIDADEINFORMACI
ON
Syst
em.ou
t.
pr
int
l
n("
Eln
úmer
oma
yore
s:"+ma
yor)
;
Syst
em.ou
t.
pr
int
l
n("
Eln
úmer
ome
nores
:"+men
or)
;
}
}
2. SU REPRESENTACIÓN EN EL PSEUDOCÓDIGO:
Si <cond1> entonces
Si Cond1 es verdadero se realiza la acción
<acción a> a y la acción b y luego el flujo del
<acción b> programa sale de la estructura selectiva.
Sino Sino se cumple la Cond1, el flujo del
Si <cond2> entonces programa se dirigirá a evaluar la Cond2, si
esta se cumple solo se realizará la acción c
<acción c>
y la acción d y luego el flujo del programa
<acción d> saldrá de la estructura selectiva.
sino Sino Cond1 y la Cond2 no se cumple, el
Si <cond3> entonces flujo del programa se dirigirá a evaluar la
<acción e> Cond3, si esta se cumple solo se realizará
la acción e y acción f y luego el flujo del
<acción f>
programa saldrá de la estructura selectiva.
sino En el caso de no cumplirse Cond1, Cond2
<acción g> y Cond3, solo en ese caso se realizará la
<acción h> acción g y la acción h.
fin si
fin si
Fin si
3. SU REPRESENTACIÓN EN LA CODIFICACION:
If monto>=1000
{ d=monto*0.30; }
else
{ If (monto<1000 && monto>=500)
{ d=monto*0.20; }
else
{ If (monto<500 && monto>=200)
{ d=monto*0.10; }
else
{ d=0; }
}
}
{ d=monto*0.30; }
else if (monto<1000 && monto>=500) //Segunda condición sino se cumple el anterior
{ d=monto*0.20; }
else If (monto<500 && monto>=200) //Tercera condición sino se cumplen las anteriores
{ d=monto*0.10; }
else //En el caso de cumplirse ninguna de las anteriores
{ d=0; }
p
u b
li
ccl
assCompa
ra{
p
u b
li
cst
at
icvoi
dmai
n(
Str
i
nga r
gs[
]
)
{
/
/DECLARACIONDEVARIABLES
i
nta,
b,
c,
ma y
or;
//
INGRESODEDAT OS-Estosdatossoncapt
ura
dosc omoSt r
ing
St
rin
gaa=JOp
ti
onPane.
showInput
Di
a l
og(
"I
ngr
esapr
imernúmero: "
);
St
rin
gbb=JOp
ti
onPane.
showInput
Di
a l
og(
"I
ngr
esasegun
d onú
me r
o: ")
;
St
rin
gcc=J
Opti
onPa
n e
.sho
wI np
utDi
a l
og(
"I
ngr
esat
erce
rn úme
ro:");
/
/LOSDATOSRECEPCI
ONADOSDEBERANSERCONVERTI
DOSAlTI
POQUECORRESPONDEN
a=I
nt
eger.
par
seI
nt
(aa)
;
b=I
nt
eger.
par
seI
nt
(bb)
;
c
= I
nt
eger
.par
seI
nt
(cc
);
/
/
PROCESODEDAT
OS
i
f(
a>b&&a>c)
{ ma y
or=
a;}
i
f
(b>
a&&b>c)
{ may
or=
b;}
i
f
(c>
a&&c>b
)
{ mayo
r=c
;}
i
f(
a<b&&a<c)
{ me n
or=
a;}
i
f(
b<a&&b<c)
{ me n
or=
b;}
i
f(
c<a&&c<b)
{ me n
or=
c;}
//
SALIDADEINFORMACI
ON
Syst
em.ou
t.
pr
int
l
n("
Eln
úmer
oma
yore
s:"+ma
yor)
;
Syst
em.ou
t.
pr
int
l
n("
Eln
úmer
ome
nores
:"+men
or)
;
}
}
Nota:
Esfuérzate por hacer tu mismo este trabajo, es importante que lo
COMPRUEBES en Java. No olvidar que se entrega el informe de este trabajo
en un folder y también el disquete o CD. (Leer forma de presentación según
aparece en la Diapositiva de la Semana 1).
Si alguno de sus compañeros no tiene esta guía de práctica, reenvíenlo a su
correo.
Logro
Diferencia y determina cuando utilizar la estructura condicional PARA en
la construcción de sus programas.
Resumen
La estructura FOR o PARA es una estructura repetitiva, esta estructura
trabaja con una variable índice que parte de un valor inicial y que en cada
vuelta automáticamente va incrementándose en 1 (a no ser que se
indique lo contrario), termina el ciclo de vueltas luego que el valor de la
variable índice haya llegado hasta el límite superior
La estructura para ejecuta las acciones del cuerpo del bucle un número especificado
de veces y de modo automático controla el número de iteraciones o pasos a través
del cuerpo del bucle.
Esta estructura realiza una serie de ciclos repetitivos de acuerdo al valor del índice
de vueltas, en cada vuelta el valor del índice puede incrementarse o decrementarse
ya sea de uno en uno o de acuerdo a otro intervalo que se especifique.
PARA I de N
a1
Instrucción A
Instrucción B
La variable I va decrementado sus
valores automáticamente, siendo
Instrucción N estos: N,….,,3,2,1
Instrucción A
Instrucción B
B
u
e
c
l
La variable I va decrementado
sus valores automáticamente,
Instrucción N siendo estos: 2,4,6,8,…N
2. SU REPRESENTACION EN PSEUDOCODIGO
3. SU REPRESENTACION EN LA CODIFICACION
EJERCICIOS DE REFUERZO
CASO 1
Evaluar los primeros 100 números naturales y mostrar únicamente a aquellos son
múltiplos de 5, sumarlos y promediarlos.
{ System.out.println(i);
cta++; // Es igual que cta=cta+1 - Es un contador
acu+=i; // Es igual que acu=acu+i - Es un acumulador
}
}
double prom=acu/cta;
System.out.println("El valor acumulado es: "+ acu);
System.out.println("El promedio acumulado es: "+ prom);
}
}
CASO 2
Evaluar los primeros 100 números naturales y mostrar únicamente a aquellos son
múltiplos de 3 ó de 5, pero no de ambos
CASO 3
Evaluar los primeros 100 números naturales y mostrar únicamente a aquellos son
capicúas (que al invertirse siguen siendo el mismo número)
for(i=1;i<=999;i++)
{
int c=(int)i/100; // Se descompone la Centena
int r1=i%100;
int d=(int)r1/10; // Se descompone la Decena
int u=r1%10; // Se descompone la Unidad
if((i>=10)&&(i<=99))
{ if(d==u)
{ System.out.println(i); }
}
else
{ if((i>=100)&&(i<=999))
{ if(c==u)
{ System.out.println(i); }
}
}
} //Fin del for
} // Fin del main
} // fin de la clase
INTRODUCCION:
Las computadoras están especialmente diseñadas para todas aquellas aplicaciones
en las cuales una operación o conjunto de ellas deben repetirse muchas veces. Un
tipo muy importante de estructura, es el algoritmo necesario para repetir una o varias
acciones un número determinado de veces. Las estructuras que repiten una
secuencia de instrucciones un número determinado de veces se denominan bucles,
y se llama iteración al hecho de repetir la ejecución de una secuencia de acciones.
DEFINICIÓN
La estructura repetitiva mientras (en inglés while o do while: hacer mientras) es
aquella en que el cuerpo del bucle se repite mientras se cumple una determinada
condición.
No
Condici
ón
S
Instrucción A
Instrucción X
i
Instrucción Y
Instrucción B
Instrucción N
2. SU REPRESENTACION EN EL PSEUDOCÓDIGO
Mientras <Condición>
Instrucción A
Instrucción B
.
.
.
Instrucción N
Fin Mientras
Instrucción X
Instrucción Y
SU REPRESENTACION EN LA CODIFICACION
while (condición)
{ instrucción A;
instrucción B;
instrucción N;
}
Instrucción X;
Instrucción Y;
DO WHILE – Ejemplo 1
// PROGRAMA QUE CALCULA EL FACTORIAL DE UN NUMERO
//*****************************************************************************************
import javax.swing.*;
public class Factorial {
//INGRESO DE DATOS
String nn=JOptionPane.showInputDialog("Ingrese un número: ");
//CONVERSION DE DATOS
n=Integer.parseInt(nn);
f=1; //Inicializamos el acumulador de productos
while(i<=n)
{
f=f*i;
i=i+1;
}
System.out.println("El factorial es :"+f);
}
}
CONTADORES Y ACUMULADORES
CONTADOR
Los procesos repetitivos son la base del uso de las computadoras. En estos
procesos se necesitan normalmente contar los sucesos o acciones internas del
bucle, como pueden ser los elementos de una lista. Una manera de controlar un
bucle es mediante un contador. Un contador es una variable cuyo valor se
incrementa o decrementa en una cantidad constante en cada iteración.
INICIO
La variable contador
se inicializa
CONT=1
Muestra el valor de
CONT
NO
CONT<=
5
SI
Mostrar
Cuerpo del Bucle CONT
CONT=CONT+1
FIN
La variable contador se
incrementa en 1 por cada
vuelta.
ACUMULADOR
INICIO
CONT=1
SUMA=0
NO
CONT<=
5
SI
Leer Valor
FIN
CONT=CONT+1
SUMA=SUMA+Valor
//CONVERSION DE DATOS
a=Integer.parseInt(aa);
b=Integer.parseInt(bb);
c=2;
mcm=1;
while(a>1 || b>1)
{ if (a%c==0 && b%c==0)
{ a=a/c;
b=b/c;
mcm=mcm*c; }
else
{ if (a%c==0)
{ a=a/c;
mcm=mcm*c; }
else
{ if b%c==0
{ b=b/c;
mcm=mcm*c; }
else
{ c=c+1; }
}
}
}
System.out.println(“El mcm de los números ingresados es: “ + mcm);
} }
//*******************************************************************************************
//* Hacer un programa que solicite un número natural diferente
//* a cero y mostrar: La cantidad de divisores y la suma de los
//* mismos.
//*******************************************************************************************
import javax.swing.*;
public class Divisores {
public static void main(String[] args) {
//DECLRACION DE VARIABLES
int n,a,c,d;
//INGRESO DE DATOS
String nn=JOptionPane.showInputDialog("Ingrese un número: ");
//CONVERSION DE DATOS
n=Interger.parseInt(nn);
//PROCESO DE DATOS
a=0;
c=1;
d=0;
while(c<=n)
{ if(n%c==0)
{ a=c+a;
d=d+1;
}
c=c+1;
}
System.out.println("La cantidad total de divisores que tiene este número es:" + d);
System.out.println("La suma total de los divisores de este número es: "+ a);
}
}
Logro
Que el alumno aplique el uso de funciones de usuario para establecer modulos
que contengan una librería de funciones que puedan ser invocadas por el resto del
sistema.
Resumen
Función de Usuario: Es un procedimiento anexo a nuestro programa
encargado de realizar una proceso específico, al cual podemos invocar
tantas veces sea necesario.
Dentro del trabajo del procesamiento de datos, se hace necesario trabajar con
conjunto de datos, por ejemplo:
¿Qué es un Arreglo?
Un Arreglo es una estructura de datos que almacena bajo el mismo nombre
(variable) a una colección de datos del mismo tipo.
Arreglo Unidimensional
• Un arreglo unidimensional es un tipo de dato estructurado que está formado de una colección
finita y ordenada de datos del mismo tipo.
• El tipo de acceso a los arreglos unidimensionales es el acceso directo, es decir, podemos
acceder a cualquier elemento del arreglo sin tener que consultar a elementos anteriores o
posteriores, esto mediante el uso de un índice para cada elemento del arreglo que nos da su
posición relativa.
EDAD 12 18 22 25 23
Índice 0 1 2 3 4
LÓGICA DE NEGOCIOS
public class Arreglos {
//Propiedades
public double[] ventas;
//Método
public void cargardatos(double dato,int pos){
ventas[pos]=dato;
}
//Método
public double mostrarUnDato(int pos){
return ventas[pos];
}
//Método
public String mostrarTodoslosDatos(int n){
int i;
String acu="";
for(i=0;i<=n-1;i++)
{ acu=acu+ventas[i]+"\n"; }
return acu;
}
//Método constructor
public Arreglos(){
//Se ejecuta cuando ocurre una instancia
ventas=new double[100];
}
}
CODIFICACIÓN EN EL FORMULARIO
Previamente debe declararse los siguientes objetos:
public class frmArreglos extends javax.swing.JFrame {
Arreglos obj; //Objeto que servirá para la instancia
public int n; //Variable Global que controla la longitud
/** Creates new form frmArreglos */
public frmArreglos() {
obj=new Arreglos(); //Instancia de la clase
initComponents();
}
Nota: Las líneas que están en letras distintas, son aquellas deben agregarse en la
parte inicial de la codificación del formulario.
for(i=0;i<=n-1;i++){
dato=Double.parseDouble(JOptionPane.showInputDialog("Introduzca dato para ventas["+i+"]"));
obj.cargardatos(dato, i);
}
}
Durante esta semana, no se han programado trabajos domiciliarios, a fin de que los
alumnos puedan dedicarse exclusivamente para prepararse para la 1ra. Practica
Calificada de la próxima semana.
III. BIBLIOGRAFIA
{ If (i%10==0)
{ cuenta=cuenta+1; }
}
System.out.print(“La estructura FOR dio la siguiente cantidad de vueltas”);
System.out.println(cuenta);
int i;int n;
for(i=1;i<=999;i++)
{
int c=(int)i/100; // Se descompone la Centena
int r1=i%100;
int d=(int)r1/10; // Se descompone la Decena
int u=r1%10; // Se descompone la Unidad
if((i>=10)&&(i<=99))
{ if(d==u)
{ System.out.println(i); }
}
else
{ if((i>=100)&&(i<=999))
{ if(c==u)
{ System.out.println(i); }
}
}
} //Fin del for
} // Fin del main
while(i<=n)
{ f=f*i;
i=i+1;
}
System.out.println("El factorial es :"+f);
//CONVERSION DE DATOS
a=Integer.parseInt(aa);
b=Integer.parseInt(bb);
c=2;
mcm=1;
while(a>1 || b>1)
{ if (a%c==0 && b%c==0)
{ a=a/c;
b=b/c;
mcm=mcm*c; }
else
{ if (a%c==0)
{ a=a/c;
mcm=mcm*c; }
else
{ if b%c==0
{ b=b/c;
mcm=mcm*c; }
else
{ c=c+1; }
}
}
}
System.out.println(“El mcm de los números ingresados es: “ +
mcm);
}
}
while(n<48)
{ c=a+b;
a=b;
b=c;
System.out.print(c);
n=n+1;
}
}
La estructura para ejecuta las acciones del cuerpo del bucle un número
Esta estructura realiza una serie de ciclos repetitivos de acuerdo al valor del
índice de vueltas, en cada vuelta el valor del índice puede incrementarse o
decrementarse ya sea de uno en uno o de acuerdo a otro intervalo que se
especifique.
Instrucción N
R. Esta rutina se realiza 100 veces y evalúa entre los números del 1 al 100 y
cuenta cuantos números son divisibles entre cinco y acumula la suma de los
números del 1 al 100. (El índice de vueltas se hace de modo decreciente de 1
a 100).
R. Esta rutina se realiza 100 veces y evalúa entre los números del 1 al 100 y
cuenta cuantos números son divisibles entre cinco y acumula la suma de los
números del 1 al 100. Luego calcula el promedio de los números incluidos en
la serie numérica del 1 al 100. (El índice de vueltas se hace de modo
decreciente de 1 a 100).
R. Esta rutina se realiza 100 veces y evalúa entre los números del 1 al 100 y
cuenta cuantos números son divisibles entre 3 ó 5 y no de ambos y muestra y
cuenta los divisores que cumplen con dicho código. (El índice de vueltas se
hace de modo decreciente de 1 a 100).
R. Esta rutina se realiza 100 veces y evalúa entre los números del 1 al 100 y
cuenta cuantos números son divisibles entre 3 ó 5 y no de ambos y muestra y
cuenta los divisores que cumplen con dicho código. (En este caso no la forma
diferente de establecer la condición).
int i;int n;
for(i=1;i<=999;i++)
{
int c=(int)i/100; // Se descompone la Centena
int r1=i%100;
int d=(int)r1/10; // Se descompone la Decena
int u=r1%10; // Se descompone la Unidad
if((i>=10)&&(i<=99))
{ if(d==u)
{ System.out.println(i); }
}
else
{ if((i>=100)&&(i<=999))
{ if(c==u)
{ System.out.println(i); }
}
}
} //Fin del for
} // Fin del main
R. Esta rutina se realiza 999 veces y evalúa entre los números del 1 al 999 y
cuenta cuantos números son capicúas.
No
Condici
ón
S
Instrucción A
Instrucción X
i
Instrucción Y
Instrucción B
Instrucción N
Mientras <Condición>
Instrucción A
Instrucción B
.
.
.
Instrucción N
Fin Mientras
Instrucción X
Instrucción Y
while (condición)
{ instrucción A;
instrucción B;
instrucción N;
}
while(i<=n)
{ f=f*i;
i=i+1;
}
System.out.println("El factorial es :"+f);
for(i=1;i<=n;i++)
{ f=f*i;
}
System.out.println("El factorial es :"+f);
INICIO
La variable contador
se inicializa
CONT=1
NO
CONT<=
5
SI
Mostrar
Cuerpo del Bucle CONT
CONT=CONT+1
FIN
La variable contador se
incrementa en 1 por cada
vuelta.
INICIO
CONT=1
SUMA=0
NO
CONT<=
5
SI
Leer Valor
FIN
CONT=CONT+1
SUMA=SUMA+Valor
//CONVERSION DE DATOS
a=Integer.parseInt(aa);
b=Integer.parseInt(bb);
c=2;
mcm=1;
while(a>1 || b>1)
{ if (a%c==0 && b%c==0)
{ a=a/c;
b=b/c;
mcm=mcm*c; }
else
{ if (a%c==0)
{ a=a/c;
mcm=mcm*c; }
else
{ if b%c==0
{ b=b/c;
mcm=mcm*c; }
else
{ c=c+1; }
}
}
}
while(n<48)
{ c=a+b;
a=b;
b=c;
System.out.print(c);
n=n+1;
}
}