JERCICIOS PARA EL EXAMEN FINAL DE SLE2

//1-Haga un diagrama que muestre los números pares del 1 al 100 y la suma de ellos
var
x, suma: numerico
inicio
cls()
set_curpos(1,22); imprimir("LOS NUMEROS PARES DEL 1 AL 100 SON\n\n")
desde x=2 hasta 100 paso 2{
imprimir(x, "\t")
suma= suma+x
}
imprimir ("\nLa suma de ellos es: ", suma)
fin
------------------------------------------------------------------------------------------------------------

/*2-Haga un diagrama que diga cuantas personas fueron encuestadas,

cuantas contestaron si, cuantas contestaron no y cuantos dejaron de responder,
cuando le preguntaron si estaba de acuerdo con la elección del nuevo presidente de USA.*/

var
cs, cn, cns, cper: numerico
op, resp:cadena
inicio
cls()
repetir
set_curpos(1,1)
imprimir ("Estuvo de acuerdo con la elección del presidente de USA? s/n")
leer (resp)
si (upper(resp)=="S"){
cs=cs+1
set_curpos(1,1);imprimir("Respuesta si! ")
sino si (upper(resp)=="N")
set_curpos(1,1);imprimir("Respuesta no! ")
cn=cn+1
sino
set_curpos(1,1);imprimir("No respondió!, ")
cns=cns+1
}
set_curpos(1,18)
imprimir("Desea salir s/n")
leer (op)
cper=cper+1
hasta (upper(op)=="S")
set_curpos(1,1)
imprimir("Respuestas si:", cs, "\nRespuestas no:", cn, "\nNo responde: ", cns)
imprimir("\nTotal encuestados:", cper)
fin
------------------------------------------------------------------------------------------------------------
//3-Realice un programa que capture los días y muestre cuantas horas, minutos y segundos habrá en ese
tiempo

var
dias,h, m, s: numerico
inicio
cls()
imprimir("Ingrese los días quiere pasar a horas, minutos, segundos:")
leer(dias)
s=dias*86400
mientras (s>=60){
si (s<3600){
m=m+1
s=s-60
sino
h=h+1
s=s-3600
}
}
imprimir("Horas: ",h, " Minutos:",m, " Segundos: ",s)
fin
------------------------------------------------------------------------------------------------------------

//4. Leer cuatro números y calcular e imprimir su suma, su producto y su media aritmética. Los números
deben ser mayores que cero.

var
n1, n2, n3, n4, media,producto, suma: numerico
inicio
cls()
set_curpos(1,1)
imprimir ("Digite número 1"); leer(n1)
set_curpos(1,1)
imprimir ("Digite número 2"); leer(n2)
set_curpos(1,1)
imprimir ("Digite número 3"); leer(n3)
set_curpos(1,1)
imprimir ("Digite número 4"); leer(n4)

suma= n1+n2+n3+n4
producto= n1*n2*n3*n4
media= suma/4
set_curpos(1,1); imprimir("La suma es: ", suma, " ")
set_curpos(2,1); imprimir("El producto es: ", producto)
set_curpos(3,1); imprimir("la media Aritmética es: ", media)

fin
------------------------------------------------------------------------------------------------------------

/*5-Realizar un programa que capture un valor en metros y presente un menú que muestre
las opciones en un menú, que permita convertir ese valor a pulgadas, a yardas y a millas.
( 1 pulgada = 0.02540 metros, 1 yarda = 0.9144 metros, 1 milla = 1609,3 Metros)*/

var
pulgada=0.02540
yarda= 0.9144
milla=1609.3
metros: numerico
op:numerico
op2: cadena
inicio
cls()
repetir
repetir
set_curpos(1,32);imprimir("MENU PRINCIPAL\n Digite opción: ")
set_curpos(3,1); imprimir(" 1- De metros a pulgadas\n 2- De metros yardas. \n 3- De metros a millas\n")
leer (op)
hasta (op>0 && op<4)
set_curpos(6,1);imprimir("Cuantos metros desea convertir?")
leer(metros)
si (op==1){
cls()
set_curpos (2,1); imprimir(metros," mts equivalen a : ",metros/pulgada, " Pulgadas\n")

sino si (op==2)
cls()
set_curpos (2,1); imprimir(metros," mts equivalen a : ",metros/yarda, " yardas\n")

sino si (op==3)
cls()
set_curpos (2,1); imprimir(metros," mts equivalen a : ",metros/milla, " millas\n")

}
imprimir ("\nDesea continuar s/n")
leer(op2)
hasta (op2=="n")
fin
------------------------------------------------------------------------------------------------------------

/*6-Realizar un algoritmo que me permita ingresar la hora, minutos y

segundos y que me indique cuantos segundos son.
La hora que ingresa será de la forma HH:MM:SS*/

var
h, m, s : numerico
th, tm,ts: numerico
total: numerico
inicio
cls()
set_curpos(3,1);imprimir("FORMATO HH: MM: SS")

set_curpos(2,1);imprimir("Digite horas");leer (h)

repetir
set_curpos(2,1);imprimir("Digite minutos");leer (m)
hasta (m>=0 && m<60)
repetir
set_curpos(2,1);imprimir("Digite segundos");leer (s)
hasta (s>=0 && s<60)
th= h*3600
tm=m*60
ts=s
total= th+tm+ts
set_curpos(1,1); imprimir(" RESULTADO\n********************")
set_curpos(3,1);imprimir(h," horas, ", m, " min, ", s," seg", " equivalen a: ",total, " segundos")
fin
------------------------------------------------------------------------------------------------------------

/*7. Elabore un diagrama de flujo que lea una serie de enteros positivos,
contar los valores introducidos y calcular su promedio.
El final de los datos se indicará con un número negativo. */

var
num: numerico
prom: numerico
suma: numerico
cont: numerico
inicio
cls()
repetir
imprimir("Digite entero positivo")
leer (num)
si (num>0){
suma= suma+num
cont=cont+1
}
hasta (num<0)
imprimir("Se han introducido ", cont," valores; El promedio de estos es: ", suma/cont)
fin

------------------------------------------------------------------------------------------------------------

//9. Se ingresan 5 notas de un alumno, publicar 2 peores notas.

var
menor=10
smenor, n: numerico
cont=1
inicio
cls()
set_curpos(1,1); imprimir(strdup("=",80))
set_curpos(3,1); imprimir(strdup("=",80))
set_curpos(2,32);imprimir("NOTAS DE BRIEVA")
set_curpos(4,1);imprimir("Nota 1")
set_curpos(5,1);imprimir("Nota 2")
set_curpos(6,1);imprimir("Nota 3")
set_curpos(7,1);imprimir("Nota 4")
set_curpos(8,1);imprimir("Nota 5")
repetir
repetir
set_curpos(10,1)
imprimir ("Digite nota", cont)
leer(n)
hasta (n<=10 && n>=0)
set_curpos(cont+3,8)
imprimir("->",n)
si (n<menor){
smenor=menor
menor=n

sino si (n<smenor && n<>menor)

smenor=n
}
inc(cont)
hasta (cont==6)
imprimir("\n\nLa peor nota es: ", menor, "\nLa siguiente peor nota es: ", smenor)
fin

jemplos resueltos

EJEMPLO 1: Escribir un programa para calcular el área de un triangulo dado sus

vertices en el plano cartesiano

programa AreaDelTriangulo

var
X1, Y1, X2, Y2, X3, Y3 : numerico
A, B, C, Semiperimetro, Area : numerico

inicio
//Limpiamos la pantalla
cls()
//Leemos las coordenadas del vertice del triangiulo
//Leemos las coordenadas del 1er punto
imprimir("\nIngrese las coordenas de 1er punto (x,y)")
leer(X1,Y1)

//Leemos las coordenadas del 2do punto

imprimir("\nIngrese las coordenas de 2do punto (x,y)")
leer(X2,Y2)

//Leemos las coordenadas del 3er punto

 imprimir("\nIngrese las coordenas de 3er punto (x,y)")
leer(X3,Y3)

//Calculamos el Area del triangulo

//Calculamos las longitudes de los lados del triangulo
A=sqrt((X2-X1)^2 + (Y2-Y1)^2)
B=sqrt((X3-X1)^2 + (Y3-Y1)^2)
C=sqrt((X2-X3)^2 + (Y2-Y3)^2)

//SemiPerimetro del Triangulo

Semiperimetro = (A + B + C)/2
//Determinamos el area del triangulo
Area = sqrt(Semiperimetro*(Semiperimetro - A)*(Semiperimetro -
B)*(Semiperimetro - C))

//Mostramos el resultado
imprimir("\nEl Area del Triangulo es : ", Area)
fin
EJEMPLO 2: Escribir un programa que calcule el número mínimo de billetes de
100, 50, 20 y 10 Nuevos Soles que son necesarias para cambiar un Cheque
bancario. (Nota: Elcheque es multiplo de 10 ).

programa CambiarBillete

var
Monto, B100, B50, B20, B10, Nrobilletes : numerico
inicio
//Limpiamos la pantalla
cls()

//Leemos un numero multiplo de 10

imprimir("\nIngrese el Monto a Cambiar")
leer(Monto)

//Calculamos el numero de billetes

B100 = int(Monto/100)
Monto = Monto%100
B50 = int(Monto/50)
Monto = Monto%50
B20 = int(Monto/20)
B10 = Monto%20

Nrobilletes = B100 + B50 + B20 + B10

//Mostramos el resultado
imprimir("\nEl numero de billetes de 100 es : ", B100)
imprimir("\nEl numero de billetes de 50 es : ", B50)
imprimir("\nEl numero de billetes de 20 es : ", B20)
imprimir("\nEl numero de billetes de 10 es : ", B10)
imprimir("\nEl numero total de billetes es : ", Nrobilletes)
fin
EJEMPLO 3: Escribir un algoritmo que convierta una distancia medida en pulgadas
a centimetros.
Centimetros = Pulgadas*2.54

programa ConvercionUnidades

const
Equivalencia = 2.54 //deficion de constantes en sle

var
Centimetros, Pulgadas : numerico

inicio
//Limpiamos la pantalla
cls();

//Leemos la medida en pulgadas

imprimir("\nIngrese una medidad en pulgadas ")
leer(Pulgadas)

//Realizamos la conversion
Centimetros = Pulgadas*Equivalencia

//Mostramos el resultado
imprimir("\nLa medica es : ", Centimetros, "cm")

fin
EJEMPLO 4: Escribir un programa para ralizar un descuento del 15% de total de
una compra

programa Descuento
var
tc : numerico
d : numerico
tp : numerico
inicio
//Limpiamos la pantalla
cls()
//Leemos el monto de la compra
imprimir("\nIngrese el Total de la Compra")
leer(tc)
//Calculamos el descuento del 15%
d = tc*0.15
tp = tc - d
//Mostramos el resultado
imprimir("\nEl Descuento del 15% es: ", d)
imprimir("\nEl total a pagar es : ", tp)
fin
EJEMPLO 5: Escribir un programa para calcular la distancia entre dos puntos
programa DistanciaEntrePuntos
var
Distancia, X1, Y1, X2, Y2 : numerico

inicio
//Limpiamos la pantalla
cls();
//Leemos la ordenada y la absisa del los puntos
imprimir("\nIngrese la abscisa del primer punto ")
leer(X1)
imprimir("\nIngrese la ordenada del primer punto ")
leer(Y1)

imprimir("\nIngrese la abscisa del segundo punto ")

leer(X2)
imprimir("\nIngrese la ordenada del segundo punto ")
leer(Y2)

//Calculamos la distancia entre los puntos

Distancia = sqrt((X2-X1)^2 + (Y2-Y1)^2)

//Mostramos el resultado
imprimir("La distancia es : ", Distancia, " unidades")
fin
EJEMPLO 6: Escribir un algoritmo que evalue la función
f(x) = 2*X^2 + 4*X - 5
para un valor de X

programa Funcion
var
X : numerico
Y : numerico
inicio
//Limpiamos la pantalla
cls()
//Leemos el valor de X para evaluar la funcion
imprimir("\Ingrese el valor de X")
leer(X)

//Evaluamos la funcion
Y = 2*X^2 + 4*X - 5

//Mostramos el resultado
imprimir("\nEL valor de f(x) = ", Y)
fin
EJEMPLO 7: Escribir un programa para el calculo de la fuerza resultante entre dos
fuerzas en el plano

programa FuerzasResultantes
var
F1, F2, Angulo, AnguloRad, Resultante : numerico

inicio
//Limpiamos la pantalla
cls();

//Leemos el valor de las fuerzas y el angulo que forman

imprimir("\nIngrese la primera fuerza")
leer(F1)

imprimir("\nIngrese la segunda fuerza")

leer(F2)

imprimir("\nIngrese el angulo formado por las fuerzas")

leer(Angulo)

//Convertir angulo de grados sexagecimales a radianes

AnguloRad = Angulo*3.1416/180

//Calculo de la fuerza resultante con la ley de COCENOS

Resultante = sqrt(F1^2 + F2^2 + 2*F1*F2*cos(AnguloRad))

//Mostramos el resultado
imprimir("\n La fuerza resultantes es : ", Resultante)
fin

Sentencia condicional
En SL existen dos sentencias condicionales: sentencia si y sentencia eval. La
primera posibilita elegir qué parte de un programa se ejecutará si cierta condición
se cumple. La segunda puede ayudar a mejorar la legibilidad de un grupo de
sentencias si muy largas o complejas.

La sintaxis básica de la sentencia si es:

si ( condicion )
{
sentencias...
sino
sentencias...
}
La cláusula “sino“ y las sentencias correspondientes son opcionales: solo se usan
cuando el programa necesita tomar acciones si la condición es falsa.

Existen programa que usan una variante de la sentencia si cuya sintaxis es:

si ( condicion )
 {
sentencias...
sino si ( condicion )
sentencias...
sino sentencias...
}
Como puede apreciarse, esta variante permite "encadenar" varios condicionales en
una sola sentencia si. Esta estructura es muy útil porque permite obviar
anidamientos innecesarios. Debe observarse que las secuencias "sino si
(condición)" no van seguidas de "{". Además la palabra "si" debe ubicarse en la
misma línea que el "sino" correspondiente.

Ejemplos resueltos

EJEMPLO 1: Escribir un programa que indique si un número es par o impar

programa AnalizarNumero

var
Numero,
Residuo : numerico

inicio
//Limpiamos la pantalla
cls();

//Leemos un numero entero

imprimir("\nIngrese el primer numero ")
leer(Numero)

//Verificamos si el numero es par o impar

Residuo = Numero%2

si (Residuo == 0) {
imprimir("\nEl Numero ", Numero," es par")
sino
imprimir("\nEl Numero ", Numero," es impar")
}
fin
EJEMPLO 2: Escribir un programa para saber si el año es Bisiesto o no

programa AnioBiciesto
var
Anio : numerico

inicio
//Limpiamos la pantalla
cls();
//Leemos un numero entero
 imprimir("\nIngrese el año ")
leer(Anio)
//Verificamos si el el anio es Bisiesto no
si (Anio%4==0)
{
imprimir("\nEl ",Anio, " año es Biciesto")
sino
imprimir("\nEl ", Anio, " año no es Biciesto")
}
fin

Sentencia eval
La sentencia eval es funcionalmente equivalente a la forma extendida de la
sentencia si, pero aporta mayor legibilidad cuando las condiciones son varias o
complejas.

La sintaxis de la sentencia eval es:

eval
{
caso ( condicion ) sentencias...
caso ( condicion ) sentencias...
sino
sentencias...
}
El programa verificará el valor de verdad de la primera condición. Si se cumple,
ejecutará todas las acciones definidas para ese caso en particular y luego irá a
ejecutar la sentencia que siga a la llave que cierra el cuerpo de la sentencia eval. Si
no se cumple, pasará a verificar la siguiente condición y así sucesivamente. Si
ninguna condición fuese verdadera y existiese una cláusula “sino”, se ejecutarán las
acciones definidas bajo esta cláusula. La cláusula “sino” es opcional. Si está
presente debe ser la última.

Ejemplos resueltos

EJEMPLO 1: El siguiente programa clasifica lo ingresado por el usuario en “letra

mayúscula”, “letra minúscula”, “dígito”, o “algún otro”. Para determinar a qué
categoría pertenece un carácter se aprovecha la distribución de los caracteres en la
tabla ASCII junto con los operadores relaciones mayor o igual (“>=”) y menor o
igual (“<=”).

/*Clasificar un carácter ingresado por el usuario en "letra mayúscula",

 "letra minúscula", "dígito" o "algún otro". */

var
let : cadena
msg : cadena

inicio

leer (let)
/* Consideremos solo el primer carácter, por si haya tipeado más de uno.
Observar cómo se usan los corchetes para seleccionar el primer carácter.*/

let = let [1]

eval
{
caso ( let >= 'A' and let <= 'Z' )
msg = "letra mayúscula"
caso ( let >= 'a' and let <= 'z' )
msg = "letra minúscula"
caso ( let >= '0' and let <= '9' )
msg = "dígito"
sino
msg = "algún otro"
}
imprimir ("\nEl carácter que usted ingresó es ", msg)
fin

EJEMPLO 2: Escribir un programa para determinar los días de un mes.

programa DiasMes
var
NroDiasMes, Mes, Anio : numerico
inicio
//Limpiar pantalla
cls()

//Leer Mes y Anio

imprimir("\nMes : ")
leer(Mes)
imprimir("\nAnio : ")
leer(Anio)

//Determinar numero de dias del mes

eval
{
caso (Mes==1 or Mes==3 or Mes==5 or Mes==7 or Mes==8 or Mes==10 or Mes==12)
NroDiasMes = 31
caso (Mes==4 or Mes==6 or Mes==9 or Mes==11)
NroDiasMes = 30
caso (Mes==2)
si(Anio % 4 == 0)
{
NroDiasMes = 29
 sino
NroDiasMes = 28
}

//Escribir dias del mes

imprimir("\n Nro dias del Mes : ", NroDiasMes)
fin

EJEMPLO 3: Dado un número entero determinar que día de la semana le

pertenece a dicho numero, si no le pertenece ningun día mostrar ERROR

programa DiasSemana
var
Dia : numerico
inicio
//Limpiar pantalla
cls()

//Leer un numero
imprimir("\nIngrese un Numero : ")
leer(Dia)

//Determinar que dia le pertenece a un numero

eval
{
caso (Dia==1)
imprimir("Lunes")
caso (Dia==2)
imprimir("Martes")
caso (Dia==3)
imprimir("Miercoles")
caso (Dia==4)
imprimir("Jueves")
caso (Dia==5)
imprimir("Viernes")
caso (Dia==6)
imprimir("Sabado")
caso (Dia==7)
imprimir("domingo")
sino
imprimir("ERROR")
}
fin

Ciclo Mientras
Esta construcción posibilita ejecutar repetidamente un conjunto de sentencias
mientras se cumpla cierta condición definida por el programador.
La sintaxis del ciclo mientras es:

mientras ( condición )
{
sentencias...
}
Debemos notar que la condición va siempre entre paréntesis.

Ejemplos Resueltos

EJEMPLO 1: Escribir un programa para realizar la división de dos números

mediante restas sucesivas

programa DivisionNumeros

var
a, b, cociente: numerico
inicio
//Limpiamos la pantalla
cls();

//Leemos dos numero

imprimir("\nIngrese Dos Numeros")
leer(a,b)

//calculamos la division mediante sumas sucesivas

cociente = 0
mientras (a>=b)
{
a = a - b
cociente = cociente + 1
}

//Mostramos el resultado
imprimir("\nEl cociente es ", cociente)
fin

Ciclo Repetir
Ciclo repetir...hasta
A diferencia del ciclo mientras, el ciclo repetir-hasta ejecuta al menos una vez las
sentencias definidas en el cuerpo del ciclo, pues la verificación para continuar o no
en el ciclo se realiza al final, como puede apreciarse en la sintaxis:

repetir
sentencias...
 hasta ( condicion_de_fin )
Debemos observar que la condición de fin va entre paréntesis.

Si bien esta forma de ciclo es utilizado con menor frecuencia que el ciclo mientras,
hay situaciones en las que con él el algoritmo resultante es más sencillo y directo. A
continuación un ejemplo:

Ejemplos Resueltos

EJEMPLO 1: Escribir un programa para determinar el número de digitos de un

número

programa NroDigitos
var
num, dig : numerico
inicio
//Limpiamos la pantalla
cls();

//Leemos un numero
imprimir("\nIngrese un Nro entero ")
leer(num)
//Calculamos la cantidad de digitos
dig = 0
repetir
dig =dig + 1
num = int(num/10)
hasta(num==0)
//Mostramos el resultado
imprimir("\nCatidad de cifras es : ", dig)
fin

EJEMPLO 2: Escribir un programa que calcule la suma de los n primeros números

enteros positivos.

programa SumaDeNumeros
var
Suma, K, N :numerico
inicio
//Limpiar pantalla
cls()
//Leer numero de enteros a sumar
imprimir("\nIngrese un Nro : ")
leer(N)

//Calcula suma de los N primeros numeros enteros

Suma = 0
K = 0
 repetir
K = K + 1
Suma = Suma + K
hasta (K==N)
// Escribir suma
imprimir("\nSuma : ", Suma)
fin

EJEMPLO 3 : Escribir un programa que muestre la tabla de multiplicar de un

número N.

programa Multiplicacion
var
Numero, k : numerico
inicio
//Limpiar pantalla
cls()

//Leer un numero entero positivos

imprimir("\nIngrese un numeros : ")
leer(Numero)

//Tabla de Multiplicar
k = -1
repetir
k = k + 1
imprimir("\n ",Numero," x ",k," = ", k*Numero )
hasta (k==12)
fin
EJEMPLO 4 : Se tiene relación de n alumnos. Para cada alumno se tiene 3 notas.
Escribir un programa que calcule el promedio de cada alumno..

programa PromedioAlumnos
var
Promedio, NroAlumno, N,
Nota1, Nota2, Nota3 : numerico
inicio
//Limpiar pantalla
cls()

//Leer Nro de alumnos

imprimir("\ningrse la cantidad de alumnos : ")
leer(N)

//Leer Notas y calclar promedio para N alumnos

NroAlumno = 0
repetir
//Procesar notas del siguiente alumno
NroAlumno = NroAlumno + 1

//Leer notas del alumno

 imprimir("\nIngresar Notas ")

imprimir("\nNota 1 : ")
leer(Nota1)

imprimir("\nNota 2 : ")
leer(Nota2)

imprimir("\nNota 3 : ")
leer(Nota3)

//Calcular promedio de notas del alumno

Promedio = (Nota1 + Nota2 + Nota3) /3

//Escribir promedio del alumno

imprimir("\nPromedio = ", Promedio,"\n\n")
hasta(NroAlumno == N)
fin

Ciclo desde
Utilizamos el ciclo desde cuando conocemos previamente el número de veces que
deseamos ejecutar un conjunto de instrucciones.

La sintaxis es:

desde variable_de_control = valor_inicio hasta valor_fin [paso incremento]

{
sentencias...
}
Al igual que el ciclo mientras, el conjunto de sentencias que forman parte de un
ciclo desde puede que nunca se ejecute. Esto ocurrirá si:

 El valor inicial es superior al valor final y el incremento es positivo, ó

 El valor inicial es inferior al valor final y el incremento es negativo.

Mas detalles acerca del ciclo desde

Cuando usamos el ciclo desde debemos tener presente algunos detalles:

 El valor de inicio, el valor de fin y el incremento deben ser expresiones

numéricas. El primero (inicio) y el último (incremento) son siempre
automáticamente truncados a enteros.
 El valor del incremento puede ser negativo (por ejemplo, para ir de 100 a 1).
 El ciclo puede realizarse de 0 a n veces.
  La variable de control debe ser numérica, pudiendo ser un elemento de un
vector o matriz.
 Alterar el valor de inicio, el valor de fin o el incremento no tiene ningún
efecto sobre la cantidad de veces que se ejecutará el ciclo (esto se calcula
justo antes de iniciar el ciclo).
 Si se desea salir del ciclo en forma anticipada, puede asignarse a la variable
de control el valor de fin.

Ejemplos

EJEMPLO 1: para entender la sintaxis.

Escribir un algoritmo que permita escribir 5 veces la frase 'Programar

computadoras es facil'

programa EjemploPara
var
k : numerico
inicio
//Limpiar pantalla
cls()

//Escribir la frace 5 veces

desde k=0 hasta 5
{
imprimir(k, "\tProgramar Computadoras es facil \n")
}
fin
Nota: Recordar que \t es equivalente a realizar un tab y \n es equivalente a
precionar enter(salto de linea).

Màs ejemplo para entender y para que quede claro la sintaxsis de "desde - hasta
hacer"

EJEMPLO 2: Escribir un algoritmo que imprima el número, el cuadrado y el cubo

de los N primeros nùmeros enteros positivos.

programa CuadradosCubos
var
Numero, Cuadrado, Cubo, j : numerico
inicio
//Limpiar la pantalla
cls()

//Leer numero entero

 imprimir("\nIngresar numero entero : ")
leer(Numero)

//Calculamos el cuadrado y el cubo

desde j=0 hasta Numero
{
Cuadrado = j*j
Cubo = j*j*j
imprimir("\n", j,"\t", Cuadrado, "\t",Cubo)
}
fin

Y otra forma de escribir el programa es la siguiente.

programa CuadradosCubos2
var
j : numerico
inicio
//Limpiar la pantalla
cls()

//Leer numero entero

imprimir("\nIngresar numero entero : ")
leer(Numero)

//Calculamos el cuadrado y el cubo

desde j=0 hasta Numero
{
imprimir("\n", j,"\t", j*j, "\t",j*j*j)
}
fin
Nota: Muchas veces minizar el nùmero de variables aumenta su eficiencia, Lo mas
importante es escribir programas que se entiendan (Programas legibles).

EJEMPLO 3 : Escribir un programa para determinar el mayor de N nùmeros enteros

positivos.

programa NumeroMayor
var
Numero, Cantidad, Mayor, j : numerico
inicio
//Limpiar la pantalla
cls()

//Leer numero entero

imprimir("\nIngresar la Cantidad de Numeros : ")
leer(Cantidad)

//Calculamos el numero mayor

 //Inicializamos la variable Mayor
Mayor = 0

desde j=1 hasta Cantidad

{
//Leer los Numeros
imprimir("\n Numero ", j, " : ")
leer(Numero)

//Determinamos el mayor
si(Numero>=Mayor)
{
Mayor = Numero
}
}

//Mostramos el Numero Mayor

imprimir("\nNumero Mayor = ", Mayor)
fin
EJEMPLO 4 : Se tiene la relación de N notas. Determinar la nota màs baja, la nota
más alta, el promedio, el número de abrobados, el número de desaprovados.

programa AnalizarNotas
var
NroNotas, Nota,
NotaMayor, NotaMenor, Promedio,
NroAprob, NroDesap, NroRepro,
k, SumaNotas : numerico
inicio
//Limpiar pantalla
cls()

//Leer numero de notas

imprimir("\nCantidad Notas : ")
leer(NroNotas)

// Leer notas y efectuar los diferentes procesos

//Inicializar contadores y acumuladores
NotaMayor = 0
NotaMenor = 20
SumaNotas = 0
NroAprob = 0
NroDesap = 0
NroRepro = 0

//Leer cada nota y procesarlo

desde k = 1 hasta NroNotas
{
//Leer Nota
imprimir("\nNota : ")
leer(Nota)

//Verificar si es la nota mas alta

 si (NotaMayor < Nota)
{
NotaMayor = Nota
}

//Verificamos si es la nota mas baja

si (NotaMenor > Nota)
{
NotaMenor = Nota
}

//Acumular para calcular el promedio

SumaNotas = SumaNotas + Nota

//Verificar si es nota aprobada, des, repro

si (Nota >=11)
{
NroAprob = NroAprob +1
sino
si (Nota >= 7)
{
NroDesap = NroDesap + 1
sino
NroRepro = NroRepro + 1
}
}
}
// Calcular promedio
Promedio = Promedio / NroNotas
// Escribir resultado
imprimir("\n Nota Alta \t: ", NotaMayor)
imprimir("\n Nota Menor \t: ", NotaMenor)
imprimir("\n Promedio \t: ", Promedio)
imprimir("\n Nro Aprob\t: ", NroAprob)
imprimir("\n Nro Desap\t: ", NroDesap)
imprimir("\n Nro Repro\t: ", NroRepro)
fin
Estructuras iterativas anidadas (desde - hasta - hacer)

EJEMPLO 5: Escribir un programa que muestre un cuadradi llenos de asterisco

programa CuadradoAsteriscos

var
i, j : numerico
inicio
//Limpiamos la pantalla
cls()

//Escribir 10 lineas de asteristos

desde i = 1 hasta 10
{
//Llevar cursos al inicio de la fila siguiente
 imprimir("\n")

//Escribimos una linea de 15 asteriscos

desde j = 1 hasta 15
{
imprimir("*")
}

fin
Escribir un programa para realizar la suma de los n primeros número

programa SumaPares
var
n, k, suma : numerico
inicio
//Limpiamos la pantalla
cls();

//Leemos el valor de n
imprimir("\nPor favor ingrese el valor para n")
leer(n)

//Calculamos la suma
suma = 0
desde k=2 hasta n paso 2
{
suma = suma+k
}

//Mostramos el resultado
imprimir("\nLa suma es : ", suma)
fin