EJERCICIOS PROPUESTO 3

CON FUNDAMENTACIN
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 nmeros 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 numeros son:',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- 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
double n,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.- 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
double l,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.- Escribir un programa que solicite ingresar 10 notas de alumnos y nos informe
cuntos tienen notas mayores o iguales a 7 y cuntos 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
double nota,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.- 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
double altura,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.- 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
cuntos empleados cobran entre $100 y $300 y cuntos cobran ms de $300.
Adems 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
si suel>=100 y suel<=500 Entonces
sum<-sum+suel
Si suel<=300 y suel>=100 Entonces
ss<-ss+1
Sino
si suel > 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

Java:
// ejercicio - 6
int n,c=0;
double sueldo,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 trminos 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

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);
}
}
}

Mostrar los mltiplos 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;
}
}
}

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 ms 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

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");
}
}
}

Ejercicios Do While:

9.- Escribir un programa que solicite la carga de un nmero entre 0 y 999, y nos
muestre un mensaje de cuntos dgitos 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

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 dgitos.");
} else {
if (valor>=10) {
System.out.println("Tiene 2 dgitos.");
} else {
System.out.println("Tiene 1 dgito.");
}
}
} while (valor!=0);
}
}

10.- Escribir un programa que solicite la carga de nmeros por teclado, obtener su
promedio. Finalizar la carga de valores cuando se cargue el valor 0.
Cuando la finalizacin depende de algn valor ingresado por el operador conviene
el empleo de la estructura do while, por lo menos se cargar un valor (en el caso
ms extremo se carga 0, que indica la finalizacin 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

Java:
// ejercicio - 10
int n,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));
}
}