1. EJERCICIOS PROPUESTO 3
CON FUNDAMENTACIÓN
Ejercicios While:
1.- Escribir un programa que solicite la carga de un valor positivo y nos muestre desde 1 hasta
el valor ingresado de uno en uno. Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los
números del 1 al 30.
Pseint:
Proceso conteo
n<-0;
ni<-0;
Escribir 'Ingrese el numero hasta donde desea el conteo:'
Leer ni;
Mientras n<ni Hacer
n<-n+1
Escribir 'Los numerosson:',n;
FinMientras
FinProceso
Java:
public static void main(String[] args) {
//ejercicio - 1
int n=1,ni=0;
System.out.print("Ingresar el numero hasta donde desea el conteo: ");
ni=entrada.entero();
while (n<=ni){
System.out.println(n);
n=n+1;
}
}
}

2. 2-Desarrollar un programa que permita la carga de 10 valores por teclado y nos muestre
posteriormente la suma de los valores ingresados y su promedio.
Pseint:
Proceso numero
n<-0
c<-0
suma<-0
promedio<-0
Mientras c<10 Hacer
c<-c+1;
Escribir 'Ingresar Numero :';
Leer n;
suma<-suma+n;
FinMientras
Escribir '**************'
promedio<-suma/10;
Escribir 'La suma de todos los numeros es: ',suma;
Escribir 'EL promedio de los numeros ingresados es: ',promedio;
FinProceso
Java:
public static void main(String[] args) {
//ejercicio - 2
doublen,c=0,suma=0,promedio;
while (c<10){
c=c+1;
System.out.print("Ingresar numero: ");
n=entrada.entero();
suma=suma+n;
}
promedio=suma/10;
System.out.println("la suma de todos los numeros es: "+suma);
System.out.println("El promedio de los numeros ingresados es: "+promedio);
}
}

3. 3.- Una planta que fabrica perfiles de hierro posee un lote de n piezas. Confeccionar un
programa que pida ingresar por teclado la cantidad de piezas a procesar y luego ingrese la
longitud de cada perfil; sabiendo que la pieza cuya longitud esté comprendida en el rango de
1,20 y 1,30 son aptas. Imprimir por pantalla la cantidad de piezas aptas que hay en el lote.
Pseint:
Proceso lote
longuitud<-0
num<-0
c<-0
pb<-0
Escribir 'Ingrese el numero de pizas en el lote:';
Leer num;
Mientras c<num Hacer
c<-c+1;
Escribir 'Ingresar la longitud de la pieza ',c;
Leer longuitud;
Si longuitud<=1.30 y longuitud>=1.20 Entonces
pb<-pb+1;
FinSi
FinMientras
Escribir 'El numero de piezas de lote es: ',pb;
FinProceso
Java:
// ejercicio - 3
doublel,n,c=0,pb=0;
System.out.print("Ingrese el numero de piezas de lote: ");
n=entrada.real();
while (c<n){
c=c+1;
System.out.println("Ingresar la longitud de la pieza :");
l=entrada.real();
if (l<=1.30 && l>=1.20){
pb=pb+1;
}
}
System.out.println("El numero de pieza de lote es: "+pb);
}
}

4. 4.-Escribir un programa que solicite ingresar 10 notas de alumnos y nos informe cuántos
tienen notas mayores o iguales a 7 y cuántos menores.
Pseint:
Proceso notas
nota<-0
c<-0
menor<-0
mayor<-0
Mientras c<10 Hacer
c<-c+1
Escribir 'Ingrese la nota ',c,' :'
Leer nota
Si nota>=7 Entonces
mayor<-mayor+1
Sino
menor<-menor+1
FinSi
FinMientras
Escribir '**************'
Escribir 'Las notas mayores o = a 7 son: ',mayor
Escribir 'LA notas menores a 7: ',menor
FinProceso
Java:
// ejercicio - 4
doublenota,c=0,menor=0,mayor=0;
while (c<10){
System.out.print("Ingresar nota:");
nota=entrada.real();
if (nota>=7){
mayor=mayor+1;
}
else{
menor=menor+1;
}
}
System.out.println("Las notas mayores (0 = a 7) son: "+mayor);
System.out.println("Las notas menores a 7 son: "+menor);
}
}

5. 5.-Se ingresan un conjunto de n alturas de personas por teclado. Mostrar la altura promedio
de las personas.
Pseint:
Proceso altura
n<-0
suma<-0
escribir 'ingresa cantidad de altura: ';
leer n;
Para i<-1 Hasta n Hacer
Escribir 'ingrese altura: ';
Leer x
suma<-suma+x;
promedio<-suma/n;
FinPara
escribir 'la suma es: ',suma;
escribir 'el promedio de la suma es: ',promedio;
FinProceso
Java:
// ejercicio - 5
doublealtura,n=0,c=0,suma=0;
System.out.print("Ingrese numero de alturas: ");
n=entrada.real();
while(c<n){
c=c+1;
System.out.println("Ingresar la altura de una persona: ");
altura=entrada.real();
suma=suma+altura;
}
System.out.println("La suma es: "+ suma);
System.out.println("El promedio de la altura es: "+ (suma/n));
}
}

6. 6.-En una empresa trabajan n empleados cuyos sueldos oscilan entre $100 y $500, realizar un
programa que lea los sueldos que cobra cada empleado e informe cuántos empleados cobran
entre $100 y $300 y cuántos cobran más de $300. Además el programa deberá informar el
importe que gasta la empresa en sueldos al personal.
Pseint:
Proceso empleados
suel<-0
num<-0
c<-0
ss<-0
sim<-0
sum<-0
Escribir 'Ingrese el numero de empleados'
Leer num
Mientras c<num Hacer
c<-c+1
Escribir 'Ingresar el sueldo del empleado ',c
Leer suel
sisuel>=100 y suel<=500 Entonces
sum<-sum+suel
Si suel<=300 y suel>=100 Entonces
ss<-ss+1
Sino
sisuel> 300 Entonces
sim<-sim+1
FinSi
FinSi
Sino
c<-c-1
Escribir 'Valor incorrecto'
FinSi
FinMientras
Escribir '******************'
Escribir 'Los sueldos superiores a 300 es: ',ss
Escribir 'Los sueldos entre 100 y 300 son: ',sim
Escribir 'El monto total a pagar es: ',sum
FinProceso

8. Java:
// ejercicio - 6
intn,c=0;
doublesueldo,ss=0,sim = 0,suma=0;
System.out.print("Ingrese el numero de empleados: ");
n=entrada.entero();
while (c<n){
c=c+1;
System.out.print("Ingresar el sueldo del empleado:");
sueldo=entrada.real();
if (sueldo>=100 && sueldo<=500){
suma=suma+sueldo;
}
if ( sueldo>=100 && sueldo<=300 ){
ss=ss+1;
}
if (sueldo>=300){
sim=sim+1;
}
}
System.out.println("Los sueldos superiores a 300 es: "+ss);
System.out.println("Los sueldos entre 100 y 300 son: "+sim);
System.out.println("El monto total a pagar es: "+suma);
}
}
7.-Realizar un programa que imprima 25 términos de la serie 11 – 22 – 33 – 44, etc. (No se
ingresan valores por teclado)
Pseint:
Proceso ejercicio7-a
n1<-0
c<-0
Escribir 'Numeros en serie : ';
Mientras c<25 Hacer
c<-c+1;
n1<-n1+11;
Escribir n1;
FinMientras
FinProceso

9. Java:
// ejercici - 7(a)
int n=0,c=0;
System.out.println("Numeros en serie: ");
while (c<25){
c=c+1;
n=n+11;
System.out.println(n);
}
}
}

10. Mostrar los múltiplos de 8 hasta el valor 500. Debe aparecer en pantalla 8 – 16 – 24, etc.+
Pseint:
Proceso ejercicio-7 b
n<-8
Mientras (n<=500) Hacer
escribir n;
n<-n+8;
FinMientras
FinProceso
Java:
// ejercicio - 7(b)
int n=8;
while (n<=500){
System.out.println(n);
n=n+8;
}
}
}

11. 8.-Realizar un programa que permita cargar dos listas de 15 valores cada una. Informar con
un mensaje cual de las dos listas tiene un valor acumulado mayor (mensajes “Lista 1 mayor”,
“Lista 2 mayor”, “Listas iguales”)
Tener en cuenta que puede haber dos o más estructuras repetitivas en un algoritmo.
Pseint:
Proceso valores
c<-0
num<-0
sum1<-0
sum2<-0
Escribir 'Lista 1'
Escribir 'Escribir 15 valores'
Mientras c<15 Hacer
c<-c+1
Leer num
sum1<-sum1+num
FinMientras
Escribir 'Lista 2'
Escribir 'Escribir 15 valores'
c<-0
Mientras c<15 Hacer
c<-c+1
Leer num
sum2<-sum2+num
FinMientras
Si sum1<sum2 Entonces
Escribir 'Lista 2 mayor'
Sino
Si sum1>sum2 Entonces
Escribir 'Lista 1 mayor'
Sino
Escribir 'Listas iguales'
FinSi
FinSi
FinProceso

13. Java:
// ejercicio - 8
int c=0,n,suma1=0,suma2=0;
System.out.println("LISTA-1");
System.out.println("Escribir 15 valores: ");
while (c<15){
c=c+1;
n=entrada.entero();
suma1=suma1+n;
}
System.out.println("LISTA-2");
System.out.println("Escribir 15 valores: ");
int co=0;
while (co<15){
co=co+1;
n=entrada.entero();
suma2=suma2+n;
}
if (suma1<suma2){
System.out.print("LISTA 2 MAYOR");
}
else if (suma1>suma2){
System.out.print("LISTA 1 MAYOR");
}
else {
System.out.println("LISTA IGUALES");
}
}
}

14. Ejercicios Do While:
9.-Escribir un programa que solicite la carga de un número entre 0 y 999, y nos muestre un
mensaje de cuántos dígitos tiene el mismo. Finalizar el programa cuando se cargue el valor 0.
Pseint:
Proceso digitos
valor<-0
Repetir
escribir 'ingresar un valor entre 0 y 999 (el 0 finaliza): ';
leer valor;
Si (valor>=100) Entonces
escribir 'tiene 3 digitos';
Sino
si (valor>=10) Entonces
escribir 'tiene 2 digitos';
Sino
escribir 'tiene 1 digitos';
FinSi
FinSi
Hasta Que (valor=0)
FinProceso

15. Java:
// ejercicio - 9
int valor;
do {
System.out.print("Ingresar un valor entre 0 y 999 (el 0 finaliza):");
valor=entrada.entero();
if (valor>=100) {
System.out.println("Tiene 3 dígitos.");
} else {
if (valor>=10) {
System.out.println("Tiene 2 dígitos.");
} else {
System.out.println("Tiene 1 dígito.");
}
}
} while (valor!=0);
}
}
10.-Escribir un programa que solicite la carga de números por teclado, obtener su promedio.
Finalizar la carga de valores cuando se cargue el valor 0.
Cuando la finalización depende de algún valor ingresado por el operador conviene el empleo
de la estructura do while, por lo menos se cargará un valor (en el caso más extremo se carga
0, que indica la finalización de la carga de valores)
Pseint:
Proceso numeros
num<-0
c<-0
sum<-0
Escribir 'Ingrese numeros (ingrese 0 para terminar)'
Repetir
c<-c+1
Leer num
sum<-sum+num
Hasta Que num=0
Escribir 'EL promedio de los numeros ingresados es: ',sum/(c-1)
FinProceso

16. Java:
// ejercicio - 10
intn,c=0,suma=0;
System.out.println("Ingrese numeros (ingrese 0 para terminar): ");
do {
c=c+1;
n=entrada.entero();
suma=suma+n;
} while (n!=0);
System.out.println("El promedio de los numeros ingresados es: "+suma/(c-1));
}
}