Guia de Ingenieria de Software 1

GUIA DE INGENIERIA DE SOFTWARE 1
UNIVERSIDAD SALESIANA
ING. IVAN VERASTEGUI PALAO
FASE 1
GESTION 2023
Boceto del proyecto del sistema
SISTEMA DE INVENTARIOS
Sistema de INVENTARIO
PARAMETROS GENERALES
MODIFICACIONES AL VUELTOS EN LAS

CLIENTES
SISTEMA COMPRAS Y VENTAS
DESARROLLO DE SOFTWARE
PROCESO DE
PROCESO DE COMPRA PROCESO DE VENTA CONTROL DE
INVENTARIOS
REPORTES DE SOFTWARE
CONTROL DE
COMPRAS VENTAS
INVENTARIOS
GUIA NETBEANS
1. INTRODUCCIÓN A LOS ALGORITMOS
1.1 FUNDAMENTOS DE ALGORITMOS
1.1.1 Algoritmo
Es un conjunto de pasos lógicos que permite alcanzar la solución de un problema.
 Características
o Finito: Debe culminar la solución.

o Ordenado: Debe tener una secuencia para seguir los pasos secuencialmente.
o No Ambigüo: Debe ser claro y no tener diferentes interpretaciones.
 Ejemplos de la Vida Diaria

Aplicando la definición de algoritmos a las actividades de la vida diaria se
muestran los siguientes ejemplos:
o Conseguir un vaso de agua.
Ir a la nevera llevando el vaso en la mano.

Abrir la nevera.
Tomar la jarra o vasija con el agua.
Verter el agua en el vaso hasta que esté lleno.
Regresar la vasija a la nevera.
Cerrar la nevera.
Tomar el agua contenida en el vaso.
Regresar el vaso.
o Preparar una limonada.
Partir cuatro limones en cuatro pedazos cada uno.

Agregar los limones cortados, 1 litro de agua y 4 cucharadas de azúcar en la
licuadora.
Licuar los ingredientes por 4 minutos
Colar la mezcla y verterla en la jarra
Servir la mezcla colada en 4 vasos.
1.1.2 Ingreso al Programa
En el escritorio aparece un icono que lleva por nombre Netbeans.
Dar doble click en el icono y se iniciará el programa o ir al menú inicio, escoger la

opción todos los programas y escoger Netbeans y luego dar click en Netbeans
1.2. CREACIÓN DE PROYECTOS
 Una vez ingresado al programa de ir al menú File y escoja la opción New

Project
Imagen 1. Ventana de Inicio en Netbeans.
 Luego escoja la opción General en la ventana de la izquierda y en la derecha

escoja la opción Java Aplication y presione el botón Next.
Imagen 2. Ventana para selección de tipo de aplicación.
 Le aparece una ventana, donde aparece Project Name en este lugar se

coloca el nombre del proyecto a realizar, para el cual debe ser relacionado al
objetivo del programa.
Imagen 3. Ventana para nombrar proyecto.
 Escoja el lugar donde se creará la carpeta en donde se guardará el programa.

Ejemplo: Mi PC/C. Se coloca en Project Location.
 Desactive las dos casillas de verificación que aparecen con un chulito en

color verde, se desactiva haciendo click sobre cada una de ellas, una vez
desactivada se presiona el botón Finish
1.3 CREACIÓN DE CLASES
Una vez creado el proyecto se crea el espacio donde se escribirá el algoritmo, de la

siguiente forma:
 Encima del nombre del proyecto que aparece en la parte izquierda de la ventana,
se da click derecho, y en el menú que se despliega, se escoge la opción New,
y luego la opción Java Class.
Imagen 4. Ventana Creación de la clase.
 En la ventana que se obtiene, en la parte en donde se encuentra Class Name,

se coloca el nombre del programa.
Imagen 5. Ventana para dar nombre a la clase.
 Presiona el botón Finísh.
Se culmina con la creación del programa el cual se crea con las siguientes
instrucciones:
/*
* prueba.java
*
* Created on 11 de julio de 2007, 12:45
*
* To change this template, choose Tools | Template Manager
* and open the template in the editor.
*/
/**
*
* @author estudiante
*/
public class prueba {
/** Creates a new instance of prueba */
public prueba() {
}
Esto quiere decir que se creó un programa, en la fecha y hora indicada. Además
note que aparece una instrucción que es:
public class prueba {
Donde esta instrucción es la que indica que es un programa de Java y no se debe

modificar o cambiar de ninguna forma.
1.4 COMPILAR Y EJECUTAR UN PROYECTO
Una vez el archivo grabado, se puede lanzar la compilación y la ejecución de su

proyecto por Menú Run->RunMainProject (F6) o haciendo clic derecho sobre el
programa y escoger la opción ejecutar archivo. Eso tiene por consecuencia ejecutar
las diferentes instrucciones del programa para compilar, luego ejecutar la aplicación.
2. ESTRUCTURAS BÁSICAS DE ALGORITMOS
En la siguiente instrucción que es:
public prueba() {
Esta instrucción es modificada y reemplazada, para colocar el inicio del pseudocódigo

de los algoritmos, de la siguiente forma:
public static void main(String args[]){

Luego aparece lo siguiente:
}
Este indica el fin del algoritmo, por lo tanto para escribir el algoritmo debe presionar
la tecla Enter al final de la instrucción de inicio para que cree un espacio entre las
dos líneas de código.
2.1. INSTRUCCIONES
2.1.1 Librería más Utilizadas
Librería es donde se definen operaciones que realiza el sistema, para los cual es
necesario ser llamadas para poder utilizar dichas funciones, entre las cuales se
tienen las siguientes:
import javax.swing.*; El cual permite enviar resultados en pantalla y leer datos por
teclados entre otras operaciones.
Import java.util.*; El cual permite generar números aleatorios, manejo de fechas,

colecciones y otras operaciones.
2.1.2 Declaración De Variables Y Tipos De Datos
Las variables son valores que pueden o no cambiar en el tiempo. Las características
de una variable es que debe tener dos componentes: Nombre y tipo de dato.
Reglas para dar Nombre a Variables
 Debe iniciar con una letra.

 Puede contener después de la letra se puede colocar letras o números.
 No debe contener espacios en blanco.
 No debe contener operadores matemáticos como (+, -, *, / , etc.).
Tabla 1. Ejemplos de Nombres de Variables.
Nombre Variable Estado (Correcto o Incorrecto)

Casa Correcto
Casa verde Incorrecto (Utiliza espacio en blanco)
A2 Correcto
A2B Correcto
1b3 Incorrecto(Empieza con número)
N# Correcto
N+d Incorrecto(Utiliza Operadores matemáticos)
2.1.3 Ejercicios Propuestos

 Indique si los nombres de variables son correctos o incorrectos y justifique su
respuesta.
a. A3456g
b. 9ft1
c. CA_45
d. a1
e. op2c_2
 ¿En cuáles de los siguientes pares es importante el orden de los enunciados?
Es decir, si se modifica el orden ¿cambian los resultados finales? (Suponemos que
X≠Y≠Z).
a) X=Y b) X=Z c) X=Y d) Z=Y

Y=Z X=Y Z=X X=Y
Manejo de Tipos de Datos en Netbeans
Existen varios tipos de datos como son: Numéricos y alfanuméricos.
 Datos Numéricos. Se dividen en enteros y reales, de los cuales en java se

definen así:
a. Enteros: int variable1, variable2, variable3,…, variable n;
b. Reales: float variable1, variable2, variable3,…, variable n;

double variable1, variable2, variable3,…, variable n;
 Datos Alfanuméricos. Se dividen en carácter y cadenas, de los cuales en

java se definen así:
a. Carácter: char variable1, variable2, variable3,…, variable n;
b. Cadenas: String variable;
2.1.4 ESTRUCTURA DE DATOS ESTATICAS. Son estructuras fijas entre los cuales
tenemos los arreglos unidimensionales y bidimensionales.
Arreglos unidimensionales o Vectores. Se definen en java de la siguiente forma:
(Tipo de dato) [] (nombre del arreglo) =new (tipo de dato)[tamaño];
Ejemplo: int []vec=new int[50];
Arreglos bidimensionales o Matriz. Se definen en java de la siguiente forma:
(Tipo de dato) [][] (nombre del arreglo) =new (tipo de dato)[fila][columna];

Ejemplo: int [][]mat=new int[50][50];
2.2 OPERADORES RELACIONALES Y MATEMÁTICOS
Existen diferentes tipos de operadores entre los cuales se tienen los siguientes:
Operadores matemáticos, lógicos y relacionales.
Operadores Matemáticos. Son todas las operaciones matemáticas básicas, se

definen en java de la siguiente forma:
Operación Operador
Suma +
Resta -
División /
Módulo de División %
Cociente de División /
Ejemplo:
f=a+b; f=a-b; f=a*b; f=a/b; f=a%b; f=a/b;
Jerarquía de los Operadores
Los operadores aritméticos tienen un orden de realizarse las operaciones este orden
se muestra en la siguiente tabla:
Tabla 2. Precedencia de Operadores.
Jerarquía de Operadores Aritméticos

Operador Jerarquía Operación
** (Mayor) Potencia
() Paréntesis
*, /, mod, div Multiplicación, división, módulo, división entera.
+,- (Menor) Suma, resta
Ejemplos
1. 17+5-6
Solución: 12 – 6
6
2. 9+7*8-36/5
Solución: 9+56-36/5
9+56-7,2
65-7,2
57,8
3. 15/2*(7+(68-15*33+(45**2/16)/3)/15)+19
Solución: 15/2*(7+(68-15*33+(2025/16)/3)/15)+19
15/2*(7+(68-15*33+126.5625/3)/15)+19
15/2*(7+68-495+126.5625/3)/15+19
15/2*(7+(68-495+42.1875)/15+19
15/2*(7+(-427+42.1875/15)+19
15/2*(7+(-)384.8125/15+19
15/2*(7+(-)25.6541)+19
15/2*(-)18.6541+19
7.5*(-)18.6541+19
-139.9062+19
-120.9062

Resolver los siguientes ejercicios teniendo en cuenta la precedencia de operaciones2.
1. 7*8*(160 mod 3**3) div 5*13-28
2. 6+3*(4/2-6+4)/2 mod 4
3. 4 * (8 - 3 * 2) + (5 / 3 * 2) * 3.0
4. (5 + 3 · 2 / 6 − 4 ) · (4 /2 − 3 + 6) / (7 − 8 / 2 − 2)**2
5. 6(-3(8+6-9)+6)+4(-8(1+3-6)+1)
Operadores Relacionales. Son todas las operaciones de comparación y
verificaciones básicas, se definen en java de la siguiente forma:
1 CAIRÓ BATTISTUTI, Osvaldo. Metodología de la Programación.

Algoritmos, diagramas de flujo y programas, México D.F.:Alfaomega.2005, p 13-
23.
Algoritmos, diagramas de flujo y programas, México D.F.:Alfaomega.2005.
Tabla 3. Operadores Relacionales.
Operación Operador
Asignación =
Igual ==
Diferente <>
Menor <
Mayor >
Menor Igual <=
Mayor Igual >=
Ejemplo:
1. A=5 B=16
(A**2)>(B*2)
25 > (B*2)
25>32
FALSO
2. X=6 B=7.8
(X * 5 + B ** 3 / 4) <= (X ** 3 div B)
(X * 5 + B ** 3 / 4) <= (X ** 3 div B)
(X * 5 + 474.552 / 4) <= (X ** 3 div B)
(30 + 474.552 / 4) <= (X ** 3 div B)
(30 + 118.638) < = (X ** 3 div B)
148.638 <= (X ** 3 div B)
148.638 <= (216 div B)
148.638 < = 27
FALSO

1. A=2 B=5
(A – 4 * B) > (A / B) = (B / A)
2. D=6 E=3
D**2 + (4 – E) <= (E *D + 5)
3. 9*(4 – 7 / 5) mod 3 > 8 div (4 – 9)
4. 10+ (24 – 31) ** 2 > (3 * 4 + 9 -3 ) < (2 – 1)
5. A=-1 B=2
(A * 4 - B) > (A ** B) = (B * A)
Operadores Lógicos. Son todas las operaciones que permiten interconectar
verificaciones, se definen en java de la siguiente forma:
Operaci Operad
ón or
Y &&
O ||
Ejemplo3:
Sea: a = 10 b = 12 c = 13 d =10
1. ((a>b) or (a<c)) and ((a=c) or (a>=b))
F T F F
T F
F
2. ((a>=b or (a<d)) and (a>=d) and (c>d))
F F T T
F T
T
3. not (a=c) and (c>b)
F T
T
T
2.2.3 Ejercicios Propuestos4
1. Not (99 >= 50 or 10 > = 75)

2. Not (3+4-4>5 and (not(4>=2 and 2^2<4) or 44< 5^3))
3. Not ( (10 * 4) > (15 /2 * 6 > = 15 * 2 / 17 = 15 ) )
4. (15 > = 7 * 3 ** 2 Y 8 > 3 Y 15 > 6) O NO (7 * 3 < 5 + 12 * 2 div 3 ** 2)
2.3 ETAPAS PARALASOLUCIÓN DE PROBLEMAS POR COMPUTADOR
Para resolver un problema es necesario seguir las siguientes etapas:
a. Identificación de Datos de entrada, Datos de Salida y proceso necesario para dar

solución al problema (Análisis del Problema).
b. Desarrollar el algoritmo utilizando pseudocódigo5.
c. Las características de un buen algoritmo son:
o Debe tener un punto particular de inicio.
o Debe ser definido, no debe permitir dobles interpretaciones.
o Debe ser general, es decir, soportar la mayoría de las variantes que se puedan
presentar en la definición del problema.
o Debe ser finito en tamaño y tiempo de ejecución.
o Diseño del Algoritmo
d. Realizar Pruebas para la comprobación de los cálculos realizados.
e. Realizar programa computacional en el lenguaje requerido.
f. Ejecución del Programa.
Datos de Entrada: Son los datos que provee el problema o que son necesarios
para realizar los cálculos.
Datos de Salida: Son los datos que se desean calcular en el problema.
Proceso: Son las operaciones, verificaciones que deben realizarse con los datos
de entrada para calcular los datos de salida.
2.4. ESTRUCTURAS ALGORITMICAS

Existen diversas instrucciones que son necesarias al momento de desarrollar una
solución entre las básicas se encuentran las siguientes:
2.4.1 ESTRUCTURAS DE ENTRADA O LEER

Pseudocódigo
Las estructuras de entrada permiten ingresar datos al programa a través del teclado.
Dichas se representan en Pseudocódigo a través del siguiente código:
Leer Nombre de la variable;
Ejemplo
Leer Variable
Instrucción de Entrada o Leer en Netbeans
Las instrucciones de entrada son aquellas que permiten ingresar datos a la solución
es decir, lea o leer. Existen dos formas de realizar las lecturas en Netbeans como
son:
Por consola:
La consola es el que se encuentra en la parte inferior de la ventana, donde tiene

como título en la pestaña output.
 Como primer paso debe definir el proceso de lectura de la siguiente forma:
BufferedReader variable = new BufferedReader(new

InputStreamReader(System.in));
Variable: la variable es colocada de acuerdo al criterio personal, esta

instrucción permite simplificar el proceso de lectura.
Pero para realizar este primer paso es necesario definir en las librerías la
siguiente:
import java.io.*;
 Como segundo paso
Variable a leer= Tipo de dato de la variable.parse tipo de dato de la

variable(variable.readline()).
Ejemplo:
num=Integer.parseInt(lectura.readLine());
Teniendo en cuenta que la variable num es definida como entera es decir int.
Por Ventana de Windows:

 Como primer paso debe declarar la variable a leer:
Pero para realizar este primer paso es necesario definir en las librerías la
siguiente:
import javax.swing.*;
 Como segundo paso

Variable a leer= Tipo de dato de la variable.parse tipo de dato de la
variable(JOptionPane.showInputDialog(“Mensaje”)).
Ejemplo:
num=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese el valor”));
num=Float.parseFloat(JOptionPane.showInputDialog(“Ingrese el valor”));
num=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese el
valor”));
Teniendo en cuenta que la variable num es definida como entera es decir int.
2.4.2 ESTRUCTURAS DE SALIDA O ESCRIBIR
Pseudocódigo
Las estructuras de salida se representan en Pseudocódigo a través del siguiente

código:
Escribir (“Mensaje”, Variable);

Ejemplo:
Escribir (“El resultado es”, N);
Por consola:
System.out.println(“Mensaje”+variable)
Ejemplo:
System.out.println(“El resultado es ”+num);
La variable donde se almacena el resultado es num, y la coma es reemplazada por

un símbolo + que significa unir el mensaje con el valor almacenado en la variable, o
en el lenguaje técnico concatenación.
Por Ventana de Windows:
Pero para realizar lo siguiente es necesario definir en las librerías la siguiente:
Luego,
JOptionPane.showMessageDialog(“Mensaje”+variable).
Ejemplo:
JOptionPane.showMessageDialog(“el resultado es ”+num);
Ejemplo del código completo en netbeans donde se realiza una entrada, es decir,
una lectura, y una escritura, es decir, escribir.
import java.io.*;
public class ejercicio1 {
public static void main(String[]args)throws IOException {
BufferedReader lectura = new BufferedReader(new InputStreamReader(System.
in));
int num;
System.out.println(“Ingrese numero: “);
num = Integer.parseInt(lectura.readLine());
System.out.println(“su número es “+num);

}
}
Ejemplo del código completo en netbeans donde se realiza una entrada, es decir,
una lectura, y una escritura utilizando ventanas de Windows, es decir, escribir.
/** Creates a new instance of ejercicio1 */

public static void main(String args[]) {
int n,d;
n=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese el valor del
numerador”));
JOptionPane.showMessageDialog(null,”El valor ingresado es “+n);
d=n*n;
JOptionPane.showMessageDialog(null,”El valor de la potencia es “+d);
}
}
2.4.3 ESTRUCTURAS SECUENCIALES
En este caso se ejecutan las instrucciones una tras otra, es decir de forma lineal.
Operador Asignación
Este operador tiene gran importancia para plantear la solución a un problema,

debido a que permite guardar valores en la variable.
Se debe tener en cuenta que en una solución algorítmica los datos o expresiones
matemáticas deben ser guardadas en las variables utilizando este operador, y se
representa por el siguiente símbolo: =
Ejemplo:
1. a1=2+3
b=a1+4
Tabla 4. Ejemplo 1.
Número de Asignación a1 b
1 5
2 9
2. Supongamos que las variables I, ACUM y J son de tipo entero, REA y SUM de
tipo real, CAR de tipo carácter y BAND de tipo booleano 6. Consideremos también
que tenemos que realizar las siguientes asignaciones:
Algoritmos, diagramas de flujo y programas, México D.F.:Alfaomega.2005, p 13-
23.
1. I<- 0
2. I<-I+1
3. ACUM<-0
4. J<-5**2 div 3
5. Car<-‘a’
6. ACUM<- J div I
7. REA<- ACUM/3
8. BAND<-(8>5)y(15<2**3)
9. SUM<-ACUM*5/J**2
10. I<-I*3
11. REA<-REA/5
12. BAND<-BAND o (I=J)
13. I<-REA
14. CAR<-J
Tabla de Memoria
Número de
I J ACUM REA SUM CAR BAND
Asignación
1 0
2 1
3 0
4 8
5 a´
6 8
7 2.66
8 FALSO
9 0.625
10 3
11 0.532
12 FALSO
13 ERROR
14 ERROR
Ejercicios Propuestos
Realizar las tablas de Memoria de las siguientes asignaciones.
1. Se supone que las variables A, B y J son de tipo entero, C y D de tipo real, CAD
de tipo carácter y DEC de tipo booleano. Consideremos también que tenemos que
realizar las siguientes asignaciones:
1. A<- 1
2. A<-A+3
3. J<-0
4. J<-4**3 mod 3
5. Cad<-‘Casa Verde’
6. B<- J div A
7. C<- B/3
8. DEC<-(8>5)y(15<2**3)
9. D<-B*5/J**2
10. A<-A*3
11. C<-C/5
12. DEC<-DEC o (I=J)
13. A<-C
14. CAD<-J
2. Se supone que las siguientes variables inician con los siguientes valores
BETA=200, CES=0.5, CONT=800, SUM=600, AME=100, PAG=40, TEN=10, RES=2,
MAX=2000, ULT=0.20
1. TOTA<-BETA*CES+10
2. ROT<-PAG
3. MAN<- MAX / TEN
4. FAC<-PAG * AME / 2
5. BOTA<-CONT + SUM –MAX
6. FAC<-RES * TEN * AME
7. TOTA<-60 + PAG – AME
8. ZOR<-MAX * ULT / 2 + ROT
9. CARO<-BETA + AME + TEN + ULT
10. NEKO<- MAX * AME + PAG – RES * CARO
Estructura Inicio – Fin
Esta estructura permite delimitar la solución del problema a través del Pseudocódigo
así:
Inicio
Instrucciones;
Fin
Ejemplo.
 Realizar un algoritmo que dados dos (2) números, calcule la suma de dichos
números.
Datos de Entrada: Número1 y Número2
Datos de Salida: Suma
Proceso: Número1 + Número2
Solución
Inicio
Escribir(“Ingrese el Primer Número”)
Leer n1
Escribir(“Ingrese el Segundo Número”)
Leer n2
S=n1+n2
Escribir(“La suma es ”, S)
Fin
 Realizar un algoritmo que dados base y altura. Calcule el área del triángulo y el
rectángulo.
Datos de Entrada: base, altura

Datos de Salida: Área del triángulo y Área del Rectángulo
Proceso: Área del Triángulo = (b*h)/2
Área del Rectángulo =b*h
Solución
Inicio
Escribir(“Ingrese la base del Triángulo”)
Leer bt
Escribir(“Ingrese la altura del triángulo”)
Leer ht
At=(b*h)/2
Escribir(“El área del Triángulo es ”, At)
Escribir(“Ingrese la base del Rectángulo”)
Leer br
Escribir(“Ingrese la altura del Rectángulo”)
Leer hr
Ar=(b*h)
Escribir(“El área del Rectángulo es ”, Ar)
Fin
Solución en Netbeans
public class Áreas{
double bt,ht,At,br,hr,Ar;
bt=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese la base del
Triángulo”));
ht=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese la altura del
Triángulo”));
At=(b*h)/2;
JOptionPane.showMessageDialog(null,”El área del triángulo es ” “+At);
br=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese la base del
Rectángulo”));
hr=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese la altura del
Rectángulo”));
Ar=(br*hr);
JOptionPane.showMessageDialog(null,”El área del Rectángulo es ” “+Ar);
}
}
 Dado el nombre y tres 3 calificaciones de un estudiante obtenidas a lo largo del
semestre. Realice un algoritmo que muestre el nombre del estudiante y el
promedio de sus calificaciones.
Datos de Entrada: nombre, nota 1, nota 2, nota 3

Datos de Salida: Promedio
Proceso: Promedio= Suma de notas/ número de notas
Solución en Pseudocódigo
Inicio
Escribir(“Ingrese el nombre del Estudiante)
Leer nombre
Escribir(“Ingrese la primera nota)
Leer n1
Escribir(“Ingrese la segunda nota)
Leer n2
Escribir(“Ingrese la tercera nota)
Leer n3
P=(n1+n2+n3)/3
Escribir(“El promedio de ”,nombre,” es de “,P)
Fin
Solución en Netbeans
public class Promedio {
String nombre;
double n1,n2,n3;
nombre=JOptionPane.showInputDialog(“Ingrese el valor del numerador”);
n1=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese el número”));
P=(n1+n2+n3)/3;
JOptionPane.showMessageDialog(null,”El promedio de “+nombre+ “es de
“+P);
}
}
Ejemplos en Netbeans de Estructuras Secuenciales
 Este programa calcula la potencia cuadrada de un número dado
int n,d;
n=Integer.parseInt (JOptionPane.showInputDialog(“Ingrese el valor del
numerador”));
d=n*n;
}
}
Para crear un nuevo programa en el mismo proyecto solo debe volver a seguir los
pasos para crear una clase que son:
 Encima del nombre del proyecto que aparece en la parte izquierda de la
ventana, se da click derecho, y en el menú que se despliega, se escoge la
opción New, y luego la opción Java Class.
 En la ventana que se obtiene, en la parte en donde se encuentra Class
Name, se coloca el nombre del programa.
 Presiona el botón Finísh.
De esta forma se creará un nuevo espacio para realizar otro programa, recuerde
que el nombre de la clase debe ser referente al objetivo del programa, además que
no debe contener espacios y debe empezar por letra.
1. Realizar un algoritmo que dado el valor de la compra y el valor a pagar por el

cliente, calcular el valor a devolver al cliente.
2. Realizar un algoritmo que dado la cantidad de mujeres y hombres de un grupo,
calcular el porcentaje de hombres y mujeres del grupo.
3. Realizar un algoritmo dadas las notas del primer parcial y del segundo parcial de
un estudiante donde el primer y segundo parcial equivalen al 30% y 30%
respectivamente, Calcular que nota debe obtener para ganar la asignatura teniendo
en cuenta que el final equivale al 40% y la nota para ganar la asignatura es de 3.0.
4. Realizar un algoritmo que dado el lado de un cuadrado, calcule al área y perímetro

del cuadrado.
5. Realizar un algoritmo que dado dos números enteros y muestre su suma, resta,
multiplicación, división.
6. Realizar un algoritmo que una vez se ingrese una medida expresada en centímetros
la convierta en pulgadas (1pulgada = 2,54 centímetros).
7. Realizar un algoritmo que exprese en horas, minutos y segundos un tiempo

expresado en segundos.
8. Realizar un algoritmo que dado el total de kilómetros recorridos, el precio de la

gasolina (por litro), el dinero de gasolina gastado en el viaje y el tiempo que se ha
tardado (en horas y minutos) y que calcule:
 Velocidad media (en km/h y m/s).
 Consumo de gasolina (en litros y euros) por cada 100 km.
 Consumo de gasolina (en litros y euros) por cada km.
9. La presión, el volumen y la temperatura de una masa de aire se relacionan por la

fórmula:
masa = (presión * volumen)/(0.37 * (temperatura + 460))
Pedir los datos de Presión, volumen y temperatura.
10. Calcular el número de pulsaciones que una persona debe tener por cada 10
segundos de ejercicio, si la fórmula es:
num_pulsaciones = (220 - edad)/10
11. En un hospital existen tres áreas: Ginecología, Pediatría, Traumatología. El
presupuesto anual del hospital se reparte conforme a la siguiente Tabla:
Área Porcentaje del presupuesto

Traumatología 30%
Ginecología 40%
Pediatría 30%
Obtener la cantidad de dinero que recibirá cada área, para cualquier monto
presupuestal.
12. Todos los lunes, miércoles y viernes, una persona corre la misma ruta y
cronometra los tiempos obtenidos. Determinar el tiempo promedio que la persona
tarda en recorrer la ruta en una semana cualquiera.
13. En una gasolinera tiene el siguiente problema, los surtidores registran lo que
surten en galones, pero el precio de la gasolina está fijado en litros. El algoritmo
debe calcular e imprimir lo que hay que cobrarle.
1 Galón tiene 3785 litros.
14. Realizar un algoritmo que dado como datos el radio y la altura de un cilindro,
calcule e imprima el área y su volumen.
15. Realizar un algoritmo que calcule la distancia entre dos puntos, dado como
datos las coordenadas de los puntos P1 y P2.
D=√(x1-x2)2+(y1-y2)2
16. La relación entre los lados (a ,b) de un triángulo rectángulo y la hipotenusa (h)
viene dada por la formula
a2 + b2 = h2 h: hipotenusa
Escribir un algoritmo que lea la longitud de los dos lados y calcule la hipotenusa.
2.4.5 OPERADORES LÓGICOS

Los operadores lógicos son resultados de evaluación de expresiones que responden
a condiciones que permiten la toma de decisiones, los operadores utilizados son: Y,
O, NO.
 Y o también conocido como AND. De este operador se pueden obtener los

siguientes resultandos:
V= verdadero
F=Falso
Tabla 5. Operador Y
Expresión 1(E1) Expresión 2(E2) E1 Y E2

V V V
V F F
F V F
F F F
En este operador el resultado de la evaluación de la expresión será verdadero

solo si todas las expresiones de esta son verdaderas, de lo contrario será falsa.
Se debe tener en cuenta que para utilizar estas expresiones se utilizan los
operadores relacionales como se mostró anteriormente en el ítem de operadores,
entre los cuales están <,>, <=, >=, =, <>.
En java se representa con el siguiente símbolo: &&

Ejemplo:
((a<b) && (b>c) && (c=d) && (d<>f))
 Conocido como OR. De este operador se pueden obtener los siguientes
resultandos:
V= verdadero
F=Falso
Tabla 6. Operador O
Expresión 1(E1) Expresión 2(E2) E1 O E2

V V V
V F V
F V V
F F F
En este operador el resultado de la evaluación de la expresión será falsa solo si todas

las expresiones de esta son falsas, de lo contrario será verdadera. Se debe tener
en cuenta que para utilizar estas expresiones se utilizan los operadores relacionales
como se mostró anteriormente en el ítem de operadores, entre los cuales están <,>,
<=, >=, =, <>.
En java se representa con el siguiente símbolo: ||
Ejemplo:
((a<b) || (b>c) || (c=d) || (d<>f))
 NO o también conocido como NOT. De este operador se pueden obtener los

siguientes resultandos:
V= verdadero
F=Falso
Tabla 7. Operador NO
Expresión 1(E1) NO (E1)

V F
V F
F V
F V
Se debe tener en cuenta que para utilizar estas expresiones se utilizan los operadores
relacionales como se mostró anteriormente en el ítem de operadores, entre los
cuales están <,>, <=, >=, =, <>.
En java se representa con el siguiente símbolo: ||
Ejemplo:
NO ((a<b) || (b>c) || (c=d) || (d<>f))

NO ((a<b) || (b>c) || (c=d) || (d<>f))
2.4.6 ESTRUCTURAS CONDICIONALES

Las estructuras condicionales permiten verificar el estado de expresiones lógicas
como son las comparaciones entre otras.
La estructura básica se representa en Pseudocódigo así:
Si (Condición) entonces
Instrucciones
F-si
Condición: es una o varias expresiones lógicas, en el cual si son varias expresiones

deben ser unidas a través de los operadores lógico Y, O.
Expresión Lógica: Son operadores unidos con operaciones relacionales como <,
>, <= ,>= ,= y <>. Ejemplo (a<b) , (b>=c).
Otras formas de representar esta estructura son las siguientes:
La estructura Si-sino-F-si
Se utiliza en el caso donde se tengan alternativas para valorar si son verdaderas o

falsas.
La condición o condiciones valoradas en el Si de la estructura determina si es
verdadera realiza las instrucciones dentro de esta estructura en caso de que sea
Falsa se realizan las instrucciones colocadas en la estructura del sino.
Pseudocódigo:
Si (Condiciones) Entonces
Instrucciones
Sino
Instrucciones
Fin-si
La estructura Si en cascada.
Se utiliza en situaciones donde se realizan varias verificaciones distintas para dar

solución a los diferentes problemas.
Pseudocódigo:
Instrucciones
Fin-si
Sino
Instrucciones
Sino
Instrucciones
Sino
Instrucciones
…. Pueden colocar otras condiciones de ser necesario….
Fin-si
Fin-si
Fin-si
…. Los cierres necesarios de acuerdo a las condiciones colocadas.
Ejemplo
1. Realizar un algoritmo que dada la edad de una persona le indique si puede o no

votar.
Datos Entrada: edad
Datos Salida: Votar o no votar
Proceso: En Colombia las personas que pueden votar son aquellas que tienen
de 18 años de edad en adelante.
Solución:
Inicio
Escribir(“Ingrese su Edad”)
Leer edad
Si (edad>=18) Entonces
Escribir (“Usted puede Votar en Colombia”)
Sino
Escribir (“Usted no puede Votar en Colombia”)
Fin-Si
2. Desarrolle un algoritmo que permita leer tres valores y almacenarlos en las
variables A, B y C respectivamente. El algoritmo debe imprimir cual es el mayor.
Recuerde constatar que los tres valores introducidos por el teclado sean valores
distintos.
Datos Entrada: Tres valores A, B y C
Datos Salida: El valor mayor
Proceso: Comparación entre A, B y C
Solución:
Inicio
Escribir(“Ingrese primer valor”)
Leer a
Escribir(“Ingrese segundo valor”)
Leer b
Escribir(“Ingrese tercer valor”)
Leer c
Si (a>b) y (a>c) Entonces
Escribir (“El valor mayor es ”,a)
Sino
Si (b>a) y (b>c) Entonces
Escribir (“El valor mayor es ”,b)
Sino
Escribir (“El valor mayor es ”,c)
Fin-Si
Fin-Si
Fin
En Netbeans esta estructura se representa así:
if(condiciones){ If (condiciones) { if(condiciones){

Instrucciones; Instrucciones Instrucciones
} else { }else{
Instrucciones; } if (condiciones) {
} Instrucciones
}else{
Instrucciones
}
}
Se puede utilizar cualquiera de las estructuras anteriores según sea necesario.

Ejemplos de Estructuras condicionales en Netbeans
 Este programa verifica si un número es positivo o negativo.
int n1,n2;
double d;
n1=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese el valor del
numerador”));
denominador”));
if(n2==0){
JOptionPane.showMessageDialog(null,”La división por cero no está
definida”);
}else{
d=n1/n2;
}
}
}
 Este programa verifica si una división puede o no realizarse.
int n1,n2;
double d;
numerador”));
denominador”));
if(n2==0){
definida”);
}else{
d=n1/n2;
}
}
}
1. 78A un trabajador le pagan según sus horas y una tarifa de pago por horas. si la
cantidad de horas trabajadas es mayor a 80 horas. la tarifa se incrementa en un
13% para las horas extras. Realizar un algoritmo que le permita calcular el
salario del trabajador dadas las horas trabajadas y la tarifa.
2. A un trabajador le descuentan de su sueldo el 10% si su sueldo es menor o igual

a 100000. por encima de 100000 y hasta 200000 el 5% del adicional, y por
encima de 200000 el 3% del adicional. Realizar un algoritmo que le permita
calcular el descuento y sueldo neto que recibe el trabajador dado su sueldo.
3. Dado un monto calcular el descuento considerando que por encima de 100000

el descuento es el 10% y por debajo de 100000 el descuento es el 2%.
4. Dado un tiempo en segundos, Realizar un algoritmo que le permita calcular los
segundos restantes que le correspondan para convertirse exactamente en
minutos.
5. Dado un tiempo en minutos, Realizar un algoritmo que le permita calcular los
días, horas y minutos que le corresponden.
6. Dada las horas trabajadas de una persona y la tarifa de pago. Realizar un
algoritmo que le permita calcular su salario e imprimirla.
7 BELTRAN, Fabio. Prácticas Introducción a la Programación.
7. Realizar un algoritmo que le permita emitir la factura correspondiente a una
compra de un artículo determinado, del que se adquieren una o varias unidades.
El IVA es del 16% y si el precio bruto (precio venta más IVA) es mayor de 1000
pesos se debe realizar un descuento del 5%.
8. Realizar un algoritmo que le permita ¿Calcular las raíces de una ecuación de

segundo grado (ax²+bx+c=0)? Tenga en cuenta que puede utilizar la formula
general.
9. ¿Dada la duración en minutos de una llamada realizar un algoritmo que le

permita calcular el costo, considerando?
a. Hasta tres minutos el costo es 0.50.
b. Por encima de tres minutos es 0.50 más 0.1 por cada minuto adicional a los
tres primeros.
10. ¿Dado el monto de una compra realizar un algoritmo que le permita calcular el
descuento considerado
a. Descuento es 10% si el monto es mayor a $50000
b. Descuento es 20% si el monto es mayor a $20000 bolivianos y menor o igual a
$50000.
c. no hay descuento si el monto es mayor o igual a $10000.
12. Ingresar un número determinado de segundos, realizar un algoritmo que le
permita convierta en horas, minutos y segundos.
13. Realizar un algoritmo que permita ingresar la hora, minutos y segundos y que
me calcule la hora en el siguiente segundo (“0=< H =<23”, “0=< M =<59” “0=<
S=<59”).
14. Realizar un algoritmo que permita que al dar la hora hh, mm, ss, muestre las
horas, minutos y segundos y también nos calcule la hora después de 2
segundos.
15. Realizar un algoritmo que permita que lea 2 números y deducir si están en
orden creciente o decreciente.
16. A un profesor le pagan según sus horas y una tarifa de pago por horas. Si la
cantidad de horas trabajadas es mayor a 40 horas, la tarifa se incrementa en
un 50 % para las horas extras. Realizar un algoritmo que calcule el salario del
profesor dadas las horas trabajadas y la tarifa.
17. Realizar un algoritmo que Calcule el perímetro de una circunferencia dado
su radio. Luego calcule el perímetro de la misma si se reduce al 50%. Luego
calcule el perímetro de la misma si se reduce al 25% con respecto al resultado
anterior.
2.4.7 ESTRUCTURAS SELECTIVAS
La estructura selectiva permite escoger dentro de un conjunto de opciones una

dentro del conjunto.
La estructura selectiva se representa en Pseudocódigo así:
DD (Variable) Haga
Caso valor1: Instrucciones;
.
Caso valor n: Instrucciones;
En otro caso: Instrucciones;
Fin-DD
Variable: Almacena el valor seleccionado del conjunto de opciones.
En Netbeans esta estructura se representa así:
switch (variable) {
Case valor1: Instrucciones;
break;
break;
break;
.
.
.
Case valor n: Instrucciones;
break;
default: Instrucciones;
}
2
Ejemplos de Estructuras condicionales en Netbeans

Desarrollar un programa que permita al usuario realizar la operación matemática
básica deseada (+, -, *, /) entre dos números enteros.
public class
ejercicio1 {
public static void main(String
args[]) { int n1,n2,op;
double d;
op=Integer.parseInt(JOptionPane.showInputDialog(“Menú
de
Opciones\n”+”1.Suma\n”+”2.Resta\n”+”3.Multiplicacion\n”+”4.Divisió
n\ n”+”Escoja la opción deseada”));
numerador”));
denominador”));
switch(op){
case 1: d=n1+n2;
JOptionPane.showMessageDialog(null,n1+” + “+n2+” =
“+d); break;
case 2: d=n1-n2;
JOptionPane.showMessageDialog(null,n1+” - “+n2+” =
“+d); break;
case 3: d=n1*n2;
JOptionPane.showMessageDialog(null,n1+” * “+n2+” =
“+d); break;
case 4:if(n2==0){
definida”);
}else{
d=n1/n2;
JOptionPane.showMessageDialog(null,n1+” / “+n2+” = “+d);
}
break
;
defau
lt:
JOptionPane.showMessageDialog(null,”Opción incorrecta “);
}
}
}
2.4.8 Problemas Propuestos
1. 9Supóngase que el importe del seguro obligatorio de un coche depende del

modelo del coche, del color y de la edad del conductor. Sean dos modelos de coche
A y B y los precios del seguro según el color:
3

Algoritmos, diagramas de flujo y programas, México D.F.:Alfaomega.2005,
Algoritmos, diagramas de flujo y programas, México D.F.:Alfaomega.2005,
Tabla 8. Precios Vs Modelo
MODE COLOR PREC

LO IO
A BLANCO 240.4
1
A METALIZA 330.0
DO 0
A OTROS 270.5
0
B BLANCO 300.0
0
B METALIZA 360.5
DO 0
B OTROS 330.0
0
Si el conductor tiene menos de 26 años, el precio se incrementa un 25%; si tiene

entre 26 y 30 años se incrementa un 10%; si tiene entre 31 y 65 años el precio no
se modifica; si tiene más de 65 años el precio se incrementará un 10%. Además,
en cualquier caso, hay que considerar que si el conductor tiene menos de 2 años
el permiso de conducir, el precio se incrementará un 25% adicional. Diseñar un
algoritmo que calcule el precio del seguro para un determinado modelo y un
determinado conductor.
2. Realizar un algoritmo que dada las figuras circulo, triangulo, rectángulo y
cuadrado, según desee el usuario calcular el perímetro de la figura.
3. Realizar un algoritmo que dadas las siguientes figuras cubo, esfera, cono cilindro,
según desee el usuario, calcular el volumen de la figura.
4. Escriba un algoritmo que lea tres números enteros de un supuesto triángulo,
determine si realmente forman un triángulo, y muestre el tipo de triángulo que es
(si es un triángulo).
a) triángulo: La suma de dos cualesquiera de los lados debe ser mayor que
el otro.
b) equilátero: todos los lados son iguales.
c) isósceles: solo dos lados son iguales.
d) escaleno: no tiene dos lados iguales.
5. 10Realice un algoritmo que permita calcular lo que hay que pagarle a un

trabajador teniendo en cuenta su sueldo y las horas extras trabajadas. Para el
pago de horas extras se toma en cuenta la categoría del trabajador-
4
Tabla 9. Precio Vs Categoría
TABLA DE CATEGORÍAS
CATEGO PRECIO HORAS
RÍA EXTRAS
1 $30000
2 $38000
3 $50000
4 $70000
Cada trabajador puede tener como máximo 30 horas extras, si tienen más sólo se
les pagarán 30. A los trabajadores con categoría mayor a 4 no debemos pagarles
horas extras.
2.5 ESTRUCTURAS REPETITIVAS

Las estructuras repetitivas permiten repetir los procesos un gran número de veces
según sea el caso.
Estas estructuras son utilizadas en procesos donde se requiere realizar las mismas
operaciones una gran cantidad de veces. Teniendo en cuanta lo anterior las
estructuras repetitivas se clasifican en:
CON BASE A UN CONTADOR
Contador: Es la variable que se encarga de enumerar los objetos que pertenecen
a un conjunto de acuerdo a una condición.
Acumulador: Es la variable encargada de adicionar los valores que se requieren
totalizar según sea el caso.
La estructura de ciclo repetitivo que pertenece a esta categoría es:
Ciclo Repetitivo Para

Sintaxis en pseudocódigo:
Para (i=Valor Inicial, Valor final, Incremento o decremento) haga
Instrucciones;
FPara
En Netbeans:
for (i=Valor inicial; i<=Valor Final; i++ o i--){
Instrucciones;
}
Ejemplos de Estructura Repetitiva para en Netbeans:
1. Elaborar un programa que muestre los números pares comprendidos entre 10
y 20 inclusive.
Solución en Netbeans:
public class
5
ejercicio1 {
args[]) { int i;
for (i=10;i<=20;i++){
JOptionPane.showMessageDialog(null,
i+”,”);
i=i+2;
}
}
}
2. Realizar un programa que calcule la tabla de sumar de un valor dado hasta el 10.
public class
ejercicio1 {
args[]) { int i, n, R;
n=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese el valor para
calcular la tabla de sumar “));
for
(i=1;i<=10;i++){
R=n+i;
JOptionPane.showMessageDialog(null, n+”+”+i+”=”+R);
}
}
}
3. Realizar un programa que dado N valores, calcule la cantidad de números

pares e impares.
Solución en Netbeans es:
public class
ejercicio1 {
args[]) { int i, n, num, p=0,im=0;
n=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese la
cantidad”)); for (i=1;i<=n;i++){
num=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese el valor”));
if(num % 2==0){
p=p+1
}else{
im=im+1
}
}
JOptionPane.showMessageDialog(null, “En el conjunto de valores
hay”+p+”pares”);
6
JOptionPane.showMessageDialog(null, “En el conjunto de

valores hay”+im+”impares”);
}
}
2.5.1 PROBLEMAS PROPUESTOS DE LA ESTRUCTURA REPETITIVA PARA
1. Un estudiante tiene problemas para manejar las tablas de multiplicar, por lo tanto
requiere para su ayuda un algoritmo que permita que dado un número N, calcule
l tabla de multiplicar de dicho número.
2. Una profesora de matemáticas requiere enseñar a sus estudiantes de una forma

fácil y rápida como determinar si un número es primo o no lo es (Número primo
es aquel que solo posee dos divisores y esos divisores son la unidad (1) y mismo
número), para lo cual se requiere que se realice un algoritmo que dado un número
determine si es un número primo o no es primo.
3. El Depto. de Seguridad Publica y Transito de Barranquilla, desea saber, de los

n autos que entran a la ciudad, cuantos entran con Stikers de cierto color.
Conociendo el último dígito de la placa de cada automóvil se puede determinar el
color del Stikers utilizando la siguiente relación:
DÍGIT COLO
O R
1o2 amarill
a
3o4 rosa
5o6 roja
7o8 verde
9o0 azul
Realice un algoritmo que asignes los Stikers teniendo en cuenta la tabla anterior.
3. Un docente requiere realizar un programa que permita ingresar las notas de los
tres cortes de N estudiantes que se especifica así: Primer parcial el cual tiene un
valor del 30% de la nota definitiva, Segundo parcial el cual tiene un valor del 30%
de la nota definitiva y examen final el cual tiene un valor del 40% de la nota
definitiva y el nombre, calcular la cantidad de estudiantes que obtuvieron notas
definitivas entre
4.0 y 5.0 y mostrar el nombre de dichos estudiantes, mostrando además que estos
estudiantes obtuvieron un beca por buen rendimiento académico.
4. Realizar un algoritmo dadas las edades de un grupo y los sexos del grupo, Calcular
el promedio de edades de hombres, mujeres y de todo el grupo de alumnos.
5. Dado un conjunto de N valores realizar un algoritmo para encontrar el menor valor

del conjunto números dados.
6. Dado un conjunto de N valores realizar un algoritmo para encontrar el mayor valor

del conjunto números dados.
7. Un grupo de N miembros de un club contra la obesidad desean saber cuánto han

7
bajado o subido de peso desde la última vez que se reunieron. Para esto se debe
realizar un ritual de pesaje en donde cada uno se pesa en m básculas distintas para
así tener el promedio más exacto de su peso. Si existe diferencia positiva entre este
promedio de peso y el peso de la última vez que se reunieron, significa que subieron
de peso. Pero si la diferencia es negativa, significa que bajaron. Lo que el problema
requiere es que por cada persona se imprima un letrero que diga: “SUBIO” o “BAJO”
y la cantidad de kilos que subió o bajo de peso.
8. Se desea obtener el promedio de g grupos que están en un mismo año escolar;

siendo que cada grupo puede tener n alumnos que cada alumno puede llevar m
materias y que en todas las materias se promedian tres calificaciones para obtener
el promedio de la materia. Realizar un algoritmo para desplegar el promedio de
los grupos, el promedio de cada grupo y el promedio de cada alumno.
9. Calcular la suma siguiente:

100 + 98 + 96 + 94 + . . . + 0 en este orden
10. Leer por cada alumno de Diseño estructurado de algoritmos su número de

control y su calificación en cada una de las 5 unidades de la materia. Al final que
escriba el número de control del alumno que obtuvo mayor promedio. Suponga que
los alumnos tienen diferentes promedios.
11. Realizar un algoritmo que calcule la potencia de un número dada la base y el

exponente. Ejemplo
BaseExponente =
Base1*Base2*Base3*….*Baseexponente 34=3*3*3*3=81
12. Realizar un algoritmo que calcule el factorial de un número, teniendo en

cuenta que el factorial está definido así:
Fact(3)=1*2*3=6
Además el factorial de 0 y 1 es 1.
2.5.2 Estructuras Repetitivas con Base a una Condición
Este tipo de estructuras repetitivas se caracteriza por:
o No necesariamente se conoce el número de veces que se repite el proceso.

o Se utilizan las condiciones para generar la repetición del proceso, siempre y
cuando se cumpla la condición, es decir, sea verdadera. El ciclo culmina
cuand0o la condición se convierte en falsa, por lo tanto es necesario que las
variables que participan en la condición sean modificadas dentro del ciclo para
que la condición pueda convertirse en falsa.
o Las operaciones que se repiten son las que son comunes para los objetos a
los cuales se les realizará dichas operaciones.
o Al igual que el ciclo anterior se utilizan conceptos de Acumulador y Contador.
8
Ciclo Repetitivo Mientras Que
Sintaxis en pseudocódigo del ciclo:

Mq (Condición)
haga Instrucciones
FMq
Sintaxis en Netbeans del ciclo:
while
(condición) {
Instrucciones;
}
Ciclo Repetitivo Haga Mientras Que

Características:
o La condición de repetición del ciclo es evaluada al final de la realización de las
operaciones especificadas dentro del ciclo.
o Este solo culmina la repetición cuando la condición es falsa.
Sintaxis en pseudocódigo del ciclo:
Haga
instruccion
es
}mq(condición)
Sintaxis en Netbeans del ciclo:

do{
instruccione
s;
}while(condición);
Ejemplos
1. Desarrolle un programa que permita calcular Promedio de Notas de N

estudiantes; finaliza cuando N = 0.
public class
ejercicio1 {
args[]) { int N,C;
double S=0,P,nota;
N=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese el número de
estudiantes”));
9
C=N;
While (N!=0) {
nota=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese la
nota”));
S=S+not
a;
N=N-1;
}
P=S/C;
JOptionPane.showMessageDialog(null, “El promedio del grupo es”+P);
}
}
2. Realizar un programa que dados varios números , los acumule hasta que se
ingrese el valor de cero. Mostrar el valor acumulado y la cantidad de valores.
public class
ejercicio1 {
args[]) { int C=0;
double S=0,num;
num=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese el
número
“));
While (num !=
0) {
S=S+num;
num=Double.parseDouble(JOptionPane.showInputDialog(“Ingrese el valor”));
C=C+1;
}
JOptionPane.showMessageDialog(null, “El valor Acumulado es ”+S+” de “+C+”
números”));
}
}
3. Realizar un algoritmo que calcule la cantidad de divisores de un número entero.

public class
divisores {
args[]) { int C=0,n,I,D;
n=Integer.parseInt(JOptionPane.showInputDialog(“Ingrese el número “));
I=1;
D=0;
do {
if(n%I==0
){
D=D+1;
10
}
I=I+
1;
}while(I<=n);
JOptionPane.showMessageDialog(null, n+“ contiene ”+D+” Divisores “));
}
}
Tabla 10. Estructura Repetitiva
PRIMITIVA
REPETITIVA
Mq (Condición) while while
haga (condición) { (condición) {
Instrucciones Instrucciones; Instrucciones;
FMq } }
Para (i=Valor Inicial, Valor for (i=Valor inicial; for (i=Valor inicial;
final, Incremento o i<=Valor Final; i++ o i-- i<=Valor Final; i++ o
decremento) haga ){ Instrucciones; i--){ Instrucciones;
Instrucciones; } }
FPara
Haga do{ do{
instruccion instruccion instruccion
es es; es;
}mq(condición) }while(condición); }while(condición);
2.5.3 Problemas Propuestos de la Estructura Repetitiva con Base a una

Condición
1. Realizar un algoritmo que dado un número calcular el producto de los dígitos

distintos.
Ejemplo: 284=2*8*4=64.
2. Realizar un algoritmos que dado un número calcular la suma de los dígitos hasta
que el resultado de dicha suma dé como resultado un número de una cifra.
Ejemplo: 9856=9+8+5+6=28=2+8=10=1+0=1
3. Se tienen como datos los importes de las ventas de cada una de las sucursales
de una empresa, junto con el código de sucursal (1, 2, 3, 4 ó 5).- Cada sucursal
puede tener varias ventas. Los datos no están ordenados por código de sucursal.
Un código igual a cero indica fin de datos.- Obtener el total de ventas para cada
sucursal.
4. 11Realizar un algoritmo que pregunte al usuario un número comprendido en

el rango de 1 a 5. El algoritmo deberá validar el número, de manera que no continúe
11
la ejecución del programa mientras no se escriba un número correcto.
5. 12Hacer un programa que de vueltas y en cada vuelta realice las potencias de

5. En cada vuelta se pide al operador SI DESEA CONTINUAR (1 o 0) si el operador
ingresa un cero ya no continuará dando vueltas.
10 Urbaez. Wilder. Estructuras Cíclicas.

http://www.desarrolloweb.com/articulos/2249.php
11 Barueto Enrique. Ejercicios de Estructuras Repetitivas.
http://enriquebarrueto0.tripod.com/clases/clase5/ clase5_2.htm
11 Barueto Enrique. Ejercicios de Estructuras Repetitivas Soluciones
http://enriquebarrueto0.tripod.com/ ebarrueto1/solu2.htm
6. Implemente el siguiente juego: el programa seleccionará un número aleatorio

entre 0 y 100 y el jugador debe acertarlo 13. En cada intento el jugador propondrá
una solución y se le informará si el número a acertar es menor o mayor que el
propuesto. El juego termina cuando se acierte la cifra o haya realizado un máximo
de 12 intentos en cuyo caso se le mostrará al jugador la calificación obtenida según
la siguiente tabla:
Tabla 11. Intentos Vs Categoría
Número de intentos Categoría

1-3 Suertudo
4-6 Genio
7 No está mal
8 Se puede mejorar
>=0 Que Pasa Amigo
12
GUIA PSENT
INDICE
INTRODUCCIÓN ................................................................................................... 4
¿QUÉ ES PSEINT? ............................................................................................... 5
La interfaz y el área de trabajo ............................................................................. 5
EL PSEUDOCÓDIGO ............................................................................................ 7
FORMA GENERAL DE UN ALGORITMO EN PSEUDOCÓDIGO ......................... 7
TIPOS DE DATOS ................................................................................................. 7
Tipos de Datos Simples .................................................................................... 8
Estructuras de Datos: Arreglos ......................................................................... 8
Dimensionamiento (Arreglos-Arrays) ................................................................ 8
EXPRESIONES ..................................................................................................... 9
Operadores ....................................................................................................... 9
Funciones matemática .................................................................................... 10
PRIMITIVAS SECUENCIALES (COMANDOS DE ENTRADA, PROCESO Y
SALIDA) .......................................................................................................... 11
Lectura o entrada ............................................................................................ 11
Asignación o proceso...................................................................................... 11
Escritura o salida ............................................................................................ 11
ESTRUCTURAS DE CONTROL (PROCESO) .................................................... 12
Condicionales..................................................................................................... 12
Si-Entonces (If-Then) ...................................................................................... 12
Selección Múltiple (Select If)........................................................................... 12
Repetitivas ......................................................................................................... 13
Mientras Hacer (while) .................................................................................... 13
Repetir Hasta Que (do-while).......................................................................... 14
Para (for)......................................................................................................... 14
EJECUCIÓN PASO A PASO ............................................................................. 145
EJEMPLOS DE ALGORITMOS ......................................................................... 167
EJERCICIOS RESUELTOS UTILIZANDO PSEINT ........................................... 212
13
INTRODUCCIÓN
El siguiente manual muestra de manera sencilla como manejar el programa PSeint.
Cuando nos enfrentamos a un problema en la vida cotidiana, su resolución requiere

que sigamos una serie de pasos; para tal fin. El conjunto ordenado de pasos
seguidos con el fin de resolver un problema o lograr un objetivo es conocido como
algoritmo.
Un algoritmo es un conjunto de instrucciones que especifica la secuencia de

operaciones a realizar, en orden, para resolver un problema específico; en otras
palabras, un algoritmo es una fórmula para la resolución de un problema.
La definición de un algoritmo debe describir tres partes: Entrada, Proceso y Salida,

asi:
 Entrada: Información dada al algoritmo, o conjunto de instrucciones que
generen los valores con que ha de trabajar.
 Proceso: Cálculos necesarios para que a partir de un dato de entrada se
llegue a los resultados.
 Salida: Resultados finales o transformación que ha sufrido la información
de entrada a través del proceso.
Cuando se formula un algoritmo el objetivo es ejecutar este en un computador, sin

embargo, para que este entienda los pasos para llevar a cabo nuestro algoritmo
debemos indicárselo siguiendo un conjunto de instrucciones y reglas que este
entienda, y estas instrucciones son abstraídas en lo que conocemos como lenguaje
de programación.
Un algoritmo codificado siguiendo un lenguaje de programación es conocido como

programa. Antes de aprender un lenguaje de programación es necesario aprender
la metodología de programación, es decir la estrategia necesaria para resolver
problemas mediante programas.
Como punto de partida se aborda la manera como es representado un algoritmo.

Básicamente analizamos dos formas, la representación usando pseudocódigo y la
representación usando diagramas de flujo.
Un diagrama de flujo es un diagrama que utiliza símbolos (cajas) estándar y que

tiene los pasos del algoritmo escritos en esas cajas unidas por flechas,
denominadas líneas de flujo, que indican las secuencia que debe ejecutar el
algoritmo
Por otro lado, el pseudocódigo es un lenguaje de especificación (descripción) de

algoritmos. El uso de tal lenguaje hace el paso de codificación final (traducción al
14
lenguaje de programación) relativamente fácil, por lo que este es considerado un

primer borrador de la solución del programa.
¿Qué es PSEINT?
PSeInt es principalmente un intérprete de pseudocódigo. El proyecto nació como

trabajo final para la cátedra de Programación I de la carrera Ingeniería en
Informática de la Universidad nacional del Litoral, razón por la cual el tipo de
pseudocódigo que interpreta está basado en el pseudocódigo presentado en la
cátedra de Fundamentos de Programación de dicha carrera. Actualmente incluye
otras funcionalidades como editor y ayuda integrada, generación de diagramas de
flujo o exportación a código C++ (en etapa experimental).
El proyecto se distribuye como software libre bajo licencia GPL.
Para descargarlo o conseguir actualizaciones visite http://pseint.sourceforge.net
La interfaz y el área de trabajo

15
Las funciones: botones
Abre un nuevo documento

Busca un fichero (archivo)
Guardar y guardar como
Deshacer y Rehacer respectivamente
Cortar
Copiar y pegar
Corregir indentado
Buscar
Ejecutar el algoritmo
Ejecutar paso a paso
Dibujar diagrama de flujo

Ayuda/contiene algunos ejemplos
16
El Pseudocódigo
Las características del este pseudolenguaje fueron propuestas en 2001 por el

responsable de la asignatura Fundamentos de Programación (Horacio Loyarte) de
la carrera de Ingeniería Informática de la FICH-UNL. Las premisas son:
• Sintaxis sencilla.
• Manejo de las estructuras básicas de control.
• Solo 3 tipos de datos básicos: numérico, carácter/cadenas de caracteres y
lógico (verdadero/falso).
• Estructuras de datos: arreglos.
Forma general de un algoritmo en Pseudocódigo
Todo algoritmo en pseudocódigo de Pseint tiene la siguiente estructura general:
Proceso SinTitulo
accion 1;
accion 1;
.
.
.
accion n;
FinProceso
Comienza con la palabra clave Proceso seguida del nombre del programa, luego le
sigue una secuencia de instrucciones y finaliza con la palabra FinProceso. Una
secuencia de instrucciones es una lista de una o más instrucciones, cada una
terminada en punto y coma.
Las acciones incluyen operaciones de entrada y salida, asignaciones de variables,

condicionales si-entonces o de selección múltiple y/o lazos mientras, repetir o para.
Tipos de datos
• Tipos Simples: Numérico, Lógico, Caracter.

• Estructuras de Datos: Arreglos.
Los identificadores, o nombres de variables, deben constar sólo de letras, números

y/o guión_bajo (_), comenzando siempre con una letra.
Tipos de Datos Simples
17
Existen tres tipos de datos básicos:

• Numérico: números, tanto enteros como decimales. Para separar decimales
se utiliza el punto. Ejemplos: 12 23 0 -2.3 3.14
• Lógico: solo puede tomar dos valores: VERDADERO o FALSO.
• Carácter: caracteres o cadenas de caracteres encerrados entre comillas
(pueden ser dobles o simples). Ejemplos 'hola' "hola mundo" '123' 'FALSO'
'etc'
Los tipos de datos simples se determinan automáticamente cuando se crean las

variables. Las dos acciones que pueden crear una variable son la lectura(LEER) y
la asignación(<-). Por ejemplo, la asignación "A<-0;" está indicando implícitamente
que la variable A será una variable numérica. Una vez determinado el tipo de dato,
deberá permanecer constante durante toda la ejecución del proceso; en caso
contrario el proceso será interrumpido.
Estructuras de Datos: Arreglos
Los arreglos son estructuras de datos homogéneas (todos sus datos son del mismo
tipo) que permiten almacenar un determinado número de datos bajo un mismo
identificador, para luego referirse a los mismo utilizando uno o más subíndices. Los
arreglos pueden pensarse como vectores, matrices, etc.
Para poder utilizar un arreglo, primero es obligatorio su dimensionamiento; es decir,

definirlo declarando los rangos de sus subíndices, lo cual determina cuantos
elementos se almacenarán y como se accederá a los mismos.
Dimensionamiento (Arreglos-Arrays)
La instrucción Dimensión permite definir un arreglo, indicando sus dimensiones.
Dimension <identificador> (<maxl>,...,<maxN>);
Esta instrucción define un arreglo con el nombre indicado en <indentificador> y N

dimensiones. Los N parámetros indican la cantidad de dimensiones y el valor
máximo de cada una de ellas. La cantidad de dimensiones puede ser una o más, y
la máxima cantidad de elementos debe ser una expresión numérica positiva.
Se pueden definir más de un arreglo en una misma instrucción, separándolos con

una coma (,).
Dimension <ident1> (<max11>,...,<max1N>),..., <identM>

(<maxM1>,...,<maxMN>)
18
Expresiones
• Operadores.
• Funciones.
Operadores
Este pseudolenguaje dispone de un conjunto básico de operadores que pueden
ser utilizados para la construcción de expresiones más o menos complejas.
Las siguientes tablas exhiben la totalidad de los operadores de este lenguaje

reducido:
Operador Significado Ejemplo

Relacionales
> Mayor que 3>2
< Menor que 'ABC'<'abc'
= Igual que 4=3
<= Menor o igual que 'a'<='b'
>= Mayor o igual que 4>=5
<> Distinto que Var1<>var2
Lógicos
&óY Conjunción (y). (7>4) & (2=1) //falso
|óO Disyunción (o). (1=1 | 2=1) //verdadero
~ ó NO Negación (no). ~(2<5) //falso
Algebraicos
+ Suma total <- cant1 + cant2
- Resta stock <- disp – venta
* Multiplicación area <- base * altura
/ División porc <- 100 * parte / total
^ Potenciación sup <- 3.41 * radio ^ 2
% ó MOD Módulo (resto de la resto <- num MOD div
división entera)
La jerarquía de los operadores matemáticos es igual a la del álgebra, aunque

puede alterarse mediante el uso de paréntesis.
Funciones matemática
Las funciones en el pseudocódigo se utilizan de forma similar a otros lenguajes. Se

coloca su nombre seguido de los argumentos para la misma encerrados entre
paréntesis (por ejemplo trunc(x)). Se pueden utilizar dentro de cualquier expresión,
y cuando se evalúe la misma, se reemplazará por el resultado correspondiente.
Actualmente, todas la funciones disponibles son matemáticas (es decir que
19
devolverán un resultado de tipo numérico) y reciben un sólo parámetro de tipo

numérico. A continuación se listan las funciones integradas disponibles:
Función Significado
RC(X) Raíz Cuadrada de X
ABS(X) Valor Absoluto de X
LN(X) Logaritmo Natural de X
EXP(X) Función Exponencial de X
SEN(X) Seno de X
COS(X) Coseno de X
TAN(X) Tangente de X
TRUNC(X) Parte entera de X
REDON(X) Entero más cercano a X
AZAR(X) Entero aleatorio entre 0 y x-1
La función raíz cuadrada no debe recibir un argumento negativo.

La función exponencial no debe recibir un argumento menor o igual a cero.
Primitivas Secuenciales (Comandos de Entrada, Proceso y Salida)

• Lectura (Entrada).
• Asignación (Proceso).
• Escritura (Salida).
Lectura o entrada
La instrucción Leer permite ingresar información desde el

ambiente.
Leer <variablel> , <variable2> , ... ,

<variableN> ;
Esta instrucción lee N valores desde el ambiente (en este caso el teclado) y los
asigna a las N variables mencionadas. Pueden incluirse una o más variables, por lo
tanto el comando leerá uno o más valores.
Asignación o proceso
La instrucción de asignación permite almacenar una valor en

una variable.
<variable> <- <expresión> ;
Al ejecutarse la asignación, primero se evalúa la expresión de la derecha y luego se

asigna el resultado a la variable de la izquierda. El tipo de la variable y el de la
expresión deben coincidir.
20
Escritura o salida
La instrucción Escribir permite mostrar valores al

ambiente.
Escribir <exprl> , <expr2> , ... , <exprN> ;
Esta instrucción imprime al ambiente (en este caso en la pantalla) los valores
obtenidos de evaluar N expresiones. Dado que puede incluir una o más
expresiones, mostrará uno o más valores.
Estructuras de Control (Proceso)

• Condicionales
o Si-Entonces
o Selección Múltiple
• Repetitivas
o Mientras
o Repetir
o Para
Condicionales
Si-Entonces (If-Then)
La secuencia de instrucciones ejecutadas por la

instrucción Si-Entonces-Sino depende del valor de
una condición lógica.
Si <condición> Entonces
<instrucciones>
Sino
<instrucciones>
FinSi
21
Al ejecutarse esta instrucción, se evalúa la condición y se ejecutan las instrucciones

que correspondan: las instrucciones que le siguen al Entonces si la condición es
verdadera, o las instrucciones que le siguen al Sino si la condición es falsa. La
condición debe ser una expresión lógica, que al ser evaluada retorna Verdadero o
Falso.
La cláusula Entonces debe aparecer siempre, pero la cláusula Sino puede no estar.
En ese caso, si la condición es falsa no se ejecuta ninguna instrucción y la ejecución
del programa continúa con la instrucción siguiente.
Selección Múltiple (Select If)
La secuencia de instrucciones ejecutada por una instrucción

Según depende del valor de una variable numérica.
Segun <variable> Hacer

<número1>: <instrucciones>
<número2>,<número3>: <instrucciones>
<...>
De Otro Modo: <instrucciones>

FinSegun
Esta instrucción permite ejecutar opcionalmente varias acciones posibles,

dependiendo del valor almacenado en una variable de tipo numérico. Al ejecutarse,
se evalúa el contenido de la variable y se ejecuta la secuencia de instrucciones
asociada con dicho valor.
Cada opción está formada por uno o más números separados por comas, dos
puntos y una secuencia de instrucciones. Si una opción incluye varios números, la
secuencia de instrucciones asociada se debe ejecutar cuando el valor de la variable
es uno de esos números.
Opcionalmente, se puede agregar una opción final, denominada De Otro Modo,

cuya secuencia de instrucciones asociada se ejecutará sólo si el valor almacenado
en la variable no coincide con ninguna de las opciones anteriores.
22
Repetitivas
Mientras Hacer (while)
La instrucción Mientras ejecuta una secuencia de instrucciones mientras una

condición sea verdadera.
Mientras <condición> Hacer

<instrucciones>
FinMientras
Al ejecutarse esta instrucción, la condición es evaluada. Si la condición resulta

verdadera, se ejecuta una vez la secuencia de instrucciones que forman el cuerpo
del ciclo. Al finalizar la ejecución del cuerpo del ciclo se vuelve a evaluar la condición
y, si es verdadera, la ejecución se repite. Estos pasos se repiten mientras la
condición sea verdadera.
Note que las instrucciones del cuerpo del ciclo pueden no ejecutarse nunca, si al
evaluar por primera vez la condición resulta ser falsa.
Si la condición siempre es verdadera, al ejecutar esta instrucción se produce un
ciclo infinito. A fin de evitarlo, las instrucciones del cuerpo del ciclo deben contener
alguna instrucción que modifique la o las variables involucradas en la condición,
de modo que ésta sea falsificada en algún momento y así finalice la ejecución del
ciclo.
Repetir Hasta Que (do-while)
La instrucción Repetir-Hasta Que ejecuta una secuencia de

instrucciones hasta que la condición sea verdadera.
Repetir
<instrucciones>
Hasta Que <condición>
Al ejecutarse esta instrucción, la secuencia de instrucciones que forma el cuerpo del

ciclo se ejecuta una vez y luego se evalúa la condición. Si la condición es falsa, el
cuerpo del ciclo se ejecuta nuevamente y se vuelve a evaluar la condición. Esto se
repite hasta que la condición sea verdadera.
Note que, dado que la condición se evalúa al final, las instrucciones del cuerpo del
ciclo serán ejecutadas al menos una vez.
23
Además, a fin de evitar ciclos infinitos, el cuerpo del ciclo debe contener alguna
instrucción que modifique la o las variables involucradas en la condición de modo
que en algún momento la condición sea verdadera y se finalice la ejecución del ciclo.
Para (for)
La instrucción Para ejecuta una secuencia de instrucciones un

número determinado de veces.
Para <variable> <- <inicial> Hasta <final> ( Con Paso <paso> ) Hacer
<instrucciones>
FinPara
Al ingresar al bloque, la variable <variable> recibe el valor <inicial> y se ejecuta la

secuencia de instrucciones que forma el cuerpo del ciclo. Luego se incrementa la
variable <variable> en <paso> unidades y se evalúa si el valor almacenado en
<variable> superó al valor <final>. Si esto es falso se repite hasta que <variable>
supere a <final>. Si se omite la cláusula Con Paso <paso>, la variable <variable>
se incrementará en 1.
Ejecución Paso a Paso
La ejecución paso a paso permite realizar un seguimiento más detallado de la

ejecución del algoritmo. Es decir, permite observar en tiempo real qué instrucciones
y en qué orden se ejecutan, como así también observar el contenido de variables o
expresiones durante el proceso.
Para acceder al panel de ejecución paso a paso puede o bien utilizar la opción
"Mostrar Panel de Ejecución Paso a Paso" del menú "Configuración", o bien hacer
click sobre el botón de ejecución paso a paso en la barra accesos rápidos (ubicado
entre los botones para ejecutar y dibujar diagrama de flujo).
El botón "Comenzar" del panel sirve para iniciar la ejecución automática. Cuando
lo utilice, el algoritmo comenzará a ejecutarse lentamente y cada instrucción que se
vaya ejecutando según el flujo del programa se irá seleccionando en el código de
dicho algoritmo. La velocidad con que avance la ejecución del algoritmo,
inicialmente depende de la seleccionada en el menú "Configuración", aunque
mientras la ejecución paso a paso está en marcha, puede variarla desplazando el
control rotulado como "Velocidad" en el panel.
Otra forma de comenzar la ejecución paso a paso es utilizar el botón "Primer Paso"
del mismo panel. Este botón iniciará la ejecución, pero a diferencia de "Comenzar"
no avanzará de forma automática, sino que se parará sobre la primer línea del
programa y esperará a que el usuario avance manualmente cada paso con el mismo
botón (que pasará a llamarse "Avanzar un Paso".
El botón "Pausar/Continuar" sirve para detener momentáneamente la ejecución del

24
algoritmo y reanudarla nuevamente después. Detener el algoritmo puede servir para

analizar el código fuente, o para verificar qué valor tiene asignado una variable o
cuanto valdría una determinada expresión en ese punto.
Para determinar el valor de una variable o expresión, una vez pausada la ejecución
paso a paso, utilice el botón "Evaluar...". Aparecerá una ventana donde podrá
introducir cualquier nombre de variable o expresión arbitraria (incluyendo funciones
y operadores), para luego observar su valor.
Finalmente, la forma más completa para analizar la ejecución es la denominada

Prueba de Escritorio.
Antes de comenzar la ejecución, puede seleccionar qué variables o expresiones

desea visualizar durante la ejecución. Para ello utilice el botón "Prueba de Esc." y
modifique la lista. Cuando la ejecución comience, por cada línea ejecutada, se
añadirá un renglón en la tabla de la prueba de escritorio (se mostrará en la parte
inferior de la ventana como un panel acoplable) indicando el número de línea y los
valores de todas la variables y expresiones especificadas.
Algunas Observaciones
 Se pueden introducir comentarios luego de una instrucción, o en líneas

separadas, mediante el uso de la doble barra ( // ). Todo lo que precede a //,
hasta el fin de la línea, no será tomado en cuenta al interpretar el algoritmo.
No es válido introducir comentario con /* y */.
 No puede haber instrucciones fuera del proceso (antes de PROCESO, o

después de
FINPROCESO), aunque si comentarios.
 Las estructuras no secuenciales pueden anidarse. Es decir, pueden contener

otras adentro, pero la estructura contenida debe comenzar y finalizar dentro
de la contenedora.
 Los identificadores, o nombres de variables, deben constar sólo de letras,

números y/o guión bajo (_), comenzando siempre con una letra.
 Los tipos de datos de las variables no se declaran explícitamente, sino que

se infieren a partir de su utilización.
 Las constantes de tipo carácter se escriben entre comillas ( " ).
 En las constantes numéricas, el punto ( . ) es el separador decimal.
 Las constantes lógicas son Verdadero y Falso.
 Actualmente este pseudolenguaje no contempla la creación de nuevas

funciones o subprocesos.
25
Ejemplos de Algoritmos
PSeInt incluye un conjunto de algoritmos de diferentes niveles de dificultad para

ejemplificar la sintaxis y el uso del pseudocódigo. A continuación se describen los
ejemplos disponibles:
1. AdivinaNumero: Sencillo juego en el que el usuario debe adivinar un número

aleatorio.
// Juego simple que pide al usuario que adivine un numero en 10 intentos

Proceso Adivina_Numero
intentos<-9;
num_secreto <- azar(100)+1;
Escribir "Adivine el número (de 1 a 100):";

Leer num_ingresado;
Mientras num_secreto<>num_ingresado Y intentos>0 Hacer
Si num_secreto>num_ingresado Entonces
Escribir "Muy bajo";
Sino
Escribir "Muy alto";
FinSi
Escribir "Le quedan ",intentos," intentos:";

Leer num_ingresado;
intentos <- intentos-1;
FinMientras
Si intentos=0 Entonces
Escribir "El numero era: ",num_secreto;
Sino
Escribir "Exacto! Usted adivinó en ",11-intentos," intentos.";
FinSi
FinProceso
2. Mayores: Busca los dos mayores de una lista de N datos.
// Busca los dos mayores de una lista de N datos

Proceso Mayores
Dimension datos[200];
Escribir "Ingrese la cantidad de datos:";
Leer n;
Para i<-1 Hasta n Hacer
Escribir "Ingrese el dato ",i,":";
Leer datos[i];
FinPara
26
Si datos[1]>datos[2] Entonces
may1<-datos[1];
may2<-datos[2];
Sino
may1<-datos[2];
may2<-datos[1];
FinSi

Si datos[i]>may1 Entonces
may2<-may1;
may1<-datos[i];
Sino
Si datos[i]>may2 Entonces
may2<-datos[i];
FinSi
FinSi
FinPara
Escribir "El mayor es: ",may1;

Escribir "El segundo mayor es: ",may2;
FinProceso
3. Triángulo: Este algoritmo determina a partir de las longitudes de tres lados de

un triángulo si corresponden a un triángulo rectángulo (para utiliza la relación de
Pitágoras, tomando los dos lados de menor longitud como catetos), y en caso
afirmativo informa el área del mismo. Lee los tres lados de un triángulo rectángulo,
determina si corresponden (por Pitágoras) y en caso afirmativo calcula el área
Proceso TrianguloRectangulo
// cargar datos
Escribir "Ingrese el lado 1:";
Leer l1;
Leer l2;
Leer l3;
// encontrar la hipotenusa (mayor lado)

Si l1>l2 Entonces
cat1<-l2;
Si l1>l3 Entonces
hip<-l1;
cat2<-l3;
Sino
27
hip<-l3;
cat2<-l1;
FinSi
Sino
cat1<-l1;
Si l2>l3 Entonces
hip<-l2;
cat2<-l3;
Sino
hip<-l3;
cat2<-l2;
FinSi
FinSi
// ver si cumple con Pitágoras

Si hip^2 = cat1^2 + cat2^2 Entonces
// calcular área
area<-(cat1*cat2)/2;
Escribir "El área es: ",area;
Sino
Escribir "No es un triángulo rectángulo.";
FinSi
FinProceso
4. OrdenaLista: Este ejemplo almacena una lista de nombres en un arreglo y luego

los ordena alfabéticamente. El método de ordenamiento es relativamente simple.
Para la entrada de datos se utiliza una estructura MIENTRAS, sin saber a priori la
cantidad de datos que se ingresarán. Se ingresa una lista de nombres (la lista
termina cuando se ingresa un nombre en blanco) no permitiendo ingresar repetidos
y luego se ordena y muestra.
Proceso OrdenaLista Dimension lista[200];
Escribir "Ingrese los nombres (enter en blanco para terminar):";
// leer la lista
cant<-0;
Leer nombre;
Mientras nombre<>"" Hacer
cant<-cant+1;
lista[cant]<-nombre;
Repetir // leer un nombre y ver que no esté ya en la lista
Leer nombre;
se_repite<-Falso;
Para i<-1 Hasta cant Hacer
Si nombre=lista[i] Entonces
28
se_repite<-Verdadero;
FinSi
FinPara
Hasta Que NO se_repite
FinMientras
// ordenar
Para i<-1 Hasta cant-1 Hacer
// busca el menor entre i y cant
pos_menor<-i;
Para j<-i+1 Hasta cant Hacer
Si lista[j]<lista[pos_menor] Entonces
pos_menor<-j;
FinSi
FinPara
// intercambia el que estaba en i con el menor que encontro

aux<-lista[i];
lista[i]<-lista[pos_menor];
lista[pos_menor]<-aux;
FinPara
// mostrar cómo queda la lista

Escribir "La lista ordenada es:";
Para i<-1 Hasta cant Hacer
Escribir " ",lista[i];
FinPara
FinProceso
5. Promedio: Ejemplo básico de uso de un acumulador y la estructura de control

PARA para calcular el promedio de un conjunto de valores.
// Calcula el promedio de una lista de N datos
Proceso Promedio
Escribir "Ingrese la cantidad de datos:";

Leer n;
acum<-0;

Leer dato;
acum<-acum+dato;
FinPara
29
prom<-acum/n;
Escribir "El promedio es: ",prom;

FinProceso
Ejercicios Resueltos utilizando PSeint
1. Escribir un nombre y saludar
//Programa para Escribir un saludo con el nombre: RPC
Proceso Escribir_nombre
Escribir "Programa para saludar"; //muestra en pantalla:
"Progr...saludar"
Escribir "Escribe tu nombre"; //instrucción
Leer a; //ingresa por teclado un texto
Escribir "Hola! Tu nombre es: ", " ****", a, "****"; //muestra un saludo
con el nombre escrito
FinProceso //fin del proceso
30
2. Sumar dos números ‘a’ y ‘b’
//Algoritmo para sumar dos números enteros 'a' y 'b' desarrollado por RPC
Proceso sumar_a_b //Proceso: ¿qué desea hacer el 'programa'?: sumar a y

b
Escribir "ingrese a:" ; //escribe/muestra en pantalla
Leer a; //introduce por teclado el valor de 'a'
Escribir "ingrese b:" ;
Leer b; //introduce por teclado el valor de 'b'
Suma<-(a+b); //operador Suma=a+b
Escribir "La suma de a + b es:",Suma ; //escribe/muestra en pantalla
+ el valor Suma
FinProceso
31
3. Escribir un nombre 5 veces
//Programa para Escribir un nombre y repetir 5 veces: RPC
Proceso repetir_nombre
Escribir "Ingresa tu nombre"; //muestra en teclado: ingresa ti nombre
leer nombre; //leer/ingresar por teclado el nombre
Para i<-1 Hasta 5 Con Paso 1 Hacer //para: use la opción del menú
de la derecha
Escribir " " , nombre; // escribe el nombre 5 veces, las comillas
le dan espacio
FinPara //fin del comando "Para"
FinProceso //fin del proceso
4. Escribir un el incremento en 1 de un nº menor a 10 hasta 10
//Escribir el incremento en 1 de un número menor a 10 hasta 10: RPC

32
Proceso sin_titulo
escribir "Digita un numero"; //Muestra en pantalla la instrucción
leer a; //ingresa la variable 'a' (número menor a 10)
Para a<-a+1 Hasta 10 Con Paso 1 Hacer //Comando Para: está al
final derecha de este IDE
escribir " ", a; //El espacio entre comillas ("") solo ajusta el
texto debajo de la variable ingresada
FinPara //Fin del comando Para
FinProceso //Fin del proceso
5. Sumar n números utilizando MIENTRAS
//Suma de n números : RPC
Proceso suma_n_numeros
33
Escribir "Ingrese un Número (0 para Calcular)";

Leer a;
tot<-0
Mientras a<>0 Hacer
tot<-tot+a;
Escribir "Ingrese otro Numero (0 para Calcular)";
Leer a;
FinMientras
Escribir "Total: ",tot;
FinProceso
6. Sumar n números utilizando REPETIR
//Sumar un número hasta que el número sea a=0
Proceso sumar_numero
Repetir
34
a<-a
tot<-tot
tot<-Tot+a;
Escribir "Ingrese un número (0 para salir)";
Leer a;
Hasta Que a = 0
Escribir "Total: ",tot;
FinProceso
7. Conocer si un número ‘n’ está en el rango de 0 a 10 con mensaje de

Correcto/Error utilizando SEGÚN HACER:
//Conocer si un número está en el rango de 0-10 con mensaje Correcto/Error: RPC
Proceso numero_entre_0_10
Escribir "Ingresa un numero";
35
Leer a;
Segun a Hacer
0,1,2,3: Escribir "Correcto!!! ", a, " está en el rango de 0 a 10";
6,5,4: Escribir "Correcto!!! ", a, " está en el rango de 0 a 10";
10,9,8,7: Escribir "Correcto!!! ", a, " está en el rango de 0 a
10";
De Otro Modo:
Escribir "Error...", a, " es mayor que 10...Debes escribir
un numero del 0 al 10";
FinSegun
FinProceso
36
8. Calculadora Suma, Resta: Multiplicación y División
//Calculadora Suma, Resta, Multiplicación y División
Proceso calculadora
escribir "Que quieres hacer?";
escribir "1: Sumar";
escribir "2: Restar";
escribir "3: Multiplicar";
escribir "4: Dividir";
leer a;
Si a=1 Entonces
escribir "digita un valor";
leer b;
escribir "digita un segundo valor:";
leer c
d<-b+c;
escribir " La Suma de ", b, " + ", c, " = ", d
Sino
Si a=2 Entonces
escribir "digita tu valor";
leer b;
escribir "digita tu segundo valor:";
leer c
d<-b-c;
escribir " La Resta de " , b, " - ", c, " = ", d
Sino
Si a=3 Entonces
leer b;
leer c
d<-b*c;
Sino escribir " La Multiplicación de " , b, " * ", c," = " , d
Si a=4 Entonces
leer b;
leer c
Sino d<-b/c;
FinSi escribir " La División de " , b, " / ", c, " = ", d
FinSi
37
FinSi
FinSi
FinProceso
38
9. Restar a de b
//Algoritmo para Restar dos números desarrollado por RPC
Proceso restar_a_de_b //Proceso: Restar a de b; note que no hay espacios:

restar_a_de_b
Escribir "ingrese el valor de b"; //muestra en pantalla la instrucción de
ingresar el valor de 'b'
Leer b; //ingresa por teclado el valor de 'b'
Escribir "ingrese el valor de a";
Leer a;
Resta<-(b-a);
Escribir "La resta b-a es: ", " ",Resta; // note que existe un espacio: "
",Resta; la variable "Resta" es el valor de b-a
FinProceso // fin del proceso
39
10. Calcular el cociente y residuo de la

división de dos números A y B
// Algoritmo para Calcular el Cociente (C) y Residuo (R) de A entre B. Desarrollado

por RPC
Proceso Calcular_Cociente_Residuo //Proceso

Escribir "Programa para calcular el Cociente (C) y el Residuo (R) de
A entre B";
40
Escribir "Ingrese el valor de A: ";

Leer A; //ingresa por teclado el valor de A
Escribir "Ingrese el valor de B: ";
Leer B; //ingresa por teclado el valor de B
Cociente<-A/B; //Cociente
Residuo<-A Mod B; //Residuo ; emplear la función Mod
Escribir "El cociente(C) de A entre B es:", " ",Cociente;
Escribir "El residuo(R) de A entre B es: ", " ",Residuo;
FinProceso
41
11. Determinar el mayor de dos números ‘a’ y ‘b’
//Algoritmo que determina el mayor de dos números 'a' y 'b'. Desarrollado por RPC
Proceso mayor_que //proceso mayor_que

Escribir "Algoritmo para calcular cual numero de a y b es mayor";
Escribir "Introduzca el valor de a: " //muestra en pantalla la
instrucción
Leer a; //ingresa por teclado el valor de 'a'
Escribir "Introduzca el valor de b: "
Leer b;
a<-a; // a=a; si escribieramos a=0, la comparación sería entre ceros
(error)
b<-b; // idem al anterior
Si a>b Entonces //Condicional Si (If) a>b Entonces que?
Escribir "El número a=", " ", a, "es mayor que b=", " ", b;
Sino
Escribir "El número a=", " ", a, "es menor que b=", " ", b;
FinSi //Fin de la condicional
FinProceso //Fin del proceso
42
43
12. Cálculo mental de dos números: le ganas a una máquina?"
//Programa que indica si el cálculo mental de dos números es correcto: RPC
Proceso cálculo_mental_sumas
Escribir "Cálculo mental de dos números: le ganas a una máquina?";
Escribir "Ingresar un numero A";
Leer A;
Escribir "Ingresar un numero B";
Leer B;
Escribir "Piensa: La Suma A + B = ?";
Leer Piensa; //Piensa es la variable (pensada) por el usuario
Suma <- A + B; // Función Suma
Si piensa = Suma Entonces
Escribir "Correcto!!!...Eres bueno/a en sumar"
Sino
Escribir "Error...Necesitas estudiar!!!"
FinSi
FinProceso
44
45
13. Determinar el tiempo transcurrido entre dos horas del día.
//Algortimo para calcular el tiempo transcurrido entre dos horas H-1 y H-2.
Desarrollado por RPC
Proceso Calcular_tiempo_dos_horas
Escribir "Programa para clacular el Tiempo transcurrido entre dos
horas";
Escribir "Hora-1 (h1, m1)"; //H-1 expresado en Horas:minutos
Leer h1; //introduce h1 por teclado
Leer m1; //introduce m1 por teclado
Escribir "Hora-2 (h2, m2)";
Leer h2;
Leer m2;
dh<-(h2-h1); //operador diferencia_horas
dm<-(m2-m1); //operador diferencia_minutos
Si dh<0 Entonces //si dh es negativo (<0) volver positivo
dh<-(-1*dh) // multiplicar por -1
Sino
dh<-dh // dh>0 positivo, no se 'hace ninguna operación'
FinSi
Si dm<0 Entonces //idem a la línea 12

dm<-(-1*dm) //idem a la línea 13
Sino
dm<-dm //idem a la línea 15
FinSi
Escribir "La El tiempo trascurrido entre H-1 y H-2 es: ", dh, " horas ",
dm, " minutos ";
FinProceso
46
47
14. Calcular el salario semanal de un empleado
//Algoritmo para calcular el salario semanal de un trabajador. Desarrollado por

RPC
Proceso Salario
Escribir "Ingresar horas trabajadas por semana":
Leer HT; //ingresa por teclado las horas_trabajadas_semana
Escribir "Ingresar el salario Bs/hora";
Leer SH; //ingresa por teclado el salario Bs/hora
Salario<-HT*SH; //operador
Escribir "El Salario Semanal ganado es: ", " ", Salario, " Bs";
FinProceso
48
15. Cálculo del promedio de N números
//Calculo del promedio de una lista de 'N' números
Proceso Promedio
Escribir "Ingrese la cantidad de datos";
Leer N;
acum<-0;
Para i<-1 Hasta N Hacer

Leer dato;
acum<-acum+dato;
FinPara
prom<-acum/N
Escribir "El promedio es: ", prom;
FinProceso
49
50
GUIA TDD SOFTWARE

Primero vamos a recordar algo muy básico de teoría sobre unit testing y TDD. Lo
primero y mas importante es que TDD y unit testing son cosas diferentes. TDD es
un proceso de desarrollo basado en obtener un feedback lo mas rápido posible a
la hora de diseñar nuestra aplicación mientras que unit testing es una herramienta
donde probar que un «unit» funciona como esperas.
La definición de unit testing es algo ambigüa, la gente diverge en la definición,
sobre todo por la parte de «unit«. La gente hace un mapeo interno de unit a una
función o clase cuando no debería ser así, unit se refiere a una funcionalidad/caso
de uso. Esta funcionalidad puede implicar comunicación entre varios
métodos/entidades.
TDD, sin embargo, no es tan ambigüo, se basa en dos reglas muy simples que
siguiendolas nos llevará por el buen camino:
 Escribir código solo cuando tengamos un unit test que falle

 Refactorizar/Eliminar duplicación
Aplicando TDD
El mecanismo de TDD es fácil, escribir un test que pruebe la funcionalidad que

queremos implementar (un caso de uso), acto seguido escribir el mínimo código
posible para poner el test en verde. Una vez lo tenemos en verde, quitar
duplicación y refactorizar. Fácil.
TDD es un mecánismo de feedback rápido, el ciclo en el cual uno desarrolla RED ·
GREEN · REFACTOR y las tres leyes en las que se basa:
 You can’t write any production code until you have first written a failing unit
test.
 You can’t write more of a unit test than is sufficient to fail, and not compiling
is failing.
 You can’t write more production code than is sufficient to pass the currently
failing unit test.
Todos sabemos que tener un bug en nuestro código y no encontrarlo es doloroso

pero, más doloroso es cuando tienes un bug en un test. El test te da en verde,
confías en el test pero el código lo ves bien, cambias código de producción que
funciona generando un bug real y sigues sin entenderlo… la perdida de tiempo y la
desesperación cuando pasa esto es brutal. Dentro del ciclo de TDD, cuando
vemos el test en rojo y lo pasamos a verde controlamos que nuestro test
realmente hace lo que debe hacer evitando este tipo de problemas.
reen Bar Patterns

51
Existen ciertos patrones para ayudarnos a poner nuestro test en verde de la

manera mas rápida posible
1. Fake It
Devolver una constante y poco a poco ir cambiandolas por variables. Con esta
técnica iremos dando muchos pasos muy pequeños y conseguimos poner el test
en verde lo mas rápido posible
Ejemplo:
expect(suma(1,2)).toEqual(3);
function suma(a,b) {return 3}
Una vez lo tenemos en verde pasamos a la fase de Refactor, en este caso vamos
a quitar duplicación. La duplicación en este caso no es de código sino de datos,
tenemos datos repetidos que a simple vista no se ve, se verá mejor con este
pequeño cambio:
function suma(a,b) {return 1+2}
Realmente hemos puesto devuelto un 3 pero lo que queríamos hacer es 1+2, que
son los mismos números que hemos pasado como parametros a nuestra función,
ahora vemos la duplicación mas clara, vamos a quitarla:
function suma(a,b) {return a+b}
Done! Mas adelante explicaremos como sacar la misma implementación con una
técnica algo mas conservadora.
2. Obvious Implementation
En sí la técnica se basa en picar la implementación que nosotros creemos saber y
confirmarla lo mas rápido posible. Esto suele llevar a picar menos test, lo cual de
primeras puedes pensar que es positivo ya que vas mas rápido pero no lo es tanto
cuando piensas que en la fase de Refactor, si no tienes testeado todas las
especificaciones del SUT, puedes romper algo sin enterarte.
52
Con la implementación obvia lo que se busca (o mejor dicho, lo que se encuentra)

es acelerar un poco el ciclo saltándonos uno de los pasos muy importante y es
escuchar a nuestro test. Cuando nosotros picamos un test y esta en rojo, nos
forzamos a preguntarnos como debemos implementarlo, dudamos de nuestra
solución pero tenemos un mecanismo que nos va diciendo si lo vamos haciendo
bien o mal. Con la implementación obvia, este paso, nos lo saltamos, vamos
directos a implementar lo que tenemos en la cabeza sin dudar, bien podríamos
picar el test después de implementar el algoritmo y tendríamos el mismo resultado.
Es aconsejable aplicar esta técnica cuando la implementación no solo es obvia
sino que es trivial, donde existen menos especificaciones y corremos menos
riesgo de fallo, aún así, siempre hay que andar con mucho cuidado.
Resumiendo, como implementarías operaciones simples? Simplemente
implementalas.
Ejemplo:
function suma(a,b) {return a+b}
3. Triangulate
Como dice Kent Beck en su libro TDD By Example, triangular es la técnica mas
conservadora para conseguir la implementación que buscamos y no le falta razón.
De primeras es lo mismo que Fake It, escribimos un test y lo ponemos en verde
devolviendo una constante. Lo siguiente sería hacer el refactor pero no lo vamos
hacer ahora, teniendo nuestro test en verde, lo que vamos a hacer es escribir otro
test que lo ponga rojo:
Ejemplo:
function suma(a,b) {return 3}
Ahora tendríamos dos caminos:
 Desarrollar la implementación para tener los dos test en verde

 Seguir devolviendo constantes con una implementación mas sencilla que la
real
53
function suma(a,b) {if(a===1) return 3 else return 7}
Una vez tengamos nuestra implementación, podemos llegar a pensar en eliminar

los tests de mas que hemos usado para llegar a nuestra implementación, es
posible que hayamos creado tests redundantes pero eso ya es algo que depende
de cada caso y de cada persona.
Que técnica usar?

Bueno, esto ya es algo personal y subjetivo, algo que con la experiencia
evoluciona. Beck comenta en el libro que lo que tenemos que conseguir es un
ritmo de desarrollo rápido, red/green/refactor contínuo, si sabes lo que tienes que
picar, utiliza Obvious implementation. Si no lo sabes, usa Fake It y si te quedas
atascado en el diseño, termina triangulando.
Tras varios debates internos en Apiumhub (por email, openspaces y charlas
informales a la hora de la comida), el como ponerlo en verde es algo personal
(aunque fake it/triangulate suelen ser las técnicas mas utilizadas) pero si llegamos
a una conclusión clara, y es no dejar ningúna especificación sin un test, algo que
con implementación obvia es muy fácil de saltarse.
Aplicando TDD: Feedback

TDD es un proceso donde conseguir feedback sobre nuestro diseño de una
manera rápida (lo voy a repetir las veces que haga falta), el feedback nos los van
a dar los tests automatizados, entonces, cuantos tests necesitamos para estar
seguros de que nuestro código funciona? Uno podría pensar que la confianza a la
hora de desarrollar es el factor a a tener en cuenta para saber cuando parar de
hacer tests, y, aunque tiene su importancia, es algo muy subjetivo. Como
podemos convertir esa subjetividad en algo objetivo? como ya hemos comentado,
un test debe cubrir una especificación, si tenemos test de todas las
especificaciones que tenemos en mente, convertimos la subjetividad de la
confianza personal en confianza a nivel de negocio.
Hay que enfatizar que TDD nace como un proceso dentro de una metodología ágil
(Extreme Programming), los requerimientos que nos piden cambiarán, aparecerán
nuevos, etc, los requerimientos se descubren a lo largo de todo el ciclo de
desarrollo, incluso una vez subido a producción se descubrirán nuevos
requerimientos.
Cuando nos encontramos un caso (que son muy pocos) en el que [creemos
conocer] conocemos a la perfección la implementación, es trivial y creemos tener
confianza ciega con ella, nos sale a cuenta dedicarle algo de tiempo escribir los
tests para cubrir las especificaciones. No existe la excusa de que te lleva tiempo
54
extra porque una de dos: o tienes experiencia con TDD o no la tienes. Si tienes
experiencia, directamente te va a salir escribir tests y si no la tienes, prácticar es la
única manera de llegar a entender bien TDD. Puedes leer mucho y pensar muy
bien sobre TDD pero la experiencia es lo único que te hará diferente a los demás.
GUIA CLEAN CODE

Se considera que el código es limpio (en inglés, clean code) cuando es fácil de
leer y entender. Si resuelve los problemas sin agregar complejidad innecesaria,
permitiendo que el mantenimiento o las adaptaciones, por algún cambio de
requerimiento, sean tareas más sencillas, entonces estamos hablando de “clean
code”.
Conoce las 7 reglas principales del Clean Code
o 1 – Los nombres son importantes. ...
o 2 – Regla del boy scout. ...
o 3 – Debes ser el verdadero autor del código. ...
o 4 – DRY (Don't Repeat Yourself) ...
o 5 – Comentar solamente lo necesario. ...
o 6 – Tratamiento de errores. ...
o 7 – Tests limpios.
10 buenas prácticas para programadores
 Prioriza la legibilidad. ...
 Estructura la arquitectura. ...
 Lee mucho código fuente. ...
 Coloca comentarios. ...
 Testea tu código. ...
 Simplifica al máximo. ...
 Realiza control de versiones. ...
 No reproduzcas fragmentos idénticos de código.
Bueno, desde el aspecto de la codificación limpia, su estructura de datos debe tener solo
propiedades privadas con captadores y definidores públicos y sin lógica comercial. Por otro
lado, los objetos deben tener solo lógica comercial con conexión a estructuras de datos sobre
abstracciones.
1. Pero en lugar de tener propiedades privadas y getters setters públicos, la mejor

manera es tenerlo en forma de interfaces que no expongan propiedades ni
implementaciones de métodos.
2. Utilice DTO para registrar y transferir datos sin procesar
55
package az.alizeynalli.cleancode.objectanddatastructures
public class ObjectsAndDataStructures {
// 1. Use abstract objects over data structures

// Instead of using this kind of Data Sturcture:
class User {
private String name;
private String role;
// public getters, setters
}
// Use this kind of abstract Objects with implementation that is unknwon
to user of this data
interface User {
String getName();
String getRole();
void setName(String name);
void setRole(String role);
}
// 2. User DTOs for raw data transformation

class ErrorDTO{
public String Message;
public Error Error;
public Exception Exception;
}
}
56
GUIA SCRUM
Se trata de una metodología de trabajo ágil que tiene varios objetivos, por ejemplo:
Acelerar los procesos para satisfacer al cliente. Actuar con rapidez ante los posibles
cambios. Realizar entregas periódicas del trabajo
¿CÓMO ORGANIZAMOS EL PRIMER SPRINT?
Primero necesitamos que el product owner haga el backlog. Este backlog

consistirá en escribir en un formato de lista todas las historias de usuario
que el cliente ha pedido o necesita.
A continuación priorizará estas historias de usuario. Arriba las que

aportan más valor y abajo las que menos. Esta priorización se hará en
función al valor que aporta dicha historia de usuario y la cantidad de
trabajo que suponen.
Para conocer la cantidad de trabajo el equipo trabajará de forma colectiva

en la planning meeting donde "jugando" al poker plan estimará la cantidad
de trabajo que supone dicha historia de usuario.
El siguiente paso, es reunir todo el equipo y el Scrum máster, ayudado

por resto del equipo, trasladará las historias de usuario que el equipo
pueda afrontar. Durante esta reunión se puntúan las historias de usuario,
pero para poderse hacer, es necesario escribir los requisitos en formato
de tareas.
Las tareas del sprint no son asignadas po r parte del Scrum master, sino
que los miembros del equipo toman la iniciativa de la forma que creen
más apropiada, según sus conocimientos de la aplicación o sus
habilidades. En este momento ya podemos rellenar nuestra Scrum board.
57
La mejor función de la Sccrum board es que hace el trabajo visible. Todo

el equipo puede ver de una forma muy gráfica como esta evolucionando
ese sprint. Que puntos se están complicando y que ya tiene hecho.
¿CÓMO LO HACEMOS EN 10 SIMPLES PASOS?
1- Elegir un responsable de producto.

2- Elegir al equipo, de 4 a 9 personas.
3- Elegir un Scrum máster.
4- Elaborar y priorizar el backlog.
5- Hacer una estimación afinada de la lista de objetivos pendientes.
6- Planificar el primer sprint valorando la cantidad de trabajo.
7- Hacer que el trabajo se haga visible.
8- Hacer la daily: misma hora, mismo lugar, máximo 15 minutos y de pie.
9- Al final del sprint, revisar los resultados.
10- Buscar juntos la mejora continua de la productividad.
58
GUIA KANBAN
¿Cómo hacer un Kanban paso a paso?
Cómo crear un Tablero Kanban en 5 sencillos pasos:

1. Paso 1: Visualizar tu flujo de trabajo. ...
2. Paso 2: Identificar los tipos de trabajo que realizas. ...
3. Paso 3: Escribe las tareas en tarjetas y colócalas en la pizarra. ...
4. Paso 4: Comienza a trabajar con tu Tablero Kanban.
¿Cómo aplicar la metodologia Kanban?
Pasos para implementar fácilmente el método Kanban en tu empresa

1. Prepara a tu equipo de trabajo. Añadir a tu empresa el método Kanban supondrá
una gran cambio en el personal. ...
2. Visualizar el flujo de trabajo. ...
3. Delimita el número de tareas en curso. ...
4. Controla el trabajo. ...
5. Mejora a tu equipo continuamente.
Ventajas de Kanban
 Generación de valor. ...
59
 Equipo de trabajo organizado. ...

 Tiempos de entrega/Cumplimiento. ...
 Asignación de tareas. ...
 Calidad del producto. ...
 Acumulación de trabajo. ...
 Flexibilidad. ...
 Mejorar de manera colaborativa; experimentar y adaptarse.
GUIA INTEGRACION Y ENTREGA CONTINUA

La entrega continua se la conoce como el siguiente paso o extensión de
la integración continua. Tiene como objetivo principal conseguir que la entrega de
los nuevos cambios o actualizaciones del software a los clientes se realicen de
forma ágil y fiable.
La Integración Continua (IC) es una práctica DevOps para controlar la relación [Causa ->
Efecto -> Radiar información] al construir productos software. Segmentar y automatizar para
poder controlar el efecto, detectar los cambios rápido y reaccionar rápido
Buscar: ¿Qué es integración continua DevOps?
¿Qué es un ejemplo de entrega continua?
En estos casos, puedes por ejemplo entregar en un entorno de pruebas o

preproducción, para la realización de pruebas manuales, o realizar alguna
demostración de producto. También puedes hacer el despliegue en producción de
forma más segura y rápida por haber hecho un buen trabajo en las fases anteriores
¿Cuál es la diferencia entre entrega continua y despliegue continuo?

CD (continuous deployment) o despliegue continuo tiene mucha relación con
la entrega continua, sin embargo va más allá. El objetivo a diferencia de
la entrega continua es que no exista intervención humana a la hora de realizar
el despliegue de nuestro Software en producción
60
GUIA MDD SOFTWARE

El desarrollo dirigido por modelos (MDD por sus siglas en inglés) es un paradigma
de desarrollo de software basado en modelos, aplicados en diferentes ámbitos; en
este artículo se presenta una descripción actual del MDD, se tiene en cuenta sus
ventajas, los puntos claves de la iniciativa, el ciclo de vida.
61
GUIA UNIT SOFTWARE

62
GUIA MOBILE D
Mobile-D es una metodología ágil, exclusivamente para el

desarrollo de aplicaciones móviles, permite interactuar constantemente entre el
equipo de trabajo con el cliente, así como de responder rápidamente a los
cambios que se puedan producir durante la etapa de desarrollo del proyecto,
 Desarrollo basado en pruebas.

 Participación continúa del cliente.
 Establecimiento de prioridades en los requisitos.
 Comunicación efectiva.
 Calidad garantizada.
 Desarrolladores expertos.
 Revisión de todo el proceso y sesiones de aprendizaje.
Para empezar un proyecto móvil puedes optar por varias metodologías de

trabajo UX (DCU, Learn Startup, Agile UX). Por mi experiencia te diré que, al
final, para ser ágiles en nuestro trabajo tenemos que usar las técnicas adecuadas
y utilizarlas en su justa medida
63
WEB PROGRESIVA
64
65
66
GUIA REFACTORING
¿Qué es refactoring en Scrum?
La refactorización de código de software podría describirse como la modificación
del código fuente sin que cambie el comportamiento del mismo. (Limpiar el
código), Ayuda a mejorar la consistencia interna y la calidad, también permite
mejorar la facilidad de comprensión del código para facilitar el mantenimiento
futuro
¿Qué se hace durante un refactoring?

El objetivo del refactoring es evitar la deuda técnica que se acumula en el código
fuente y generar un código mas limpio y mas fácil de entender.
...
No tener código duplicado.
1. Hacer uso del diseño de patrones para resolver alguna problema en especifico.
2. Separar las responsabilidades en paquetes.
3. Usar clases utilitarias.
Cómo hacer el refactoring
Los cambios se deben ir realizando poco a poco, y por cada cambio hay que pasar
los tests para ver que no se ha roto su implementación. Esto es clave, ya que es la
única manera de que este proceso sea predecible y sea seguro.
67
68

Guia de Ingenieria de Software 1

Cargado por

Copyright:

Formatos disponibles

Guia de Ingenieria de Software 1

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia de Ingenieria de Software 1

Cargado por

Copyright:

Formatos disponibles

GUIA DE INGENIERIA DE SOFTWARE 1

MODIFICACIONES AL VUELTOS EN LAS

1.1 FUNDAMENTOS DE ALGORITMOS

Es un conjunto de pasos lógicos que permite alcanzar la solución de un problema.

o Finito: Debe culminar la solución.

 Ejemplos de la Vida Diaria

o Conseguir un vaso de agua.

Ir a la nevera llevando el vaso en la mano.

o Preparar una limonada.

Partir cuatro limones en cuatro pedazos cada uno.

1.1.2 Ingreso al Programa

En el escritorio aparece un icono que lleva por nombre Netbeans.

Dar doble click en el icono y se iniciará el programa o ir al menú inicio, escoger la

 Una vez ingresado al programa de ir al menú File y escoja la opción New

Imagen 1. Ventana de Inicio en Netbeans.

 Luego escoja la opción General en la ventana de la izquierda y en la derecha

Imagen 2. Ventana para selección de tipo de aplicación.

 Le aparece una ventana, donde aparece Project Name en este lugar se

Imagen 3. Ventana para nombrar proyecto.

 Escoja el lugar donde se creará la carpeta en donde se guardará el programa.

 Desactive las dos casillas de verificación que aparecen con un chulito en

1.3 CREACIÓN DE CLASES

Una vez creado el proyecto se crea el espacio donde se escribirá el algoritmo, de la

 En la ventana que se obtiene, en la parte en donde se encuentra Class Name,

Imagen 5. Ventana para dar nombre a la clase.

 Presiona el botón Finísh.

public class prueba {

Donde esta instrucción es la que indica que es un programa de Java y no se debe

1.4 COMPILAR Y EJECUTAR UN PROYECTO

Una vez el archivo grabado, se puede lanzar la compilación y la ejecución de su

2. ESTRUCTURAS BÁSICAS DE ALGORITMOS

En la siguiente instrucción que es:

Esta instrucción es modificada y reemplazada, para colocar el inicio del pseudocódigo

public static void main(String args[]){

2.1.1 Librería más Utilizadas

Import java.util.*; El cual permite generar números aleatorios, manejo de fechas,

2.1.2 Declaración De Variables Y Tipos De Datos

Reglas para dar Nombre a Variables

 Debe iniciar con una letra.

Tabla 1. Ejemplos de Nombres de Variables.

Nombre Variable Estado (Correcto o Incorrecto)

2.1.3 Ejercicios Propuestos

a) X=Y b) X=Z c) X=Y d) Z=Y

Manejo de Tipos de Datos en Netbeans

Existen varios tipos de datos como son: Numéricos y alfanuméricos.

 Datos Numéricos. Se dividen en enteros y reales, de los cuales en java se

a. Enteros: int variable1, variable2, variable3,…, variable n;

b. Reales: float variable1, variable2, variable3,…, variable n;

 Datos Alfanuméricos. Se dividen en carácter y cadenas, de los cuales en

Arreglos unidimensionales o Vectores. Se definen en java de la siguiente forma:

(Tipo de dato) [] (nombre del arreglo) =new (tipo de dato)[tamaño];

Ejemplo: int []vec=new int[50];

Arreglos bidimensionales o Matriz. Se definen en java de la siguiente forma:

(Tipo de dato) [][] (nombre del arreglo) =new (tipo de dato)[fila][columna];

2.2 OPERADORES RELACIONALES Y MATEMÁTICOS

Operadores Matemáticos. Son todas las operaciones matemáticas básicas, se

f=a+b; f=a-b; f=a*b; f=a/b; f=a%b; f=a/b;

Jerarquía de los Operadores