//

######################################################################
##########
//Algoritmo que muestre la tabla de multiplicar de los números 1,2,3,4 y 5.
//
######################################################################
##########
//Análisis
//Debo repetir 5 veces (desde el número 1 hasta el 5) mostrar
//la tabla de multiplicar de ese número.
//Como vimos en otro ejercicio para una tabla de multiplicar debemos repetir
//10 veces para mostrar cada línea de la tabla.
//Por lo tanto necesito dos bucles anidados.
// Datos de entrada: Nada
// Información de salida: Las cinco tablas de multiplicar
// Variables:tabla,num(entero)
//
######################################################################
##########
//Diseño
//1.- Para tabla desde 1 hasta 5
// 2.-Para num desde 1 hasta 10
// 3.- Mostrar tabla * num = (tabla*num)
//
######################################################################
##########
Proceso TablasDeMultiplicar
Definir tabla,num Como Entero;
Para tabla<-1 hasta 5 Hacer
Para num<-1 hasta 10 Hacer
Escribir tabla," * ",num," = ", tabla*num;
FinPara
Esperar Tecla;
FinPara
FinProceso
######################################################################
##########
//Escribe un programa que diga si un número introducido por teclado es o no primo.
//Un número primo es aquel que sólo es divisible entre él mismo y la unidad.
//Nota: Es suficiente probar hasta la raíz cuadrada del número para ver si es
//divisible por algún otro número.
//
######################################################################
##########
//Análisis
//Leemos un número y vamos comprobando si es divisible entre 2 hasta la raíz
//cuadrada del número. Si es divisible por algún número no es primo.
//Si no es divisible por ningún número es primo.
//Para saber si es divisible usamos el operador módulo.
// Datos de entrada: el número a comprobar si es primo o no
// Información de salida: Un mensaje diciendo si es primo o no
// Variables: numero_es_primo (entero), num (entero) contador desde 2 hasta
//raíz cuadrada del num_es_primo, es_primo (lógico)
//
######################################################################
##########
//Diseño
//1.- Supongo que el número es primo -> es_primo<-Verdadero
//2.-Leer num_es_primo
//3.- Desde num = 2 hasta raíz(numero_es_rpimo)
// 4.- Si numero_es_primo es divisible entre num -> es_primo<-Falso
//5.- Si es_primo -> Mostrar "Es primo"
//6.- Si no -> Mostrar "No es primo"
//
######################################################################
##########
Proceso EsPrimo
Definir numero_es_primo,num Como Entero;
Definir es_primo Como Logico;
es_primo<-Verdadero;
Escribir Sin Saltar "Introduce un número para comprobar si es primo:";
Leer numero_es_primo;
Para num<-2 hasta rc(numero_es_primo) Hacer
Si numero_es_primo % num = 0 Entonces
es_primo <- Falso;
FinSi
FinPara
Si es_primo Entonces
Escribir "Es Primo";
SiNo
Escribir "No es Primo";
FinSi
FinProceso
//
######################################################################
##########
//Realizar un algoritmo para determinar cuánto ahorrará una persona en un año,
//si al final de cada mes deposita cantidades variables de dinero;
//además, se quiere saber cuánto lleva ahorrado cada mes.
//
######################################################################
##########
//Análisis
//se debe calcular cuanto a ahorrado en un año, indicando las cantidades que ahorra
//cada mes. Por lo tanto tendremos que hacer un bucle que se repita 12 veces e ir
//acumulando dichas cantidades.
//Se debe mostrar el valor del acumulador en cada iteración (para indicar lo que
//lleva ahorrado en cada mes.
// Datos de entrada: La cantidad de dinero ahorrado cada mes.
// Información de salida: En cada mes lo que lleva ahorrado.
// Variables: cant_mensaul (real), ahooro_acum (real), mes (entero)
//
######################################################################
##########
//Diseño
//1.- Inicializo el acumulador -> ahorro_acum<-0
//2.- Desde el mes 1 hasta el 12
// 3.- Leer cantidad ahorrada en el mes
// 4.- Acumular la cantidad
// 5.- Mostrar el valor acumulado
//
######################################################################
##########
Proceso CalcularAhorro
Definir cant_mensual Como Real;
Definir ahorro_acum como Real;
Definir mes Como Entero;
ahorro_acum<-0;
Para mes<-1 hasta 12 Hacer
Escribir "¿Cuánto has ahorrado en el mes ",mes,"?:";
Leer cant_mensual;
ahorro_acum <- ahorro_acum + cant_mensual;
Escribir "En el mes ",mes," llevas ahorrado ",ahorro_acum;
FinPara
FinProceso

//
######################################################################
##########
//Una empresa tiene el registro de las horas que trabaja diariamente un empleado
//durante la semana (seis días) y requiere determinar el total de éstas, así como
//el sueldo que recibirá por las horas trabajadas.
//
######################################################################
##########
//Análisis
//Calcular el sueldo y las horas trabajadas de un empleado en una semana (6 días).
//Hay que ir introduciendo la cantidad de horas que trabaja cada día.
//Tenemos que saber cuanto se paga la hora trabajada.
//Hay que ir acumulando las horas trabajadas cada día, para poder calcular el sueldo.
// Datos de entrada: Sueldo por hora, horas.
// Información de salida: Las horas acumuladas, y el sueldo de la semana.
// Variables: sueldo_por_hora (Real),horas, horas_acum, dia(entero)
//
######################################################################
##########
//Diseño
//1.- Incializo las horas acumuladas
//2.- Leer sueldo por hora (sueldo)
//3.- Desde el día 1 al 6
// 4.- Leer horas trabajadas
// 5.- Acumular las horas trabajadas
//6.- Mostrar Las horas acumuladas
//7.- Mostrar el sueldo -> horas acumuladas * sueldo por hora
//
######################################################################
##########
Proceso CalcularSueldo
Definir sueldo_por_hora Como Real;
Definir horas,horas_acum como Entero;
Definir dia Como Entero;
horas_acum<-0;
Escribir sin saltar "Introduce el sueldo por hora:";
Leer sueldo_por_hora;
Para dia<-1 hasta 6 Hacer
Escribir "¿Cuántas horas has trabajado el día ",dia,"?:";
Leer horas;
horas_acum <- horas_acum + horas;
FinPara
Escribir "Horas acumuladas en la semana:",horas_acum;
Escribir "Sueldo:",sueldo_por_hora*horas_acum;
FinProceso

//
######################################################################
##########
//Una persona se encuentra en el kilómetro 70 de una carretera, otra se encuentra
//en el km 150, los coches tienen sentido opuesto y tienen la misma velocidad.
//Realizar un programa para determinar en qué kilómetro de esa carretera se
//encontrarán.
//
######################################################################
##########
//Análisis
//tengo que calcular en que km se van a encontrar los coches. sabemos que van en
//sentido opuesto por lo tanto, si llevan la misma velocidad, el primero va a ir
//incrementando el km donde se encuentra y el segundo va a ir decrementándolo.
//Cuando coincidan en el mismo km, podemos considerar que se han encontrado.
// Datos de entrada: Nada, vamos a inicializar las variables donde guardamos los km
// Información de salida: El km donde se encuentran.
// Variables: km1,km2 (enteros)
//
######################################################################
##########
//Diseño
//1.- Inicializao las variables kms
//2.- Mientras km1<>km2
// 3.- Incremento km1
// 4.- Incremento km2
//5.- Mostrar en el km que se encuentran
//
######################################################################
##########
Proceso CalcularKm
Definir km1,km2 Como Entero;
km1<-70;
km2<-150;
Mientras km1<>km2 Hacer
km1<-km1+1;
km2<-km2-1;
FinMientras
Escribir "Se encuentran en el km:",km1;
FinProceso

/
######################################################################
##########
//Una persona adquirió un producto para pagar en 20 meses. El primer mes pagó 10
//euros, el segundo 20 euros, el tercero 40 euros y así sucesivamente.
//Realizar un algoritmo para determinar cuánto debe pagar mensualmente y el total
//de lo que pagó después de los 20 meses.
//
######################################################################
##########
//Análisis
//Tenemos que ir acumulando lo valores de un serie aritmética. La serie está
//formada por 20 cantidades a pagar que se van multiplicando por 2.
// Datos de entrada: Nada
// Información de salida: El pago acumulado
// Variables: Pago, pago_acum (real), mes (entero)
//
######################################################################
##########
//Diseño
//1.- Inicializo las variables -> pago_acum<-20; pago<-10
//2.- Desde el mes 1 hasta el 20
// 3.- Acumulo el pago
// 4.- Doblo el pago
//5.- Muestro el pago acumulado
//
######################################################################
##########
Proceso Prestamo
Definir pago, pago_acum Como Real;
Definir mes Como Entero;
pago_acum<-0;
pago<-10;
Para mes <- 1 Hasta 20 Hacer
pago_acum<-pago_acum+pago;
pago<-pago*2;
FinPara
Escribir "Al final de los 20 meses tuvo que pagar: ",pago_acum;
FinProceso
//
######################################################################
##########
//Una empresa les paga a sus empleados con base en las horas trabajadas en la semana
//Para esto, se registran los días que trabajó y las horas de cada día.
//Realice un algoritmo para determinar el sueldo semanal de N trabajadores
//y además calcule cuánto pagó la empresa por los N empleados.
//
######################################################################
##########
//Análisis
//Hay que calcular el sueldo de un número de trabajadores, por lo tanto
//necesitamos el número de trabajadores que tiene la empresa. También
//necesitamos saber el sueldo por hora,y por cada trabajador hay que pedir
//los días que ha trabajado en la semana y las horas que ha trabajado cada día.
//Por cada trabajador hay que mostrar el sueldo semanal y al finalizar el programa
//mostramos el total de sueldos pagados.
// Datos de entrada: Número de trabajadores, sueldo por hora, días trabajador por
//semana,horas trabajadas por cada trabajador.
// Información de salida: Sueldo de cada trabajador, total pagado.
// Variables:horas, horas_por_trabajador, horas_acum (entero), sueldo_por_hora (real)
// trabajadores,trabajador,dia(entero)
//
######################################################################
##########
//Diseño
//1.- Inicializo el acumulador de horas
//2.- Leer el número de trabajadores
//3.- Leer sueldo por hora
//4.- Por cada trabajador
// 5.- Inicializar el acumulador de horas_por_trabajador
// 6.-Por cada día
// 7.- Leer horas
// 8.- Acumular horas trabajadas por trabajador
// 9.-Mostrar sueldo (horas_por_trabajador*sueldo_por_hora
//10.- Mostrar total de pago (horas_acum*sueldo_por_hora)
//
######################################################################
##########
Proceso CalcularSalario2
Definir dias,horas Como Entero;
Definir horas_por_trabajador,horas_acum Como Entero;
Definir dia, trabajador Como Entero;
Definir sueldo_por_hora Como Real;
Definir trabajadores como Entero;
Escribir Sin Saltar "¿Cuántos trabajadores tiene la empresa?:";
Leer trabajadores;
Escribir Sin Saltar "Sueldo por hora:";
Leer sueldo_por_hora;
horas_acum<-0;
Para trabajador<-1 hasta trabajadores Hacer
horas_por_trabajador<-0;
Escribir Sin Saltar "¿Cuántos días ha trabajado el trabajador ",trabajador," ?";
Leer dias;
Para dia<-1 hasta dias Hacer
Escribir Sin Saltar "¿Cuántas horas ha trabajado el trabajador ",trabajador," el día
",dia,"?:";
Leer horas;
horas_por_trabajador<-horas_por_trabajador+horas;
FinPara
Escribir "El trabajador ",trabajador," tiene de sueldo
",horas_por_trabajador*sueldo_por_hora;
horas_acum<-horas_acum+horas_por_trabajador;
FinPara
Escribir "El pago a los ",trabajadores," trabajadores es :",horas_acum*sueldo_por_hora;
FinProceso
//
######################################################################
##########
//Hacer un programa que muestre un cronometro, indicando las horas, minutos y
segundos.
//
######################################################################
##########
//Análisis
//Necesito realizar 3 bucles anidados: el más interno es que me permite recorrer
//los segundos, el intermedio me permite recorrer los minutos y el más externo
// recorre las horas.
// Datos de entrada: Nada
// Información de salida: La hora (hora, minutos y segundos)
// Variables: hora,minuto,segundo (entero)
//
######################################################################
##########
Proceso Cronometro
Definir hora,minuto,segundo Como Entero;
Para hora <- 0 hasta 23 con paso 1 hacer //horas
Para minuto <- 0 hasta 59 con paso 1 hacer //minutos
Para segundo <- 0 hasta 59 con paso 1 hacer //segundos
Limpiar Pantalla;
Escribir hora,":",minuto,":",segundo; //escribe hora:minutos:segundos (actualizandose a
medida que va pasando cada segundo)
Esperar 1 Segundo;
finpara
finpara
finpara
FinProceso
//
######################################################################
##########
//Realizar un ejemplo de menú, donde podemos escoger las distintas opciones hasta
//que seleccionamos la opción de "Salir".
//
######################################################################
##########
//Análisis
//La realización del menú la hacemos con un bucle repetir y una alternativa "según"
//En el bucle se realiza las siguientes acciones:
// * Mostrar el menú con las distintas opciones
// * Leer opción
// * Según opción ejecutamos las instrucciones necesarias.
// * En otro caso (opción incorrecta): Mostramos opción incorrecta
// La opción de "salir" la podemos dejar vacía (no ejecutar ninguna instrucción).
// Se repetir el bucle hasta que elijamos la opción de salir.
// Datos de entrada: opción
// Información de salida: Según la opción escogida
// Variables: opcion(entero)
//
######################################################################
##########
Proceso sin_titulo
Definir opcion Como Entero;
Repetir
// mostrar menu
Limpiar Pantalla;
Escribir "Menú de recomendaciones";
Escribir " 1. Literatura";
Escribir " 2. Cine";
Escribir " 3. Música";
Escribir " 4. Videojuegos";
Escribir " 5. Salir";
// ingresar una opcion
Escribir "Elija una opción (1-5): ";
Leer opcion;
// procesar esa opción
Segun opcion Hacer
1:
Escribir "Lecturas recomendables:";
Escribir " + Esperándolo a Tito y otros cuentos de fúbol (Eduardo Sacheri)";
Escribir " + El juego de Ender (Orson Scott Card)";
Escribir " + El sueño de los héroes (Adolfo Bioy Casares)";
2:
Escribir "Películas recomendables:";
Escribir " + Matrix (1999)";
Escribir " + El último samuray (2003)";
Escribir " + Cars (2006)";
3:
Escribir "Discos recomendables:";
Escribir " + Despedazado por mil partes (La Renga, 1996)";
Escribir " + Búfalo (La Mississippi, 2008)";
Escribir " + Gaia (Mägo de Oz, 2003)";
4:
Escribir "Videojuegos clásicos recomendables";
Escribir " + Día del tentáculo (LucasArts, 1993)";
Escribir " + Terminal Velocity (Terminal Reality/3D Realms, 1995)";
Escribir " + Death Rally (Remedy/Apogee, 1996)";
5:
Escribir "Gracias, vuelva prontos";
De otro modo:
Escribir "Opción no válida";
FinSegun
Escribir "Presione enter para continuar";
Esperar Tecla;
Hasta Que opcion=5
FinProceso
//
######################################################################
##########
//Crea una aplicación que pida un número y calcule su factorial (El factorial de
//un número es el producto de todos los enteros entre 1 y el propio número y se
//representa por el número seguido de un signo de exclamación.
//Por ejemplo 5! = 1x2x3x4x5=120)
//
######################################################################
##########
//Análisis
// Necesito acumular las sucesivas multiplicaciones, empezando por 2 hasta el
// número indicado.
// Datos de entrada: número al que calcular el factorial
// contador para in contando los números desde 2 al número
// Información de salida:El resultado del factorial
// Variables:num,contador(entero), resultado (real)
//
######################################################################
##########
//Diseño
// 1.Leer numero
// 2. Incializo variables
// contador = 2
// resultado = 1
// 3. Mientras contador<=num hacer
// 4. resultado=resultado*contador
// 5. contador=contador+1
// 6. Mostrar resultado
//
######################################################################
##########
Proceso Factorial
Definir num,contador Como Entero;
Definir resultado Como Real;
resultado <- 1;
Escribir Sin Saltar "Dime un número:";
Leer num;
contador <- 2;
Mientras contador<=num Hacer
resultado <- resultado * contador;
contador <- contador + 1;
FinMientras
Escribir "El resultado es ", resultado;
FinProceso
//
######################################################################
##########
// Crea una aplicación que permita adivinar un número. La aplicación genera un
// número aleatorio del 1 al 100. A continuación va pidiendo números y va
// respondiendo si el número a adivinar es mayor o menor que el introducido,
// a demás de los intentos que te quedan (tienes 10 intentos para acertarlo).
// El programa termina cuando se acierta el número (además te dice en cuantos
//intentos lo has acertado), si se llega al limite de intentos te muestra el
//número que había generado.
//
######################################################################
##########
//Análisis
//Tenemos que generar un número aleatorio (función Aleatorio) del 1 al 100.
//Necesitamos un contador para contar los 10 intentos. Al principio vale 10 y
// irá decrementando.
// Mientras no acierte el número y me queden intentos:
// Leo un número
// Lo comparo con el número generado (digo si es mayor o menor)
// Pido otro numero
// Puedo terminar el bucle por dos razones: si he adivinado el numero (he ganado)
// y muestro los intentos que he necesitado.
// sino he perdido, he utilizado los 10 intentos y muestro el número generado.
// Datos de entrada: número pedido al usuario.
// Información de salida: Has ganado y los intentos, o has perdido y el número.
// Variables: num_screto, num_ingresado, intentos (entero)
//
######################################################################
##########
//Diseño
// 1.- Genero un numero aleatorio del 1 al 100 (num_secreto)
// 2.- intentos = 10
// 3.- Leer num
// 4.- Mientras num<> num_secreto y intentos>1
// 5.- Si num_screto>num -> Escribir "Muy bajo"
// 6.- Si num_screto<num -> Escribir "Muy alto"
// 7.- intentos=intentos-1
// 8.- Escribir intentos
// 9.- Leer num
// 10.- Si num_secreo=num -> Escribir "Has ganado", intentos
// 11.- SiNo -> Escribir "Has perdido, num_secreto
//
######################################################################
##########
Proceso Adivina_Numero
Definir intentos,num_secreto,num_ingresado Como Entero;
intentos<-10;
num_secreto <- Aleatorio(1,100);
Escribir "Adivine el numero (de 1 a 100):";
Leer num_ingresado;
Mientras num_secreto<>num_ingresado Y intentos>1 Hacer
Si num_secreto>num_ingresado Entonces
Escribir "Muy bajo";
Sino
Escribir "Muy alto";
FinSi
intentos <- intentos-1;
Escribir "Le quedan ",intentos," intentos:";
Leer num_ingresado;
FinMientras
Si num_secreto=num_ingresado Entonces
Escribir "Exacto! Usted adivino en ",11-intentos," intentos.";
Sino
Escribir "El numero era: ",num_secreto;
FinSi
FinProceso
//
######################################################################
##########
//Mostrar en pantalla los N primero números primos. Se pide por teclado la cantidad
//de números primos que queremos mostrar.
//
######################################################################
##########
//Análisis
//Tengo que leer la cantidad de números primos que voy a mostrar. La cantidad debe
//ser positivo. El primer número primo es el 2 (lo muestro) a partir de este son
//todos impares. Voy probando desde el 3 todos los impares hasta que muestre la
//cantidad que hemos indicados (necesito un contador).
//Para comprobar si son primos, los voy dividiendo desde 3 hasta la raíz cuadrada
//del número, si es divisible por algún número no es primo (necesito un indicador).
// Datos de entrada: Cantidad de números a mostrar.
// Información de salida: Los números primos indicados.
// Variables: cant_a_mostrar, cant_mostradis, divisor (entero), es_primo(lógico)
//
######################################################################
##########
//Diseño
//1.- Leer cantidad de número primos a mostrar, debe ser positivo
//2.- Muestro el primer número primo, el 2.
//3.- Inicializo el contador de número mostrados a 1.
//4.- Inicializo la variable donde guardo el número a probar -> num=3
//4.- Mientras no haya mostrado la cantidad de número indicados
// 5.- Considero que es primo. Inicializo el indicador -> es_primo=Verdadero
// 6.- desde el 3 hasta la raíz cuadrada del número
// 7.- Si es divisible -> Ya no es primo -> es_primo=Falso
// 8.- Si es primo
// 9.- Incremento el contador de números mostrados
// 10.- Escribo el número primo
// 11.- Como son impares, incremento en 2 el número a probar
//
######################################################################
##########
Proceso Primos
Definir cant_a_mostrar,num,cant_mostrados,divisor Como Entero;
Definir es_primo Como Logico;
Repetir
Escribir "Ingrese la cantidad de números primos a mostrar:";
Leer cant_a_mostrar;
Hasta que cant_a_mostrar>0;
Escribir "1: 2"; // el primer primo es 2, los otros son todos impares...
cant_mostrados <- 1;
num<-3; // ...a partir de 3
Mientras cant_mostrados<cant_a_mostrar Hacer
es_primo <- Verdadero; // pienso que es primo hasta que encuentre con que dividirlo
Para divisor<-3 hasta rc(num) con paso 2 Hacer // ya sabemos que es impar
Si num % divisor = 0 entonces // si la división da exacta...
es_primo <- Falso; // ...ya no es primo
FinSi
FinPara
Si es_primo Entonces
cant_mostrados <- cant_mostrados + 1;
Escribir cant_mostrados, ": ",num;
FinSi
num <- num + 2 ;
FinMientras
FinProceso
//
######################################################################
##########
//Algoritmo que pida números hasta que se introduzca un cero. Debe imprimir la suma
// y la media de todos los números introducidos.
//
######################################################################
##########
//Análisis
//Vamos pidiendo números hasta introducir un 0.
//Necesitamos un acumulador para ir realizando las sumas intermedias.
//Además necesitamos un contador, para calcular la media (suma/cantidad)
// Datos de entrada: números, un acumulador para sumar y un contador
// Información de salida:La suma y la media
// Variables:num, suma, cont (enteros)
//
######################################################################
##########
//Diseño
//1.- Incializo: suma = 0, cont = 0
//2.- Leer num
//3.- Mientras num<>0
// 4.- Acumulo: suma = suma + num
// 5.- Cuento si num<>0: cont=cont+1
// 6.- Leer num
//7.- Si cont=0 (No hemos introducido ningún número)-> media=0
//8.- SiNo -> media=suma/cont;
//9.- Mostrar suma y media
//
######################################################################
##########
Proceso CalcularSumaMedia
Definir num Como Entero;
Definir suma,cont como Entero;
Definir media Como Real;
suma <- 0;
cont <-0;
//Con el mientras si el primer número es 0 no va a entrar en el bucle
Escribir "Número (0 para salir):";
Leer num;
Mientras num<>0 Hacer
suma <- suma + num;
cont <- cont + 1;
Escribir "Número (0 para salir):";
Leer num;
FinMientras
//Si cont=0 no puedo realizar la división
Si cont>0 Entonces
media <- suma / cont;
SiNo
media <-0;
FinSi
Escribir "Suma:",suma;
Escribir "Media:",media;
FinProceso
//
######################################################################
##########
//Algoritmo que pida números hasta que se introduzca un cero. Debe imprimir la suma
// y la media de todos los números introducidos.
//
######################################################################
##########
//Análisis
//Vamos pidiendo números hasta introducir un 0.
//Necesitamos un acumulador para ir realizando las sumas intermedias.
//Además necesitamos un contador, para calcular la media (suma/cantidad)
// Datos de entrada: números, un acumulador para sumar y un contador
// Información de salida:La suma y la media
// Variables:num, suma, cont (enteros)
//
######################################################################
##########
//Diseño
//1.- Incializo: suma = 0, cont = 0
//2.- repetir
// 3.- Leer num
// 4.- Acumulo: suma = suma + num
// 5.- Cuento si num<>0: cont=cont+1
//6.- Hasta num=0
//7.- Si cont=0 (No hemos introducido ningún número)-> media=0
//8.- SiNo -> media=suma/cont;
//9.- Mostrar suma y media
//
######################################################################
##########
Proceso CalcularSumaMedia
Definir num Como Entero;
Definir suma,cont como Entero;
Definir media Como Real;
suma <- 0;
cont <-0;
Repetir
Escribir "Número (0 para salir):";
Leer num;
suma <- suma + num;
//Si num=0 no debemos tenerlo en cuenta para calcular la media
Si num<>0 Entonces
cont <- cont + 1;
FinSi
Hasta que num=0;
//Si cont=0 no puedo realizar la división
Si cont<>0 Entonces
media <- suma / cont;
SiNo
media <- 0;
FinSi
Escribir "Suma:",suma;
Escribir "Media:",media;
FinProceso
//
######################################################################
##########
//Realizar un algoritmo que pida números (se pedirá por teclado la cantidad de
//números a introducir). El programa debe informar de cuantos números introducidos
//son mayores que 0, menores que 0 e iguales a 0.
//
######################################################################
##########
//Análisis
//Se pide la cantidad de números que se van a leer. Vamos introduciendo números.
//Tenemos que contar los positivos, negativos y 0.
// Datos de entrada:Cantidad de números, los números.
// Información de salida: Cantidad de positivos, de negativos y de 0.
// Variables:cantidad_num,num,cont_positivos,cant_negativos,cantidad_ceros(entero)
//
######################################################################
##########
//Diseño
//1.- Inicializo los contadores
//2.- Leer cantidad de números
//3.- Desde 1 hasta cantidad de números
// 4.- Leer num
// 5.- Si num> 0-> incremento cont_positivos
// 6.- Si num< 0-> incremento cont_negativos
// 7.- Si num = 0-> incremento cont_ceros.
// Muestro cont_postivos, cont_negativos, cont_ceros
//
######################################################################
##########
Proceso ContarNumerosPositivosNegativosYCeros
Definir num Como Entero;
Definir cantidad_num,i Como Entero;
Definir cont_negativos,cont_positivos,cont_ceros Como Entero;
cont_negativos <- 0;
cont_positivos <- 0;
cont_ceros <- 0;
Escribir "¿Cuántos números vas a introducir?:";
Leer cantidad_num;
Para i<-1 Hasta cantidad_num Hacer
Escribir "Número ",i,":" ;
Leer num;
Si num>0 Entonces
cont_positivos <- cont_positivos + 1;
Sino
Si num<0 Entonces
cont_negativos <- cont_negativos + 1;
SiNo
cont_ceros <- cont_ceros + 1;
FinSi
FinSi
FinPara
Escribir "Números positivos:",cont_positivos;
Escribir "Números negativos:",cont_negativos;
Escribir "Números igual a 0:",cont_ceros;
FinProceso
//
######################################################################
##########
//Algoritmo que pida caracteres e imprima 'VOCAL' si son vocales y 'NO VOCAL'
//en caso contrario, el programa termina cuando se introduce un espacio.
//
######################################################################
##########
//Análisis
//Leer un carácter hasta que sea el espacio.
//Si el carácter no es espacio -> si es una vocal -> Muestro "Es vocal"
//Si no muestro "No es vocal"
// Datos de entrada:vamos leyendo un carácter.
// Información de salida:Mensajes: "Es vocal", "No es vocal"
// Variables:car (caracter)
//
######################################################################
##########
//Diseño
//1.- Repetir -> Leer carácter hasta que sea un sólo carácter
//2.- Mientras no sea espacio
// 3.- Si car no es el espacio
// 4.- Si es A,E,I,O,U o a,e,i,o,u -> Mostrar "Es vocal"
// 5.-Si no mostrar "No es vocal"
// 6.- Repetir -> Leer carácter hasta que sea un sólo carácter
//
######################################################################
##########
Proceso VocalConsonante
Definir car Como Caracter;
Repetir
Escribir "Introduce un carácter:";
Leer car;
Hasta que Longitud(car)=1;
Mientras car<>" " Hacer
Si Mayusculas(car)="A" o Mayusculas(car)="E" o Mayusculas(car)="I" o
Mayusculas(car)="O" o Mayusculas(car)="U" Entonces
Escribir "VOCAL";
SiNO
Escribir "NO VOCAL";
FinSi
Repetir
Escribir "Introduce un carácter:";
Leer car;
Hasta que Longitud(car)=1;
FinMientras
FinProces

nes (30 sloc) 1.17 KB

//
######################################################################
##########
//Escribir un programa que imprima todos los números pares entre dos números que
//se le pidan al usuario.
//
######################################################################
##########
//Análisis
//Leemos un número. Si es impar, le sumo 1 y ya es par. Leemos el segundo número.
//Escribo el número desde el primero hasta el segundo de dos en dos.
// Datos de entrada: dos números
// Información de salida:Los números pares que hay entre los dos anteriores
// Variables:num, num1,num2 (entero)
//
######################################################################
##########
//Diseño
//1.- Leer num1,num2
//2.- Si num1 es impar -> num1=num1+1
//3.- Desde num1 hasta num2 de 2 en 2
// 4.- Escribir el número
//
######################################################################
##########
Proceso NumerosPares
Definir num,num1,num2 Como Entero;
Escribir Sin Saltar "Introduce el número 1:";
Leer num1;
Escribir Sin Saltar "Introduce el número 2:";
Leer num2;
Si num1 % 2 = 1 Entonces
num1<-num1+1;
FinSi
Para num<-num1 Hasta num2 Con Paso 2 Hacer
Escribir sin saltar num," ";
FinPara
FinProceso
//
######################################################################
##########
//Realizar una algoritmo que muestre la tabla de multiplicar de un número
//introducido por teclado.
//
######################################################################
##########
//Análisis
//Leemos el número del que queremos mostrar la tabla
//Necesitamos un contador para contar de 1 a 10
//Tenemos que repetir 10 veces -> En cada vuelta debemos mostrar:
// el contador * el numero = resultado de la multiplicación
// Datos de entrada: El número de la tabla, y un contador de 1 a 10.
// Información de salida:Las 10 operaciones de la tabla de multiplicación
// Variables:tabla,num (enteros)
//
######################################################################
##########
//Diseño
//1.- Leer tabla
//2.- DEsde numero de 1 a 10
// 3.- Mostrar num * tabla = (num*tabla)
//
######################################################################
##########
Proceso TablaMultiplicar
Definir tabla,i Como Entero;
Escribir Sin Saltar "¿De qué número quieres mostrar la tabla de multiplicar?:";
Leer tabla;
Para num<-1 hasta 10 Hacer
Escribir num," * ",tabla," = ",num*tabla;
FinPara
FinProceso

//
######################################################################
##########
//Escribe un programa que pida el limite inferior y superior de un intervalo.
//Si el límite inferior es mayor que el superior lo tiene que volver a pedir.
//A continuación se van introduciendo números hasta que introduzcamos el 0.
//Cuando termine el programa dará las siguientes informaciones:
// * La suma de los números que están dentro del intervalo (intervalo abierto).
// * Cuantos números están fuera del intervalo.
// * He informa si hemos introducido algún número igual a los límites del intervalo.
//
######################################################################
##########
//Análisis
//Pedimos un intervalo (límite inferior y superior)
//Nos tenemos que asegurar que el límite inferior sea menor que el superior.
//Se van pidiendo números hasta que se introduzca el 0.
//Si el numero pertenece al intervalo -> lo voy sumando (necesito un acumulador)
//Si el número no pertenece al intervalo, lo cuento (necesito un contador)
//Si el número es igual a algún límite, lo índico (necesito un indicador)
//Al final muestro la suma de los números que pertenecen al intervalo.
//Muestro el contador de número que no pertenecen al intervalo.
//Indico si hemos introducido un número igual a algún límite
// Datos de entrada:límite superior e inferior del intervalo y números.
// Información de salida:La suma de los que pertenecen al intervalo,
// el contador de los números que no pertenecen al intervalo
// indico si un número ha sido igual a algún intervalo
// Variables:lim_inf, lim_sup, num, suma_dentro_intervalo, cont_fuera_intervalo
(entero)
// igual_limites (Lógico)
//
######################################################################
##########
//Diseño
//1.- Inicializo el acumulador, el contador y el indicado
//2.-Repetir -> ller lim_inf y lim_sup hasta que lim_inf<lim_sup
//3.-Leer num
//4.- Mientras num sea distinto de 0
// 5.-Si num pertenece al intervalo -> acumula la suma
// 6.-Sino -> incremento contador
// 7.- Si es igual a algún intervalo -> Lo indico (indicador a Verdadero)
// 8.- Leer num
// 9.-Muestro la suma de los números pertenecientes al intervalo
// 10.-Muestro el contador de números no pertenecientes al intervalo
// 11.- Si el indicador = Verdadero -> Muestro "Un número = a intervalo"
// 12.- SiNo -> Muestro "No has introducido un número igual al intervalo
//
######################################################################
##########
Proceso Intervalo
Definir lim_inf, lim_sup como Entero;
Definir num como Entero;
Definir suma_dentro_intervalo Como Entero;
Definir cont_fuera_intervalo Como Entero;
Definir igual_limites Como Logico;
suma_dentro_intervalo <- 0;
cont_fuera_intervalo <- 0;
igual_limites <- Falso;
//Me aseguro que el lim_inf es menor que el lim_sup
Repetir
Escribir "Introduce el límite inferior del intervalo:";
Leer lim_inf;
Escribir "Introduce el límite superior del intervalo:";
Leer lim_sup;
Si lim_inf>lim_sup Entonces
Escribir "ERROR: El límite inferior debe ser menor que el superior.";
FinSi
Hasta Que lim_inf<=lim_sup;
Escribir Sin Saltar "Introduce un número (0, para salir):";
Leer num;
Mientras num<>0 Hacer
//Pertenece al intervalo
Si num>lim_inf Y num<lim_sup Entonces
suma_dentro_intervalo <- suma_dentro_intervalo + num;
SiNo
//No pertenece al intervalo
cont_fuera_intervalo <- cont_fuera_intervalo + 1;
FinSi
//Número igual a alguno de los límites
Si num=lim_inf O num=lim_sup Entonces
igual_limites <- Verdadero;
FinSi
Escribir Sin Saltar "Introduce un número (0, para salir):";
Leer num;
FinMientras
Escribir "La suma de los número dentro del intervalo es ",suma_dentro_intervalo;
Escribir "La cantidad de números fuera del intervalo es ",cont_fuera_intervalo;
Si igual_limites Entonces
Escribir "Se ha introducido algún número igual a los límites del intervalo.";
SiNo
Escribir "No se ha introducido ningún número igual a los límites del intervalo.";
FinSi
FinProceso

//
######################################################################
##########
//Escribe un programa que dados dos números, uno real (base) y un entero positivo
//(exponente), saque por pantalla el resultado de la potencia. No se puede
//utilizar el operador de potencia.
//
######################################################################
##########
//Análisis
//Leo la base y el exponente de una potencia.
//El exponente me tengo que asegurar que es positivo.
//Para realizar la potencio tengo que acumular el productor de la base tantas veces
//como indique el exponente.
// Datos de entrada: La base y el exponente
// Información de salida:La potencia
// Variables:base,potencia(Real), exponente(entero), i (indice del bucle para)
//
######################################################################
##########
//Diseño
//1.- Inicializo el acumulador para multiplicación -> potencia <- 1
//2.- Leer base
//3.- Repetir -> Leer exponente -> hasta que exponente sea positivo
//4.- Desde 1 hasta el exponente
// 5.- Acumulo la multiplicación de la base -> potencia<-potencia*base
//6.- Muestro potencia
//
######################################################################
##########
Proceso CalcularPotencia
Definir base, potencia Como Real;
Definir exponente Como Entero;
Definir i Como Entero;
Escribir Sin Saltar "Dame la base de la potencia:";
Leer base;
Repetir
Escribir Sin Saltar "Dame el exponente de la potencia:";
Leer exponente;
Si exponente<0 Entonces
Escribir "ERROR: El exponente debe ser positivo";
FinSi
Hasta Que exponente >= 0;
potencia <- 1;
Para i<-1 hasta exponente Hacer
potencia <- potencia * base;
FinPara
Escribir "Potencia:",potencia;
FinProceso