Creando una mariposa en PSeInt

En esta ocasión se muestra el código para crear una figura de una "mariposa" empleando el caracter "@", se puede realizar con otro caracter como el "*" o"#".

Código completo

Proceso Mariposa
   Definir cade Como Caracter 
   Escribir "Ingrese el tamaño"
   Leer ta
   Para i <- 1 Hasta ta Con Paso 1 Hacer
     cade<-""
     Para j<-1 Hasta ta Con Paso 1 Hacer
       Si i<=ta/2 Entonces    
         Si j<=i o j>ta-i Entonces
           cade<-cade+"@"
         SiNo
           cade<-cade+" "
         FinSi
       SiNo
         Si j>i o j<=ta-i Entonces
           cade<-cade+"@"
         SiNo
           cade<-cade+" "
         FinSi
       FinSi   
     FinPara
     Escribir cade
   FinPara
FinProceso

Variables

Tenemos dos variables que son "cade" y "ta", estas representan a cada línea de la mariposa (horizontal) y el tamaño que tendrá la mariposa respectivamente. Al ser "ta" una variable de entrada, se deben de leer. Por ello le pedimos al usuario que indique el tamaño, si el usuario coloca 6 tendrá una mariposa que tiene 6 filas por 6 columnas, si coloca 10 tendrá una de 10 columnas por 10 filas y así sucesivamente. Por ello, tenemos dos estructuras repetitivas "PARA" una dentro de otra.

Proceso

En cada ciclo (que representa cada fila) se reinicia la variable "cade", para que sea reescrita en cada iteración. En cada columna se valida si supera o no al tamaño medio (ta/2), en el primer condicional se evalúa posteriormente que vaya del inicio subiendo de uno en uno o desde el final retrocediendo de uno en uno y en esos casos se escribe una "@", caso contrario se escriben espacios en blanco (" ").

Luego que supera a la mitad de filas se debe replantear al condicional con otro que hace lo opuesto del anterior, va escribiendo filas con "@" y cada vez más espacios en blanco en medio y eso genera la mariposa final.

Creando un Reloj con PseInt

Código

---

El reloj que se ha realizado en PseInt primero pide la hora, minutos y segundos con los que va a iniciar, mediante el uso de estructuras repetitivas valida datos correctos y posteriormente muestra la hora ingresada y avanza tal cual lo hace un reloj de segundo en segundo mediante la función ESPERAR

Proceso reloj
   Definir hora, minuto, segs Como Entero
   Repetir
     Escribir "Ingrese la hora"
     Leer hora 
   Hasta Que hora>=0 Y hora <24
   Repetir
     Escribir "Ingrese los minutos"
     Leer minuto  
   Hasta Que hora>=0 Y hora <60
   Repetir
     Escribir "Ingrese los segundos"
     Leer segs  
   Hasta Que hora>=0 Y hora <60
   Escribir "Presiona una tecla para comenzar"
   Esperar Tecla
   Mientras Verdadero Hacer
     Limpiar Pantalla
     Si hora<10 Entonces
       Escribir "0" hora Sin Saltar
     Sino
       Escribir hora Sin Saltar
     FinSi
     Escribir " : " Sin Saltar
     Si minuto<10 Entonces
       Escribir "0" minuto Sin Saltar
     Sino
       Escribir minuto Sin Saltar
     FinSi  
     Escribir " : " Sin Saltar
     Si segs<10 Entonces
       Escribir "0" segs
     Sino
       Escribir segs
     FinSi
     segs<-segs+1  
     Si segs=60 Entonces
       minuto<-minuto+1
       segs<-0
       Si minuto=60 Entonces
         hora<- hora+1
         minuto<-0
         Si  hora=24 Entonces
           hora<-0
         FinSi
       FinSi
     FinSi 
     Esperar 1 Segundo  
   FinMientras
FinProceso

Ejercicios con PseInt de estructuras repetitivas - Avanzado

EJERCICIO #1

---

Crear una calculadora de MCD en pseudocódigo, que permita ingresar dos números y muestre el MCD. Solo se debe permitir ingresar números enteros positivos

Proceso maximoComunDivisor
 //Variables de entrada
 Definir a, b Como Real 
 //Variable auxiliar
 Definir aux Como Entero
 //Variable de salida
 Definir mcd Como Entero
 //CAPTURA DE DATOS
 Repetir
  Escribir "Ingrese un número"
  Leer a
 Hasta Que a > 0
 Repetir
  Escribir "Ingrese otro número"
  Leer b
 Hasta Que b > 0
 //PROCESO y SALIDA
 Si a<b Entonces
  aux <- b
 SiNo
  aux <- a
 FinSi
 mcd <- 1
 Para i<-2 Hasta aux Con Paso 1 Hacer
  Mientras  a % i = 0 & b% i = 0 Hacer
   a<-a/i
   b<-b/i
   mcd <- mcd * i
  FinMientras
 FinPara
 Escribir mcd
FinProceso

EJERCICIO #2

---

Realizar un pseudocódigo que permita ingresar un número positivo, luego una base menor a 10 y devuelva el número en dicha base.

Proceso base10aBaseMenor
 //Variables de entrada
 Definir a,b Como Entero 
 //Variable auxiliar
 Definir aux Como Entero
 //Variable de salida
 Definir bin Como Entero
 //Inicializar contador
 aux<-1
 //Inicializar acumulador
 bin<-0
 //CAPTURA DE DATOS
 Repetir
  Escribir "Ingrese un número positivo"
  Leer a
 Hasta Que a > 0
 Repetir
  Escribir "Ingrese la base menor de 10"
  Leer b
 Hasta Que b > 0 & b < 10
 //PROCESO y SALIDA 
 Escribir a Sin Saltar
 Mientras a>=b Hacer
  bin<-bin+(a%b)*aux
  aux<-aux*10
  a<-(a-a%b)/b
 FinMientras 
 bin<-bin+(a)*aux
 Escribir " en base ",b," es: ", bin
FinProceso

EJERCICIO #3

---

Crear un pseudocódigo que permita ingresar una frase u oración y devuelva la cantidad de vocales que hay.

Proceso buscarVocales
 Definir frase Como Caracter
 Definir cont Como Entero
 Dimension vocales(5)
 vocales[1] <- ["a"]
 vocales[2] <- ["e"]
 vocales[3] <- ["i"]
 vocales[4] <- ["o"]
 vocales[5] <- ["u"]
 cont<-0
 Escribir "Ingrese una frase u oración"
 Leer frase 
 Para i<-1 hasta Longitud(frase) Con Paso 1 Hacer
  Para j<-1 hasta 5 Con Paso 1 Hacer   
   Si Subcadena(frase,i,i)=vocales[j] Entonces 
    cont<-cont+1
   FinSi
  FinPara
 FinPara
 Escribir "La cantidad de vocales es: ", cont
FinProceso

EJERCICIO #4

---

Crear un algoritmo que simule "n" lanzamientos de un dado y muestre el valor que salió en cada lanzamiento. Finalmente debe mostrar una tabla resumen de cuantas veces salio cada valor. Nota: use arreglos

Proceso buscarVocales
 Definir lanzamientos Como Entero
 Definir aux Como Entero
 Dimension valores(6)
 //Inicializar la matriz
 Para j <- 1 Hasta 6 Con Paso 1 Hacer
  valores[j] <- 0
 FinPara
 //CAPTURA DE DATOS
 Repetir
  Escribir "Ingrese el número de lanzamientos del dado"
  Leer lanzamientos  
 Hasta Que lanzamientos > 0
 //PROCESO
 Para i<-1 hasta lanzamientos Con Paso 1 Hacer
  aux <- azar(6)+1
  Escribir "Lanzamiento #",i," salió ",aux
  valores[aux]<-valores[aux]+1
 FinPara
 //SALIDA
 Escribir "==============================================="
 Escribir "=================== RESUMEN ==================="
 Escribir "===============================================" 
 Para k <- 1 Hasta 6 Con Paso 1 Hacer
  Escribir "Lanzamientos que salieron ",k," : ", valores[k]
 FinPara
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que permita calcular el sueldo mensual de "n" empleados de una empresa. Se ingresa el nombre, categoria y número horas trabajadas. Si la categoría es A, el pago por hora es de 50 soles, si es B es de 35 soles, si es C es de 25 soles y si es D es de 21 soles. Luego mostrar el pago que le corresponde a cada trabajador, el pago total que se debe hacer, el total de trabajadores que ganan menos de 1000 soles, el total que ganan desde 1000 soles a 4000 soles y los que ganan más de 4000 soles.

Proceso resumen
 Definir n, horas, t1k, t1k_4k, t4k Como Entero
 Definir nombre, categ Como Caracter
 Definir sueldo, tSueldo Como Real
 //Inicializar contadores
 t1k <- 0 //Menos de 1000
 t1k_4k <- 0 //De 1000 a 4000
 t4k <- 0 //Más de 4000
 //Inicializar acumulador
 tSueldo <- 0
 Repetir
  Escribir "Ingrese el número de empleados"
  Leer n  
 Hasta Que n > 0
 Dimension trab_dat[n,2]
 Dimension trab_num[n,2]
 Para i<-1 Hasta n Con Paso 1 Hacer
  Repetir
   Escribir "Ingrese el nombre del trabajador #",i
   Leer nombre   
  Hasta Que longitud(nombre)>0
  Repetir
   Escribir "Ingrese el número de horas del trabajador #",i
   Leer horas   
  Hasta Que horas>=0
  Repetir
   Escribir "Ingrese la categoria del trabajador #",i
   Leer categ
   categ <- Mayusculas(categ)
  Hasta Que categ="A" | categ="B" | categ="C" | categ="D"
  Segun categ Hacer
   "A": sueldo <- horas*50
   "B": sueldo <- horas*35
   "C": sueldo <- horas*25
   "D": sueldo <- horas*21
  FinSegun
  trab_dat[i,1]<-nombre
  trab_num[i,1]<-horas
  trab_dat[i,2]<-categ
  trab_num[i,2]<-sueldo
  tSueldo <- tSueldo + sueldo
  Si sueldo < 1000 Entonces
   t1k <- t1k + 1
  SiNo
   Si sueldo <= 4000 Entonces
    t1k_4k <- t1k_4k + 1
   SiNo
    t4k <- t4k + 1    
   FinSi
  FinSi
 FinPara
 Escribir "==========LISTA DE EMPLEADOS=========="
 Para i<-1 Hasta n Con Paso 1 Hacer  
  Escribir "NOMBRE: ", trab_dat[i,1]
  Escribir "CAT | HORAS | SUELDO"
  Escribir " ",trab_dat[i,2], "  |   " Sin Saltar
  Escribir trab_num[i,1], "   " Sin Saltar
  Escribir " S/",trab_num[i,2]
 FinPara
 Escribir "======================================"
 Escribir "===============RESUMEN================"
 Escribir "PAGO TOTAL         :  S/",tSueldo
 Escribir "Menos de S/1000    :  ",t1k, " trabajadores"
 Escribir "De S/1000 a S/4000 :  ",t1k_4k, " trabajadores"
 Escribir "Más de S/4000      :  ",t4k, " trabajadores"
 Escribir "======================================"
 Escribir "======================================"
FinProceso

Ejercicios con PseInt de estructuras repetitivas - Intermedio

EJERCICIO #1

---

Crear una calculadora en pseudocódigo, que permita ingresar un número positivo y lo devuelva en binario.

Proceso base10a2
   //Variables de entrada
   Definir a Como Entero 
   //Variable auxiliar
   Definir aux Como Entero
   //Variable de salida
   Definir bin Como Entero
   //Inicializar contador
   aux<-1
   //Inicializar acumulador
   bin<-0
   //CAPTURA DE DATOS
   Repetir
     Escribir "Ingrese un número positivo"
     Leer a
   Hasta Que a > 0
   //PROCESO y SALIDA 
   Escribir a Sin Saltar
   Mientras a>=2 Hacer
     bin<-bin+(a%2)*aux
     aux<-aux*10
     a<-(a-a%2)/2
   FinMientras 
   bin<-bin + a * aux
   Escribir " en binario es: ", bin
FinProceso

EJERCICIO #2

---

Realizar un pseudocódigo que permita calcular el factorial de un número entero positivo. Nota: Mostrar 1 si se pide calcular el factorial de cero.

Proceso factorial
 //Variables de entrada
 Definir num,fact Como Entero 
 //Inicializar acumulador
 fact<-1
 //CAPTURA DE DATOS
 Repetir
  Escribir "Ingrese el primer número"
  Leer num
 Hasta Que num >= 0 
 //PROCESO
 Para i<-1 Hasta num Con Paso 1 Hacer
  fact<-fact*i
 FinPara 
 //SALIDA
 Escribir num,"! = ", fact
FinProceso

EJERCICIO #3

---

Realizar un pseudocódigo que permita calcular el monto total de sueldos de todos los empleados de N empleados de una empresa para el mes de Junio. Se ingresa el nombre, número de días programados y número de días que faltó por cada empleado. Además, se pide el monto total de sueldos de todos los empleados. El pago por día a cada empleado es 50 soles y el descuento por día de falta es de 100% del pago diario.

Proceso sueldos
 Definir n,dt,df Como Entero
 Definir nombre Como Caracter
 Definir aux,sTotal Como Real
 Repetir
  Escribir "Ingrese el número de empleados"
  Leer n
   sTotal <- 0
 Hasta Que n>0
 Para i<-1 Hasta n Con Paso 1 Hacer
  Escribir "Ingrese el nombre del trabajador #",i
  Leer nombre
  Repetir
   Escribir "Ingrese los días programados"
   Leer dt
  Hasta Que dt < 31 & dt > 0  
  Repetir
   Escribir "Ingrese los días que faltó"
   Leer df
  Hasta Que df <= dt & dt > 0
  aux <- (dt-df) * 50
  sTotal <- sTotal + aux
 FinPara
 Escribir "El monto total por los sueldos es: S/", sTotal
FinProceso

EJERCICIO #4

---

Desarrollar un pseudocódigo que luego de ingresar 2 números naturales, donde el segundo debe ser mayor que el primero, por teclado. Luego imprima los números naturales pares que hay entre ambos empezando por el menor y luego haga el mismo proceso para los impares

Proceso entreNumeros2
 //Variables de entrada
 Definir n1,n2 Como Entero
 //CAPTURA DE DATOS
 Repetir
  Escribir "Ingrese el primer número"
  Leer n1
 Hasta Que n1 > 0
 Repetir
  Escribir "Ingrese el segundo número"
  Leer n2
 Hasta Que n2 > n1 
 //PROCESO y SALIDA
 Si n1 % 2 <> 0 Entonces  
  Escribir "NUMEROS PARES"
  Para i<-n1+1 Hasta n2-1 Con Paso 2 Hacer
   Escribir i " ; " Sin Saltar
  FinPara  
  Escribir ""
  Escribir "NUMEROS IMPARES"
  Para i<-n1+2 Hasta n2-1 Con Paso 2 Hacer
   Escribir i " ; " Sin Saltar
  FinPara
 SiNo
  Escribir "NUMEROS PARES"
  Para i<-n1+2 Hasta n2-1 Con Paso 2 Hacer
   Escribir i " ; " Sin Saltar
  FinPara  
  Escribir ""  
  Escribir "NUMEROS IMPARES"
  Para i<-n1+1 Hasta n2-1 Con Paso 2 Hacer
   Escribir i " ; " Sin Saltar
  FinPara  
  Escribir ""
 FinSi
FinProceso

EJERCICIO #5

---

Crear una algoritmo en pseudocódigo que permita ingresar un número positivo y muestre el número de cifras totales, el número de cifras pares e impares

Proceso cifras
   //Variables de entrada
   Definir a Como Entero 
   //Variables de salida
   Definir c,cp,ci Como Entero 
   //Inicializacion de contadores
   c<-0
   cp<-0
   ci<-0
   //CAPTURA DE DATOS
   Repetir
     Escribir "Ingrese un número positivo"
     Leer a
   Hasta Que a > 0
   //PROCESO y SALIDA
   Mientras a<>0 Hacer
     Si (a % 10) % 2 = 0 Entonces
       cp<-cp+1
     SiNo
       ci<-ci+1   
     FinSi
     a<-TRUNC(a/10)
     c<-c+1
   FinMientras
   Escribir "Cifras pares  : ",cp
   Escribir "Cifras impares: ",ci
   Escribir "Cifras totales: ",c
FinProceso

Ejercicios con PseInt de estructuras repetitivas - Básico

EJERCICIO #1

---

Construir un pseudocódigo que solo permita ingresar números positivos, en caso de que el número no sea positivo debe volver a pedir que se ingrese el número hasta que el usuario ingrese un número positivo, luego mostrar el número.

Proceso soloPositivo
   //Variables de entrada
   Definir num Como Real 
   //CAPTURA DE DATOS
   Repetir
     Escribir "Ingrese un número"
     Leer num
   Hasta Que num > 0
   //PROCESO y SALIDA
   Escribir "El número es: ", num
FinProceso

EJERCICIO #2

---

Realizar un pseudocódigo que solo permita ingresar dos números diferentes, sin finalizar el proceso, luego muestre el menor y el mayor

Proceso diferentes
   //Variables de entrada
   Definir n1,n2 Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese un número"
   Leer n1
   Repetir
     Escribir "Ingrese un número diferente de ", n1
     Leer n2
   Hasta Que n2 <> n1
   //PROCESO y SALIDA
   Si n2 < n1 Entonces
     Escribir "Mayor ", n1
     Escribir "Menor ", n2
   SiNo
     Escribir "Mayor ", n2
     Escribir "Menor ", n1
   FinSi
FinProceso

EJERCICIO #3

---

Realizar un pseudocódigo que muestre la frase: "¿Que podría ser peor?" diez veces usando la estructura repetitiva para.

Proceso frase
   //PROCESO y SALIDA
   Para i <- 1 Hasta 10 Con Paso 1 Hacer
     Escribir "¿Que podría ser peor?"
   Fin Para
FinProceso

EJERCICIO #4

---

Crear una algoritmo en pseudocódigo que permita ingresar un número entre 0 y 12, luego muestre la tabla de multiplicar de dicho número del 0 al diez

Proceso tabla
 //Variable de entrada
 Definir num Como Entero
 //CAPTURA DE DATOS
 Repetir
  Escribir "Ingrese un número"
  Leer num
 Hasta Que num >= 0 & num <= 10 
 //PROCESO y SALIDA 
 Para i<-0 Hasta 10 Con Paso 1 Hacer
  Escribir num, "x",i," = ", (num*i)
 FinPara
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que luego de ingresar 2 números naturales, donde el segundo debe ser mayor que el primero, por teclado. Luego imprima los números naturales que hay entre ambos empezando por el mayor.

Proceso entreNumeros
   //Variables de entrada
   Definir n1,n2 Como Entero
   //CAPTURA DE DATOS
   Repetir
     Escribir "Ingrese el primer número"
     Leer n1
   Hasta Que n1 > 0
   Repetir
     Escribir "Ingrese el segundo número"
     Leer n2
   Hasta Que n2 > n1 
   //PROCESO y SALIDA 
   Escribir "Números entre ",n1," y ", n2, " de mayor a menor: "
   Para i<-n2-1 Hasta n1+1 Con Paso -1 Hacer
     Escribir i " ; " Sin Saltar
   FinPara  
   Escribir ""  
FinProceso

Ejercicios con PseInt de estructuras condicionales - Avanzado

EJERCICIO #1

---

Construir un pseudocódigo que permita el sueldo base de un trabajador (asumimos que el usuario ingresa un valor mayor a cero), su categoría (A,B o C) y la cantidad de hijos (asumimos que el usuario ingresa un valor mayor o igual que cero). Luego calcule y muestre su sueldo bruto de acuerdo a las siguientes tablas:

Categoría	Aumento
A	10% de su sueldo base
B	20% de su sueldo base
C	15% de su sueldo base

Número de hijos	Bono
Ninguno	0 soles
De 1 a 3	200 soles
De 4 a 6	350 soles
De 7 a más	500 soles

Proceso sueldo
   //Variables
   Definir hijos Como Entero
   Definir sBruto, sBase Como Real
   Definir cat Como Caracter
   //ENTRADA DE DATOS
   Escribir "Ingrese el sueldo base en soles"
   Leer sBase
   Escribir "Ingrese la categoria (A, B o C)"
   Leer cat
   Escribir "Ingrese el número de hijos"
   Leer hijos
   //PROCESO
   Segun MAYUSCULAS(cat) hacer
     Caso "A": sBruto <- sBase*1.1
     Caso "B": sBruto <- sBase*1.2
     Caso "C": sBruto <- sBase*1.15
   FinSegun
   Si hijos > 0 Entonces  
     Si hijos >= 1 & hijos <=3 Entonces
       sBruto <- sBruto + 200
     SiNo
       Si hijos > 3 & hijos <=6 Entonces
         sBruto <- sBruto + 350
       SiNo
         sBruto <- sBruto + 500
       FinSi
     FinSi 
   FinSi
   //SALIDA
   Escribir "El sueldo bruto es: S/", sBruto
FinProceso

EJERCICIO #2

---

Construir un pseudocódigo que permita ingresar la fecha de un año (valor mayor que cero) y muestre un mensaje indicando si es bisiesto o no. Nota: Mostrar una advertencia si se ingresa un valor menor igual que cero.

Proceso bisiesto
   Definir anio Como Entero 
   Escribir "Ingresa el año"
   Leer anio
   Si anio > 0 Entonces
     Si anio % 4 = 0 entonces
       Si anio % 100 = 0 entonces
         Si anio % 400 = 0 Entonces    
           Escribir "El año ", anio, " es bisiesto"
         SiNo
           Escribir "El año ", anio, " no es bisiesto" 
         FinSi
       SiNo
         Escribir "El año ", anio, " es bisiesto"
       FinSi
     SiNo
       Escribir "El año ", anio, " no es bisiesto"  
     FinSi
   SiNo
     Escribir "AVERTENCIA: Año no válido"
   FinSi
FinProceso

EJERCICIO #3

---

Realizar un pseudocódigo que permita calcular el sueldo semanal de un trabajador. El programa debe pedir el total de horas trabajadas en la semana y el pago por hora. Si el total de horas trabajadas es mayor a 48 la diferencia de horas se considera como horas extras y se pagan un 50% más que una hora normal. Si el sueldo obtenido es mayor a S/ 500.00 se descuenta un 11% en caso contrario el descuento es del 5%. El programa debe mostrar el total de horas laboradas, la cantidad de horas extra, el sueldo sin descuentos y su sueldo final

Proceso sueldo
   //Variables
   Definir horas, hExtra como Entero
   Definir pagoHora, sBruto, sFinal como Real
   //ENTRADA DE DATOS
   Escribir "Ingrese en numero de horas trabajadas"
   Leer horas
   Escribir "Ingrese en monto de pago por hora"
   Leer pagoHora
   //PROCESO
   hExtra<-0
   Si horas > 48 entonces
     hExtra<- horas - 48
     horas<-48
   FinSi 
   sBruto<-horas*pagoHora+hExtra*pagoHora*1.5
   Si sBruto > 500 Entonces
     sFinal<-sBruto*0.89
   SiNo
     sFinal<-sBruto*0.95 
   FinSi
   //SALIDA
   Escribir "Las horas trabajadas son   : ", horas+hExtra, " horas"
   Escribir "Las horas extra son        : ", hExtra, " horas"
   Escribir "El sueldo sin descuentos es: S/", sBruto
   Escribir "El sueldo final es         : S/", sFinal
FinProceso

EJERCICIO #4

---

Construir un pseudocódigo que permita ingresar un numero natural de dos a tres cifras y muestre el mensaje "Es capicúa" o "No es capicúa" según sea el caso. Nota: mostrar una advertencia si el número no es de 2 o 3 cifras.

Proceso capicua
   Definir num como Entero 
   Escribir "Ingresa un número de dos  o tres cifras"
   Leer num 
   Si num >= 10 & num < 100 entonces
     Si num % 11 = 0 Entonces
       Escribir "Es capicúa"
     SiNo
      Escribir "No es capicúa"
     FinSi
   SiNo
     Si num >= 100 & num < 1000 entonces 
       Si num % 10 = TRUNC(num/100) Entonces
         Escribir "Es capicúa"
       SiNo
         Escribir "No es capicúa"
       FinSi
     SiNo
       Escribir "ADVERTENCIA: Ingrese un numero de dos o tres cifras"
     FinSi 
   FinSi 
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que permita ingresar un año, valide que sea mmayor que cero, luego un mes (validando que se encuentra entre 1 y 12). Finalmente el día y muestre un mensaje señalando si la fecha existe. Nota: en caso la fecha no exista mostrar una advertencia.

Proceso validarFecha
   Definir d,m,a,aux Como Entero
   Escribir "Ingrese el año"
   Leer a
   Si a > 0 Entonces
     Escribir "Ingrese el mes"
     Leer m
     Si m>0 & m<=12 Entonces
       Escribir "Ingrese el día"
       Leer d
       Segun m hacer
         1,3,5,7,10,12:
           Si d > 0 & d <=31 Entonces
             Escribir "Fecha: ",d,"-",m,"-",a," válida"
           SiNo
             Escribir "AVERTENCIA: día no válido"
           FinSi
         2:
           Si a % 4 = 0 entonces
             Si a % 100 = 0 entonces
               Si a % 400 = 0 Entonces    
                 aux <- 29
               SiNo
                 aux <- 28 
               FinSi
             SiNo
               aux <- 29
             FinSi
           SiNo
             aux <- 28  
           FinSi
           Si d > 0 & d <=aux Entonces
             Escribir "Fecha: ",d,"-",m,"-",a," válida"
           SiNo
             Escribir "AVERTENCIA: día no válido"
           FinSi     
         4,6,9,11:
           Si d > 0 & d <=30 Entonces
             Escribir "Fecha: ",d,"-",m,"-",a," válida"
           SiNo
             Escribir "AVERTENCIA: día no válido"
           FinSi     
       FinSegun
     SiNo   
       Escribir "AVERTENCIA: Mes no válido"
     FinSi
   SiNo
     Escribir "AVERTENCIA: Año no válido"
   FinSi
FinProceso

Ejercicios con PseInt de estructuras condicionales - Intermedio

EJERCICIO #1

---

Construir un pseudocódigo que permita ingresar un número y devuelva un mensaje de acuerdo a la siguiente tabla:

Valor	Mensaje
Menor de 0	Negativo
Igual a 0	Neutro
Mayor de 0	Positivo

Proceso rangos
   //Variable de entrada
   Definir num Como Real  
   //CAPTURA DE DATOS
   Escribir "Ingrese el número"
   Leer num
   //PROCESO y SALIDA
   Si num < 0 Entonces
     Escribir "Negativo"
   SiNo
     Si num = 0 Entonces
       Escribir "Neutro"
     SiNo   
       Escribir "Positivo"
     FinSi
   FinSi
FinProceso

EJERCICIO #2

---

Construir un pseudocódigo que permita ingresar dos número y un símbolo (+,-,x,÷) y dependiendo del operador devuelva la suma, la diferencia, el producto o la división. Nota: verificar que el divisor no sea cero y mostrar una advertencia si se ingresa un valor diferente a esos símbolos

Proceso operadores
   //Variables de entrada
   Definir n1,n2 Como Real 
   Definir simbolo Como Caracter  
   //CAPTURA DE DATOS
   Escribir "Ingrese los números"
   Leer n1,n2
   Escribir "Ingrese el símbolo (+,-,x,÷)"
   Leer simbolo 
   //PROCESO y SALIDA
   Segun simbolo hacer
      Caso "+":
         Escribir n1 , " + ", n2, " = ", (n1+n2)
      Caso "-":
         Escribir n1 , " - ", n2, " = ", (n1-n2)
      Caso "x":
         Escribir n1 , " x ", n2, " = ", (n1*n2)
      Caso "÷":
         Si n2 <> 0 Entonces
           Escribir n1 , " ÷ ", n2, " = ", (n1/n2)
         SiNo
           Escribir "No se puede dividir entre cero"
         FinSi
      De Otro Modo:
         Escribir "ADVERTENCIA: Operador inválido"
   FinSegun
FinProceso

EJERCICIO #3

---

Realizar un pseudocódigo que permita ingresar tres números (asumimos que el usuario ingresa tres números diferentes) y nos muestre el menor de ellos.

Proceso elMenor
   //Variables de entrada
   Definir n1,n2,n3 Como Real 
   //Variable de salida
   Definir mnor Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese tres números diferentes"
   Leer n1,n2,n3
   //Inicialización de la variable 
   //que contiene al menor
   mnor <- n1
   //PROCESO 
   Si n2 < mnor Entonces
     mnor <- n2
   FinSi 
   Si n3 < mnor Entonces
     mnor <- n3
   FinSi
   //SALIDA
   Escribir "El menor es: ", mnor
FinProceso

EJERCICIO #4

---

Construir un algoritmo que al ingresar un número desde 1 hasta el 29. Luego muestre en pantalla el número escrito en forma literal. Por ejemplo, si se ingresa 12 debe mostrar doce.

Proceso literal
   Definir num, dec, uni Como Entero
   Definir nom, unidad, decena Como Caracter
   Escribir "Ingrese un número del 1 al 29"
   Leer num
   Si num < 30 & num > 0 Entonces
     Si num < 10 Entonces
       uni <- num
       dec <- 0
     SiNo
       uni <- num % 10
       dec <- (num-uni)/10
     FinSi
     Segun dec Hacer
       0: decena <- ""
       1: 
         Segun uni Hacer
           0:
             decena <- "diez"
           1:
             decena <- "once"
           2:
             decena <- "doce"
           3:
             decena <- "trece"
           4:
             decena <- "catorce"
           5:
             decena <- "quince"
           De Otro Modo:
             decena <- "dieci"
         FinSegun    
       2: 
         Si uni <>0 Entonces
           decena <- "veinti"     
         Sino
           decena <- "veinte"
         FinSi    
     FinSegun
     Segun uni Hacer
       0:
         unidad <- ""
       1:
         unidad <- "uno"
       2:
         unidad <- "dos"
       3:
         unidad <- "tres"
       4:
         unidad <- "cuatro"
       5:
         unidad <- "cinco"
       6:
         unidad <- "seis"
       7:
         unidad <- "siete"
       8:
         unidad <- "ocho"
       9:
         unidad <- "nueve"
     FinSegun
     Si num > 9 Entonces
       Si num <=15 Entonces
         nom <- decena
       SiNo
         nom <- decena+unidad
       FinSi
     SiNo
       nom <- unidad
     FinSi
       Escribir "El número ", num, " se lee: ", Mayusculas(nom)
   SiNo
     Escribir "ADVERTENCIA: Ingrese un valor del 1 al 29"
   FinSi
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que permita ingresar las medidas de los tres lados de un triángulo y mostrar en pantalla si el triángulo es equilátero, isóceles, escaleno o no puede existir.

Proceso operadores
   //Variables de entrada
   Definir l1,l2,l3 Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese las medidas de los lados de un triángulo" 
   Leer l1,l2,l3 
   //PROCESO y SALIDA
   Si l1+l2<=l3 O l1+l3<=l2 O l3+l2<=l1 Entonces
     Escribir "El triángulo no existe"
   SiNo
     Si l1=l2 Y l2=l3 Entonces
       Escribir "El triángulo es equilátero"
     Sino
         Si l1 <> l2 Y l1 <>l3 Y l2<>l3 Entonces
           Escribir "El triángulo es escaleno"
         SiNo
           Escribir "El triángulo es isóceles"
        FinSi
     FinSi
   FinSi
FinProceso

Ejercicios con PseInt de estructuras condicionales - Básico

EJERCICIO #1

---

Construir un pseudocódigo que permita ingresar un número, si el número es mayor de 500, se debe calcular y mostrar en pantalla el 18% de este.

Proceso quinientos
   //Variables de entrada
   Definir num Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese un número"
   Leer num
   //PROCESO y SALIDA
   Si num > 500 Entonces
     Escribir num*0.18
   FinSi
FinProceso

EJERCICIO #2

---

Realizar un pseudocódigo que permita ingresar un número, si el número es menor de 100 debe mostrar el 10% del número, en caso contrario debe mostrar el 20% del número.

Proceso cien
   //Variables de entrada
   Definir num Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese un número"
   Leer num
   //PROCESO y SALIDA
   Si num < 100 Entonces
     Escribir num*0.1
   SiNo
     Escribir num*0.2  
   FinSi
FinProceso

EJERCICIO #3

---

Realizar un pseudocódigo que permita ingresar dos números (asumimos que el usuario ingresa dos números diferentes) y nos muestre el mayor de ambos.

Proceso elMayor
   //Variables de entrada
   Definir n1,n2 Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese dos números diferentes"
   Leer n1,n2
   //PROCESO y SALIDA
   Si n1 > n2 Entonces
     Escribir "El mayor es: ",n1
   SiNo
     Escribir "El mayor es: ",n2  
   FinSi
FinProceso

EJERCICIO #4

---

Crear una calculadora de división en pseudocódigo, que permita ingresar dos números y muestre el cociente. En caso de ingresar cero en el divisor nos debe decir: "No se puede dividir entre cero"

Proceso calculadora2
   //Variables de entrada
   Definir a, b Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese dos números"
   Leer a, b 
   //PROCESO y SALIDA
   Si b<>0 Entonces
     Escribir a , " ÷ ", b, " = ", (a/b)
   SiNo
     Escribir "No se puede dividir entre cero"
   FinSi
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que permita ingresar dos números, si son diferentes los debe multiplicar en caso contrario los debe sumar y mostrar el resultado en pantalla.

Proceso diferentesIguales
   //Variables de entrada
   Definir a, b Como Real 
   //CAPTURA DE DATOS
   Escribir "Ingrese dos números"
   Leer a, b 
   //PROCESO y SALIDA
   Si a<>b Entonces
     Escribir a , " x ", b, " = ", (a*b)
   SiNo
     Escribir a , " + ", b, " = ", (a+b)
   FinSi
FinProceso

Ejercicios con PseInt de estructuras secuenciales - Avanzado

EJERCICIO #1

---

Construir un pseudocódigo que que calcule la distancia entre dos puntos cuyas coordenadas se ingresan al algoritmo.

Proceso distancia2puntos
   //Variables de entrada
   Definir x1,y1,x2,y2 Como Real
   //Variable de salida
   Definir distancia Como Real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese las coordenadas del primer punto (x1;y1)"
   Leer x1, y1
   Escribir "Ingrese las coordenadas del segundo punto (x2;y2)"
   Leer x2, y2
 
   //PROCESO
   distancia <- RAIZ( (y2-y1)^2 + (x2-x1)^2 )
 
   //SALIDA
   Escribir "La distancia entre los puntos: " Sin Saltar
   Escribir "(", x1, " ; ", y1 , ") y " Sin Saltar
   Escribir "(", x2, " ; ", y2 , ")" Sin Saltar
   Escribir " es: ", distancia
FinProceso

EJERCICIO #2

---

Construir un algoritmo que convierta un número entre 8 y 15 a binario. (No utilizar estructuras condicionales y asumir que el usuario solo ingresa valores entre 8 y 15)

Proceso binario
   //Variable de entrada
   Definir num Como Real
   //Variables auxiliares
   Definir aux Como Real
   //Variables de salida
   Definir  a,b,c Como Real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese un binario entre 8 y 15"//1000 1111
   Leer num
 
   //PROCESO
   aux <- num
   a <- aux mod 2
   aux <- TRUNC(aux/2)
   b <- aux mod 2
   aux <- TRUNC(aux/2)
   c <- aux mod 2 
  
   //SALIDA
   Escribir "El número ", num," es en binario: 1",c,b,a
FinProceso

EJERCICIO #3

---

Un padre repartirá una cantidad de dinero entre sus cinco hijos. Cada uno recibirá una cantidad equivalente a:

• Tamara: 85% del monto recibido por Josué
• Josué: 27% de la cantidad a repartir
• Caleb: 23% del monto total recibido entre Josué y Daniel
• Daniel: 25% de la cantidad a repartir
• David: lo que queda del dinero a repartir

Dada la cantidad de dinero a repartir, desarrolle un pseudocodigo que determine cuánto de dinero recibirá cada hijo. (Asumimos que el usuario ingresa valores positivos en la cantidad de dinero a repartir)

Proceso reparto
   //Variable de entrada
   Definir monto Como Real
   //Variables de salida
   Definir h1,h2,h3,h4,h5 Como Real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese el monto para la repartición"
   Leer monto 
 
   //PROCESO
   h2 <- monto*0.27
   h1 <- h2*0.85
   h4 <- monto*0.25
   h3 <- (h1 + h4)*0.23
   h5 <- monto-h1-h2-h3-h4
 
   //SALIDA
   Escribir "Tamara recibirá S/", h1
   Escribir "Josué recibirá  S/", h2
   Escribir "Caleb recibirá  S/", h3
   Escribir "Daniel recibirá S/", h4
   Escribir "David recibirá  S/", h5 
FinProceso

EJERCICIO #4

---

Realizar un pseudocódigo que permita ingresar el número de lados de un polígono regular y la medida de sus lados. Luego muestre el perímetro y área del polígono(Asumimos que el usuario ingresa valores positivos)

Proceso poligonos
   //Variables de entrada
   Definir lados, medida_lado Como Real
   //Variables auxiliares
   Definir angulo_interno, apotema Como Real
   //Variables de salida
   Definir perimetro, area Como Real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese el número de lados"
   Leer lados
   Escribir "Ingrese la medida del lado"
   Leer medida_lado
 
   //PROCESO
   perimetro <- lados * medida_lado
   angulo_interno <- 180 - 360 / lados
   apotema <- medida_lado * TAN(angulo_interno*PI/360) / 2
   area <- perimetro * apotema / 2
   //SALIDA
   Escribir "El polígono de ", lados, " lados tiene:"
   Escribir "-> Perímetro: ", perimetro, " metros"
   Escribir "-> Área: ", area, " metros cuadrados"
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que permita ingresar una oración, luego devuelva el texto en minúsculas, mayúsculas y la primera letra en mayúsculas y las demás en minúsculas.

Proceso textos
   //Variable de entrada
   Definir oracion Como Caracter
   //Variables auxiliares
   Definir long Como Entero
   Definir parte_a,parte_b Como Caracter
   //Variables de salida
   Definir minus, mayus, capital Como Caracter
 
   //CAPTURA DE DATOS
   Escribir "Ingrese una oración"
   Leer oracion
 
   //PROCESO
   minus <- MINUSCULAS(oracion)
   mayus <- MAYUSCULAS(oracion)
   long <- LONGITUD(oracion)
   parte_a <- MAYUSCULAS(SUBCADENA(oracion,1,1))
   parte_b <- MINUSCULAS(SUBCADENA(oracion,2,long))
   capital <- CONCATENAR(parte_a,parte_B)
 
   //SALIDA
   Escribir "La oración en minúscula    : ", minus
   Escribir "La oración en mayúscula    : ", mayus
   Escribir "La oración en letra capital: ", capital
FinProceso

Ejercicios con PseInt de estructuras secuenciales - Intermedio

EJERCICIO #1

---

Construir un pseudocódigo que permita ingresar el precio base de un vehículo y calcule la comisión e impuesto que son el 12% y 18% y el precio final (Asumimos que el usuario solo ingresa valores mayores a cero en el precio base)

Proceso vehiculo
   //Variables de entrada
   Definir precio_base como Real
   //Variables de salida
   Definir comision, impuesto, precio_final como real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese precio base del vehículo"
   Leer precio_base
 
   //PROCESO
   comision<-precio_base*12/100
   impuesto<-precio_base*18/100 
   precio_final<-precio_base+comision+impuesto
 
   //SALIDA  
   Escribir "El precio base es:  S/", precio_base
   Escribir "La comision es:     S/", comision
   Escribir "El impuesto es:     S/", impuesto
   Escribir "El precio final es: S/", precio_final 
FinProceso

EJERCICIO #2

---

Realizar un pseudocódigo que solicite los nombres, apellidos, sueldo base, número de hijos y número de horas extra de un trabajador. Luego debe mostrar en pantalla su sueldo bruto que es el sueldo base más 100 soles por hijo y 25 soles por hora extra, luego el monto de su AFP (descuento) que equivale al 11% del sueldo bruto y finalmente su sueldo neto que es el resultado del sueldo bruto menos su AFP (Asumimos que el usuario solo ingresa valores mayores a cero en el sueldo base y mayores o iguales a cero en número de hijos y horas extra)

Proceso sueldo
   //Variables de entrada
   Definir nombres,apellidos Como Caracter
   Definir num_hijos,num_horas como Entero
   Definir sueldo_base Como Real
 
   //Variables de salida
   Definir sueldo_bruto,sueldo_neto,afp Como Real
 
   //CAPTURA DE DATOS
   Escribir "ingrese los datos"
   Leer nombres, apellidos
   Escribir "ingrese el sueldo base"
   Leer sueldo_base
   Escribir "ingrese el numero de hijos"
   Leer num_hijos
   Escribir "ingrese el numero de horas extra"
   Leer num_horas
 
   //PROCESO
   sueldo_bruto<-sueldo_base+100*num_hijos+25*num_horas
   afp<-0.11*sueldo_bruto
   sueldo_neto<-sueldo_bruto-afp
 
   //SALIDA
   Escribir "Datos del trabajador: ", nombres, " ", apellidos
   Escribir "Sueldo bruto S/", sueldo_bruto
   Escribir "Afp          S/", afp
   Escribir "Sueldo neto  S/", sueldo_neto 
FinProceso

EJERCICIO #3

---

Realizar un pseudocódigo que permita ingresar un el sueldo base de un vendedor, el valor de las 3 ventas que realiza y muestre la comisión por sus ventas(el 10% del total de ventas) y su sueldo final (Asumimos que el usuario ingresa valores positivos)

Proceso comision_vendedor
   //Variables de entrada
   Definir sueldo_base, v1, v2 ,v3 Como Real
   //Variables de salida
   Definir comision, sueldo_final Como Real 
 
   //CAPTURA DE DATOS
   Escribir "Ingrese su sueldo base"
   Leer sueldo_base
   Escribir "Ingrese sus ventas"
   Leer v1, v2, v3
 
   //PROCESO 
   comision<-(v1+v2+v3)*0.10
   sueldo_final <- sueldo_base + comision
 
   //SALIDA 
   Escribir "La comisión es:     S/", comision
   Escribir "El sueldo final es: S/", sueldo_final
FinProceso

EJERCICIO #4

---

Realizar un pseudocódigo que permita ingresar un el nombre de un equipo, los partidos ganados, empatados y perdidos y muestre su puntaje, si por cada ganado le dan 3 puntos, por empatado 1 y por perdido 0 (Asumimos que el usuario ingresa valores positivos)

Proceso puntaje
   //Variables de entrada
   Definir equipo Como Caracter
   Definir pg, pe, pp Como Entero
   //Variables de salida
   Definir ptotal Como Entero
 
   //CAPTURA DE DATOS
   Escribir "Ingrese el nombre del equipo"
   Leer equipo
   Escribir "ingrese los partidos ganados"
   Leer pg
   Escribir "ingrese los partidos empatados"
   Leer pe
   Escribir "ingrese los partidos perdidos"
   Leer pp 
 
   //PROCESO
   ptotal<-pg*3+pe*1+pp*0 // es opcional poner pp*0 
 
   //SALIDA
   Escribir "El equipo ", equipo," hizo ", ptotal, " puntos" 
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que permita ingresar un monto de inversión en soles y lo reparta en la refacción de cinco avenidas de la siguiente manera:

• Avenida La Mar - 35% del monto
• Avenida Abancay - 25% del monto
• Avenida 28 de Julio - 10% del monto
• Avenida Aviación - 15% del monto
• Avenida Tacna - restante del monto

Mostrar cuanto le correspondería a cada avenida.

Proceso avenidas
   //Variable de entrada
   Definir monto Como Real
   //Variables de salida
   Definir av1,av2,av3,av4,av5 Como Real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese el monto para la reparacion"
   Leer monto 
 
   //PROCESO
   av1 <- monto*0.35
   av2 <- monto*0.25
   av3 <- monto*0.10
   av4 <- monto*0.15
   av5 <- monto-av1-av2-av3-av4
 
   //SALIDA
   Escribir "La avenida La mar recibirá      S/", av1
   Escribir "La avenida Abancay recibirá     S/", av2
   Escribir "La avenida 28 de Julio recibirá S/", av3
   Escribir "La avenida Aviación recibirá    S/", av4
   Escribir "La avenida Tacna recibirá       S/", av5 
FinProceso

Ejercicios con PseInt de estructuras secuenciales - Básico

EJERCICIO #1

---

Construir un pseudocódigo para calcular el perímetro y área de un rectángulo. (Asumimos que el usuario solo ingresa valores mayores a cero y en metros)

Proceso rectangulo
   //Variables de entrada
   Definir base, altura Como Real
   //Variables de salida
   Definir area, perimetro Como Real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese la base y altura en metros"
   Leer base, altura
 
   //PROCESO
   area <- base * altura
   perimetro <- 2*(base + altura)
 
   //SALIDA
   Escribir "El perímetro es: ", perimetro, " metros."
   Escribir "El área es: ", area, " metros cuadrados." 
FinProceso

EJERCICIO #2

---

Realizar un pseudocódigo que pida el radio de un círculo y devuelva el valor del área y su perímetro (Asumimos que el usuario solo ingresa valores mayores a cero y en metros)

Proceso circulo
   //Variable de entrada
   Definir radio Como Real
   //Variables de salida
   Definir area, perimetro Como Real
 
   //CAPTURA DE DATOS
   Escribir "Ingrese el radio en metros"
   Leer radio
 
   //PROCESO
   area <- PI * radio^2
   perimetro <- 2*PI*radio
 
   //SALIDA
   Escribir "El perímetro es: ", perimetro, " metros."
   Escribir "El área es: ", area, " metros cuadrados." 
FinProceso

EJERCICIO #3

---

Realizar un pseudocódigo que permita ingresar un número y nos devuelve el doble, la mitad y el cuadrado de dicho número

Proceso dobleMitadCuadrado
   //Variable de entrada
   Definir num Como Real
  
   //CAPTURA DE DATOS
   Escribir "Ingrese el número"
   Leer num
  
   //PROCESO y SALIDA
   Escribir "El doble de ", num, " es: ", (2*num)
   Escribir "La mitad de ", num, " es: ", (num/2)
   Escribir "El cuadrado de ", num, " es: ", (num^2)
FinProceso

EJERCICIO #4

---

Crear una calculadora de adición, sustracción y multiplicación en pseudocódigo, que permita ingresar dos números y muestre la suma, resta y producto.

Proceso calculadora
   //Variables de entrada
   Definir a, b Como Real
  
   //CAPTURA DE DATOS
   Escribir "Ingrese los números"
   Leer a, b
  
   //PROCESO y SALIDA
   Escribir a , " + ", b, " = ", (a+b)
   Escribir a , " - ", b, " = ", (a-b)
   Escribir a , " x ", b, " = ", (a*b)
FinProceso

EJERCICIO #5

---

Desarrollar un pseudocódigo que convierta grados centígrados a grados Fahrenheit, grados kelvin y grados Rankine. El algoritmo debe mostrar los grados centígrados y las conversiones obtenidas.

Proceso temperaturas
   //Variables de entrada
   Definir cent, far, kel, rank Como Real
   //CAPTURA DE DATOS
   Escribir "Ingrese la temperatura en °C"
   Leer cent
   //PROCESO
   far <- (cent * 9/5) + 32
   kel <- cent + 273.15
   rank <- (cent * 9/5) + 491.67
   //SALIDA
   Escribir "Temperatura: ",cent," °C"
   Escribir "Temperatura: ",far," °F"
   Escribir "Temperatura: ",kel," °K"
   Escribir "Temperatura: ",rank," °R"  
FinProceso

Estructuras repetitivas REPETIR HASTA QUE - PSeInt (Ejemplo)

Supongamos el siguientes enunciados:

1. Elabore un programa que permita ingresar los nombres, apellidos y nota final de un estudiante, si la nota ingresada se encuentra fuera del rango de 0 a 20, el programa debe pedir nuevamente la nota hasta que esta se encuentre en el intervalo de 0 a 20. El programa no debe pedir nuevamente el nombre ya ingresado o reiniciarse.

Solución:

• Primero debemos definir cuales serán las variables con las que trabajaremos.  En el pseudocódigo se hace mediante la palabra reservada Definir, en los lenguajes de programación de alto nivel se hace mediante las palabras reservadas: var, int, String, Float, Decimal, etc. 

Definir nombres, apellidos Como Caracter
Definir nota Como Entero

• Luego debemos pedir que el usuario ingrese los datos del estudiante, pero para ello debemos escribir en pantalla un mensaje pidiéndole dicho valor. Para mostrar texto se usa la palabra reservada Escribir (el los lenguajes de alto nivel se usan palabras reservadas como cout, echo, etc) y para leer un valor que el usuario ingresa por teclado se usa la palabra reservada Leer (el los lenguajes de alto nivel se usan palabras reservadas como cin, scanner, etc.)

Escribir "Ingrese los nombres del estudiante"
Leer nombres
Escribir "Ingrese los apellidos del estudiante"
Leer apellidos

• Empleamos la estructura REPETIR HASTA QUE (el los lenguajes de alto nivel se usan palabras reservadas como DO WHILE) que nos va permitir evaluar el valor ingresado.

Repetir
   Escribir "Ingrese la nota final del estudiante";
   Leer nota
Hasta Que nota <= 20 Y nota >= 0

Nota: Se inicia el bucle pidiendo la nota, si esta es menor de 0 o mayor de 20, se repite el proceso, pero si la nota se encuentra dentro del rango de 0 a 20, solo se ejecutaría una vexz el bucle, pero mientras el usuario ingrese una nota no válida, se le estará pidiendo que ingrese la corrercta.

Código completo:

Proceso nota_valida
   Definir nombres, apellidos Como Caracter
   Definir nota Como Entero

   Escribir "Ingrese los nombres del estudiante"
   Leer nombres
   Escribir "Ingrese los apellidos del estudiante"
   Leer apellidos

   Repetir
      Escribir "Ingrese la nota final del estudiante";
      Leer nota
   Hasta Que nota <= 20 Y nota >= 0

   Escribir "Los datos del estudiante son: ", apellidos, " ,", nombres
   Escribir "Su nota final es: ", nota
FinProceso

Estructuras repetitivas MIENTRAS - PSeInt (Ejemplo)

Supongamos el siguientes enunciados:

1. Elabore un programa que permita ingresar un número y calcule el número de cifras.

Solución:

• Primero debemos definir cuales serán las variables con las que trabajaremos.  En el pseudocódigo se hace mediante la palabra reservada Definir, en los lenguajes de programación de alto nivel se hace mediante las palabras reservadas: var, int, String, Float, Decimal, etc. 

Definir num, cifras Como Entero
cifras <- 1

• Luego debemos pedir que el usuario ingrese la edad de la persona, pero para ello debemos escribir en pantalla un mensaje pidiéndole dicho valor. Para mostrar texto se usa la palabra reservada Escribir (el los lenguajes de alto nivel se usan palabras reservadas como cout, echo, etc) y para leer un valor que el usuario ingresa por teclado se usa la palabra reservada Leer (el los lenguajes de alto nivel se usan palabras reservadas como cin, scanner, etc.)

Escribir "Ingrese el número"
Leer num

• Cuando ingresemos el número, desconocemos el número de cifras de este, entonces utilizamos una estructura repetitiva que nos permite repetir sentencias mientras se cumpla una condición, en este caso, utilizamos la sentencia MIENTRAS (el los lenguajes de alto nivel se usa por lo general la palabra reservada WHILE), esta permite establecer una condición, y si se cumple esta condicion el bucle se ejecuta, hasta que la condición sea falsa.

Mientras num / 10 > 1 Hacer
   cifras <- cifras + 1
   num <- TRUNC(num / 10)
FinMientras

Nota: Se inicia el bucle evaluando la condición que al dividir el número entre 10, este resulta mayor que 1, en caso se introduzca 7, este resultado no será meor de 1 y la cantidad de cifras es 1, pero si se introduce 12 la división resulta 1.2 y al ser mayor de 1, se aumenta cifras de 1 a 2 y el numero se divide entre 10 quitándole la parte decimal con la función TRUNC (ver aquí más)

Código completo:

Proceso calcular_cifras
   Definir num, cifras Como Entero
   cifras <- 1

   Escribir "Ingrese el número"
   Leer num

   Mientras num / 10 > 1 Hacer
      cifras <- cifras + 1
      num <- TRUNC(num / 10)
   FinMientras

   Escribir "La cantidad de cifras del número es: ", cifras
FinProceso

Estructuras repetitivas PARA - PSeInt (Ejemplo)

Supongamos el siguientes enunciados:

1. Elabore un programa que permita ingresar la edad de diez personas e imprima en pantalla la edad mayor

Solución:

• Primero debemos definir cuales serán las variables con las que trabajaremos.  En el pseudocódigo se hace mediante la palabra reservada Definir, en los lenguajes de programación de alto nivel se hace mediante las palabras reservadas: var, int, String, Float, Decimal, etc. 

Definir edad, edad_max Como Entero
edad_max <- 0

• Luego debemos pedir que el usuario ingrese la edad de la persona, pero para ello debemos escribir en pantalla un mensaje pidiéndole dicho valor. Para mostrar texto se usa la palabra reservada Escribir (el los lenguajes de alto nivel se usan palabras reservadas como cout, echo, etc) y para leer un valor que el usuario ingresa por teclado se usa la palabra reservada Leer (el los lenguajes de alto nivel se usan palabras reservadas como cin, scanner, etc.)

Escribir "Ingrese la edad de la persona #"
Leer edad

• Esas sentencias para leer edades deben de repetirse durante 10 veces, entonces utilizamos una estructura repetitiva que nos permite repetir sentencias un determinado número de veces, en este caso, utilizamos la sentencia PARA (el los lenguajes de alto nivel se usa por lo general la palabra reservada FOR), esta permite establecer un valor de inicio, luego un valor final y de cuanto en cuanto irá avanzando el bucle.

Para cont<-1 Hasta 10 Con paso 1 Hacer
   Escribir "Ingrese la edad de la persona #", cont
   Leer edad
   Si edad > edad_max Entonces
      edad_max <- edad
   FinSi
FinPara

Nota: Se inicia el bucle con la variable "cont" con valor 1, luego de la palabra reservada "hasta" se coloca el ultimo valor que tomará la variable "cont", en este caso 10 porque queremos repetir el proceso 10 veces. Finalmente, la palabra resevada "Con paso" nos indica de cuanto en cuanto avanza el bucle, en nuestro caso avanzaría de 1 en 1. De tal modo que inicia en 1,sigue 2, luego 3 y así sucesivamente hasta llegar a 10

Código completo:

Proceso calcular_edad 
   Definir edad, edad_max Como Entero
   edad_max <- 0

   Para cont<-1 Hasta 10 Con paso 1 Hacer
      Escribir "Ingrese la edad de la persona #", cont
      Leer edad
      Si edad > edad_max Entonces
         edad_max <- edad
      FinSi
   FinPara

   Escribir "La edad mayor del grupo es: ", edad_max
FinProceso

Lenguajes de intercambio

¿Qué es un lenguaje de intercambio?

Un lenguaje de intercambio es un formato para el intercambio de datos entre aplicaciones informáticas de manera que no necesitan estar codificados en el mismo lenguaje de programación o instalados en un mismo sistema operativo, pero su uso va más allá.

¿Cuándo surgieron?

Surgen en los inicios de los años 90 cuando la proliferación de aplicaciones empezó a mostrar un alarmante problema a futuro que sería: "¿Cómo hacer que dos aplicaciones puedan comunicarse entre ellas si se encuentran codificadas en diferentes lenguajes de programación?"

¿Qué beneficios traen?

Transmitir información entre un programa realizado en JAVA y otro en PHP se podría realizar almacenando los datos en una base de datos mediante el primer programa y el segundo lea la base de datos, pero que pasaría si una de las aplicaciones no pudiera tener acceso a la base de datos y se requiere que la aplicación en JAVA reciba los datos desde la aplicación en PHP. Este caso se da cuando construimos aplicaciones móviles para Android, este si bien puede manejar su propia base de datos como un SQLite, no podría leer directamente datos desde un servidor MySQL, mientras que la aplicación en PHP si puede hacerlo y enviarle la información al programa en JAVA, y para que ambos entiendan la información a enviar es que se aprovecha un lenguaje de intercambio mediante Web Services.

¿Cuáles son los más usados?

Actualmente tenemos tres: XML, Json y YAML, XML es un lenguaje de marcado formal, mientras que Json y YAML son formatos inspirados en la sintaxis humana más que la de las computadoras utilizando texto plano en su totalidad, todos tienen sus ventajas y desventajas y están deben ser analizadas por los proveedores de Web Services y API Rest o SOAP para elegir el más conveniente

XML (Extensible Markup Language)

Inicialmente apareció el XML, un tipo de lenguaje de marcado como el HTML que mediante etiquetas permitía estandarizar la forma de intercambiar datos entre aplicaciones.

Por ejemplo si queremos transmitir la siguiente información: un usuario llamado Jhon que posee un correo que es jhon@mail.com y un número de teléfono que es 999999999 mediante XML, haríamos lo siguiente:

<persona>
   <nombre>Jhon</nombre>
   <contacto>
      <correo>jhon@mail.com</correo>
      <telefono>999999999</telefono>
   </contacto>
</persona>

Podemos identificar que existe una etiqueta llamada persona que contiene como atributos un nombre y un contacto, este contacto a la vez contiene información sobre un correo y un teléfono.

Json (JavaScript Object Notation)

Inicialmente apareció el XML, un tipo de lenguaje de marcado que nació de la notación en texto plano de los objetos de JavaScript, posee una simpleza que lo hizo muy popular e incluso uno de los responsables que el lenguaje de marcado HTML sobreviviera hasta nuestros días frente a la que iba ser su evolución (XHTML).

Por ejemplo si queremos transmitir la siguiente información: un usuario llamado Jhon que posee un correo que es jhon@mail.com y un número de teléfono que es 999999999 mediante Json, haríamos lo siguiente:

{
   "persona"{
      "nombre" : "Jhon"
      "contacto"{
         "correo" : "jhon@mail.com"
         "telefono" : "999999999"
      }
   }
}

Podemos identificar que existe una campo llamado persona que contiene como atributos un nombre y un contacto, este contacto a la vez contiene información sobre un correo y un teléfono, todos escritos como texto plano entre comillas dobles.

YAML(Ain't Markup Language)

Su traducción significa: "no es un lenguaje de marcado", aunque en su concepción se le trató y llamó como un lenguaje de marcado al igual que XML, actualmente se hace una distinción entre los lenguajes de marcado y los formatos para intercambio de datos como YAML o Json considerándolos como lenguajes de "marcado ligero".

Por ejemplo si queremos transmitir la siguiente información: un usuario llamado Jhon que posee un correo que es jhon@mail.com y un número de teléfono que es 999999999 mediante Yaml, haríamos lo siguiente:

---
   persona
     -nombre: Jhon
      contacto:
         -correo :jhon@mail.com
          telefono :999999999

Podemos identificar que existe una etiqueta llamada persona que contiene como atributos un nombre y un contacto, este contacto a la vez contiene información sobre un correo y un teléfono.

Operadores lógicos - PseInt

En PseInt tenemos diversas operaciones lógicas que utilizamos en las estructuras condicionales:

Operador	Operador en PseInt	Ejemplo
Conjunción ( y )	& Y	verdadero Y verdadero = verdadero verdadero Y falso = falso falso Y verdadero = falso falso Y falso = falso
Disyunción ( o )	| O	verdadero O verdadero = verdadero verdadero O falso = verdadero falso O verdadero = verdadero falso O falso = falso
Negación ( no )	~ NO	NO verdadero = falso NO falso = verdadero

Además, PseInt nos permite realizar comparaciones numéricas

Operador	Operador en PseInt	Ejemplo
Mayor	>	12 > 10 = verdadero 20 > 30 = falso
Mayor o igual	>=	12 >= 12 = verdadero 12 >= 10 = verdadero
Menor	<	2 < 10 = verdadero 12 < 10 = falso
Menor o igual	<=	2 <= 10 = verdadero 10 <= 10 = verdadero
Igual	=	"hola" =  "hola" = verdadero 12 = 10 = falso
Diferente	<>	12 <> 10 = verdadero 12 <> 12 = falso

Ejemplo implementado en Pseudocódigo

Crearemos un algoritmo que pida ingresar usuario y contraseña, donde el usuario será JHON y la contraseña será 1992, de forma que si alguno de ellos no coinciden nos debe mostrar el mensaje de Acceso Negado, pero si las credenciales fueran válidas nos debe mostrar Acceso concedido.

Proceso validar_contraseña
 Definir usuario,clave Como Caracter 
 Escribir "Ingrese el usuario"
 Leer usuario
 Escribir "Ingrese la clave"
 Leer clave 
 Si usuario="JHON" & clave="1992" Entonces
  Escribir "Acceso concedido"
 Sino
  Escribir "Acceso Negado"
 Fin Si 
FinProceso

Resultados:

Ingrese el usuario
> JHON
Ingrese la clave
> 1992
Acceso concedido

Ingrese el usuario
> JHON
Ingrese la clave
> 1994
Acceso Negado

Operaciones aritméticas - PseInt

En PseInt tenemos diversas operaciones matemáticas que se pueden ejecutar como:

Operación	Operador en PseInt	Ejemplo
Adición	+	10 + 2 = 12
Sustracción	-	10 - 2 = 8
Multiplicación	*	10 * 2 = 20
División	/	10 / 2 = 5
Potencia	^	10 ^ 2 = 100
Raíz	RAIZ RC	RAIZ(100) = 10
Residuo	% mod	10 % 2 = 0 10 mod 3 = 1
Parte entera	TRUNC	TRUNC(10 / 3) = 3 TRUNC(2.34) = 2

Además, PseInt nos permite definir un número trascendental muy usado que es Pi, para usarlo solo debemos escribir PI:

Ejemplo: Si queremos calcular el doble de PI colocamos: 2*PI

Ejemplo implementado en Pseudocódigo

Proceso Operadores
 Definir a,b Como Real

 Escribir "Ingrese dos números"
 Leer a, b

 Escribir "La suma es ", (a+b)
 Escribir "La resta es ", (a-b)
 Escribir "El producto es ", (a*b)
 Escribir "La división es ", (a/b)
 Escribir "El cubo del primero es ", (a^3)
 Escribir "La raíz del segundo es ", (RC(b))
 Escribir "El residuo al dividir es ", (a%b)
FinProceso

Resultado:

Ingrese dos números
> 3
> 4
La suma es 7
La resta es -1
El producto es 12
La división es 0.75
El cubo del primero es 27
La raíz del segundo es 2
El residuo al dividir es 3

Estructuras condicionales múltiples - PSeInt (Ejemplo)

Supongamos el siguientes enunciados:

1. Elabore un programa que permita ingresar el número del mes e imprima en pantalla el nombre del mes correspondiente, si el usuario ingresa un valor fuera del rango de [1-12] mostrar una advertencia.

Solución:

• Primero debemos definir cuales serán las variables con las que trabajaremos.  En el pseudocódigo se hace mediante la palabra reservada Definir, en los lenguajes de programación de alto nivel se hace mediante las palabras reservadas: var, int, String, Float, Decimal, etc. 

Definir mes Como Entero;

• Luego debemos pedir que el usuario ingrese el número del mes, pero para ello debemos escribir en pantalla un mensaje pidiéndole dicho valor. Para mostrar texto se usa la palabra reservada Escribir (el los lenguajes de alto nivel se usan palabras reservadas como cout, echo, etc) y para leer un valor que el usuario ingresa por teclado se usa la palabra reservada Leer (el los lenguajes de alto nivel se usan palabras reservadas como cin, scanner, etc.)

Escribir "Ingrese el número del mes (1-12): ";
Leer mes;

• En lugar de usar multiples sentencias condicionales se hace uso de la sentencia "Segun", seguido de la variable a analizar y luego la palabra reservada "Hacer". Luego para cada valor que el usuario ingrese se tendrá una respuesta. Se coloca el valor seguido de dos puntos ( : ) y luego las sentencias que se ejecutaran para cada caso, par el caso de un valor fuera del rango, se ingresa la expresión "De Otro Modo" seguido de dos puntos ( : ) y luego las sentencias que se ejecutaran.

Segun mes Hacer
        1: Escribir "Enero";
        2: Escribir "Febrero";
        3: Escribir "Marzo";
        4: Escribir "Abril";
        5: Escribir "Mayo";
        6: Escribir "Junio";
        7: Escribir "Julio";
        8: Escribir "Agosto";
        9: Escribir "Septiembre";
        10: Escribir "Octubre";
        11: Escribir "Noviembre";
        12: Escribir "Diciembre";
        De Otro Modo: Escribir "Ingrese un valor entre 1 y 12";
Fin Segun

Código completo:

Proceso nombre_mes
        Definir mes Como Entero; 
        Escribir "Ingrese el número del mes (1-12): "; 
        Leer mes;
        Segun mes Hacer
              1: Escribir "Enero";
              2: Escribir "Febrero";
              3: Escribir "Marzo";
              4: Escribir "Abril";
              5: Escribir "Mayo";
              6: Escribir "Junio";
              7: Escribir "Julio";
              8: Escribir "Agosto";
              9: Escribir "Septiembre";
              10: Escribir "Octubre";
              11: Escribir "Noviembre";
              12: Escribir "Diciembre";
              De Otro Modo: Escribir "Ingrese un valor entre 1 y 12";
        Fin Segun
FinProceso

Estructuras condicionales simples - PSeInt (Ejemplo)

Supongamos el siguientes enunciados:

1. Elabore un programa que permita ingresar la edad de una persona e imprima en pantalla si es mayor de edad o menor de edad, el sistema solo debe aceptar números enteros que no sean negativos

Solución:

• Primero debemos definir cuales serán las variables con las que trabajaremos.  En el pseudocódigo se hace mediante la palabra reservada Definir, en los lenguajes de programación de alto nivel se hace mediante las palabras reservadas: var, int, String, Float, Decimal, etc. 

Definir edad Como Entero;

• Luego debemos pedir que el usuario ingrese la edad de la persona, pero para ello debemos escribir en pantalla un mensaje pidiéndole dicho valor. Para mostrar texto se usa la palabra reservada Escribir (el los lenguajes de alto nivel se usan palabras reservadas como cout, echo, etc) y para leer un valor que el usuario ingresa por teclado se usa la palabra reservada Leer (el los lenguajes de alto nivel se usan palabras reservadas como cin, scanner, etc.)

Escribir "Ingrese la edad de la persona: ";
Leer edad;

• Luego se hace hace la consulta si el número ingresado es negativo o no, para ello se usa la palabra reservada "Si", luego la expresión a validar y la palabra reservada "Entonces", si fuera negativo imprimirá un ERROR en pantalla, para que se ejecute código en el caso que no se cumpla la condición se usa la palabra reservada "SiNo", en ese momento al ser el valor ingresado un número no negativo se analizará si el valor es menor de 18, en ese caso imprimirá que la persona es menor de edad, caso contrario que la persona es mayor de edad. Finalmente, se cierra la sentencia condicional con la expresión "Fin Si"

Si edad<0 Entonces
        Escribir "ERROR, ingrese un valor válido";
SiNo
        Si edad<18 Entonces
            Escribir "la persona es menor de edad";
        SiNo
            Escribir "la persona es mayor de edad";
        Fin Si
Fin Si

Código completo:

Proceso validar_edad 
        Definir edad Como Entero; 
        Escribir "Ingrese la edad de la persona: "; 
        Leer edad;
        Si edad<0 Entonces
           Escribir "ERROR, ingrese un valor válido";
        SiNo
           Si edad<18 Entonces
              Escribir "la persona es menor de edad";
           SiNo
              Escribir "la persona es mayor de edad";
           Fin Si
        Fin Si 
FinProceso

Estructuras secuenciales - PSeInt (Ejemplo)

Supongamos el siguientes enunciados:

1. Elabore un programa que permita ingresar 2 números y calcule e imprima en pantalla el valor de su suma, resta y producto.

Solución:

• Primero debemos definir cuales serán las variables con las que trabajaremos.  En el pseudocódigo se hace mediante la palabra reservada Definir, en los lenguajes de programación de alto nivel se hace mediante las palabras resverdas: var, int, String, Float, Decimal, etc. 

Definir var1, var2, suma, resta, producto Como Entero;

• Luego debemos pedir que el usuario ingrese los dos números que se operarán, pero para ello debemos escribir en pantalla un mensaje pidiéndole dichos números. Para mostrar texto se usa la palabra reservada Escribir (el los lenguajes de alto nivel se usan palabras reservadas como cout, echo, etc) y para leer un valor que el usuario ingresa por teclado se usa la palabra reservada Leer (el los lenguajes de alto nivel se usan palabras reservadas como cin, scanner, etc.)r

Escribir "Ingrese el primer número: ";
Leer var1;
Escribir "Ingrese el segundo número: ";
Leer var2;

• Luego se hace el cálculo de la suma, resta y producto, almacenando cada uno de esos resultados en su variable correspondiente, esta asignación de valor se hace mediante la combinación de símbolos menor y guión ( <- ), el los lenguajes de alto nivel se usan símbolos como el igual ( = ). Los operadores aritméticos son para la suma el signo más ( + ), para la resta el guión ( - ) y producto el asterisco ( * )

suma <- var1 + var2;	
resta <- var1 - var2;	
producto <- var1 * var2;

• Finalmente se muestra en pantalla los resultados, para concatenar (unir dos cadenas de texto), las separamos por comas. En los lenguajes de programación de alto nivel esto se hace mediante el símbolo más ( + ), el punto ( . ), una función como "append" u otros.

Escribir "La suma es: ",suma;
Escribir "La resta es: ",resta;
Escribir "El producto es: ",producto;

Código completo:

Proceso suma_resta_producto	
	Definir var1, var2, suma, resta, producto Como Entero;	
	Escribir "Ingrese el primer número: ";	
	Leer var1;	
	Escribir "Ingrese el segundo número: ";	
	Leer var2;	
	suma <- var1 + var2;	
	resta <- var1 - var2;	
	producto <- var1 * var2;	
	Escribir "La suma es: ",suma;	
	Escribir "La resta es: ",resta;	
	Escribir "El producto es: ",producto;	
FinProceso