Sunteți pe pagina 1din 36

Informacin importante para docentes usuarios de

PSeInt
PSeInt permite personalizar algunos aspectos del lenguaje. Para evitar confusin
en los alumnos, la idea es que la primera vez que se ejecute el programa, solicite al
estudiante elegir un "perfil de configuracin" para su
universidad/facultad/carrera, definiendo rpidamente y en un solo paso la
configuracin del lenguaje de acuerdo a las exigencias de su docente. Este mensaje
es para solicitar a los docentes que enven sus perfiles para agregarlos a la lista.
Para ello, deben realizar los siguientes pasos:
1. Ejecute PSeInt (asegrese de haber instalado la ltima versin).
2. Seleccione el tem "Opciones del Lenguaje (perfiles)" del men "Configurar".
3. En el cuadro de dilogo que aparece, haga click en "Personalizar".
4. En el nuevo cuadro de dilogo que aparece, configure el perfil como lo
desee.
5. Haga click en el segundo botn de la esquina inferior izquierda del cuadro
de dilogo (el que muestra un disquete) para guardar el perfil en un
archivo.
6. Seleccione una ubicacin cualquiera para el archivo e introduzca una breve
descripcin del perfil (se recomienda mencionar la institucin donde se
utiliza, la ctedra o carrera, y el nombre del docente responsable o de quien
enva el perfil).
7. Enve el archivo por email a zaskar_84<arroba>yahoo.com.ar.

En el correo incluyan adems del archivo generado e informacin de la ctedra


donde lo utilizan (nombre de la universidad y facultad o instituto, nombre de la
carrera, nombre de la ctedra/materia, docente responsable de la misma, y qu
lenguaje de programacin real utilizan en las clases luego de la etapa de
pseudocdigo). Adems, cada perfil se muestra con un pequeo cono de 24x24px,
que tomar del favicon del sitio web de la institucin a menos que sugieran o
enven otro (tengan en cuenta que si el logo de la institucin es muy complejo, al
reducirlo a 24x24 puede que ya no se reconozca).

Si creen que sera util agregar otras personalizaciones adems de las ya


implementadas no duden en sugerirlo.

A continuacin se muestra un ejemplo escrito Para los perfiles Estricto y


Flexible, ilustrando algunas diferencias entre configuraciones:

Proceso Estricto Algoritmo Flexible

Definir VAL_MAYOR,ARREGLO,CANT,I
Como Enteros;
Escribir "Ingrese la
Dimension ARREGLO[100]; cantidad de numeros:"
Escribir "Ingrese la cantidad de Leer CANT
numeros:"; Dimension ARREGLO[CANT]
Leer CANT;
Para Cada Elemento de
Para I<-0 Hasta CANT-1 Hacer ARREGLO
Escribir "Ingrese un numero:"; Escribir "Ingrese un
Leer ARREGLO[I]; numero:"
FinPara Leer ELEMENTO
Fin Para
VAL_MAYOR<-0;
Para I<-0 Hasta CANT-1 Hacer VAL_MAYOR<-0
Si ARREGLO[I]>VAL_MAYOR Para Cada ELEMENTO de
Entonces ARREGLO
VAL_MAYOR<-ARREGLO[i]; Si ELEMENTO Es Mayor Que
FinSi VAL_MAYOR
FinPara VAL_MAYOR<-ELEMENTO
Fin Si
Si VAL_MAYOR % 2 = 0 Entonces Fin Para
Escribir "El mayor es
",VAL_MAYOR," y es par"; Si VAL_MAYOR Es Par
Sino Escribir "El mayor es "
Escribir "El mayor es VAL_MAYOR " y es par"
",VAL_MAYOR," y es impar"; Sino
FinSi Escribir "El mayor es "
VAL_MAYOR " y es impar"
FinProceso Fin Si

FinAlgoritmo

Para qu sirve PSeInt?

PSeInt est pensado para asistir a los estudiantes que se inician en la


construccin de programas o algoritmos computacionales. El pseudocdigo se
suele utilizar como primer contacto para introducir conceptos bsicos como el uso
de estructuras de control, expresiones, variables, etc, sin tener que lidiar con las
particularidades de la sintaxis de un lenguaje real. Este software pretende
facilitarle al principiante la tarea de escribir algoritmos en este pseudolenguaje
presentando un conjunto de ayudas y asistencias, y brindarle ademas algunas
herramientas adicionales que le ayuden a encontrar errores y comprender la lgica
de los algoritmos.

Caractersticas y Funcionalidades de PSeInt:

Puede encontrar en este enlace un resmen rpido y grfico de las principales


funcionalidades.
Presenta herramientas de edicin para escribir algoritmos en pseudocodigo
en espaol
o Autocompletado
o Ayudas Emergentes
o Plantillas de Comandos
o Coloreado de Sintaxis
o Resaltado de bloques lgicos
o Indentado Inteligente
o Listados de funciones, operadores y variables
Permite generar y editar el diagrama de flujo del algoritmo
o Puede trabajar con diagramas clsicos y de Nassi-Shneiderman
Permite la edicin simultnea de mltiples algoritmos
El pseudo-lenguaje utilizado es configurable
o Ofrece perfiles de configuracin predefinidos para numerosas
instituciones
Puede interpretar (ejecutar) los algoritmos escritos
o Puede modificar el algoritmo y ver los cambios en la ejecucin
inmediatamente (sin reingresar los datos)
o Permite modificar uno o ms datos selectos de una ejecucin ya
finalizada para observar cmo varan los resultados
o Permite deshacer una ejecucin para reiniciarla o repetirla desde un
punto arbitrario
o Permite ejecutar el algoritmo paso a paso controlando la velocidad e
inspeccionando variables y expresiones
o Puede confeccionar automticamente una tabla de prueba de
escritorio
o Ofrece un modo especial en el que describe las acciones realizadas
en cada paso
Determina y marca claramente los errores
o Seala errores de sintaxis en tiempo real (mientras escribe)
o Seala claramente errores en tiempo de ejecucion
o Ofrece descripciones detalladas de cada error, con sus causas y
soluciones ms frecuentes.
Permite convertir el algoritmo de pseudocodigo a cdigo numerosos
lenguajes de programacin
o C, C++, C#, Java, JavaScript, MatLab, Pascal, PHP, Python 2, Python 3,
QBasic Visual Basic
Ofrece un sistema de ayuda integrado acerca del pseudocdigo y el uso del
programa
o Incluye un conjunto de ejemplos de diferentes niveles de dificultad
Es multiplataforma (probado en Microsoft Windows, GNU/Linux y Mac OS
X)
Es totalmente libre y gratuito (licencia GPLv2)
Advertencia: Las sintaxis que aqu se presenta corresponde a
la sintaxis en la cual se bas originalmente el proyecto. Desde
hace varias versiones estoy buscando que en la palabra
pseudocdigo pese ms la parte pseudo que la de cdigo. Para
ello se han agregado posibles sinnimos, sintaxis alternativas o
versiones incompletas de algunas construcciones en pos de
desrigidizar el pseudolenguaje utilizado, siempre y cuando no se
caiga en ninguna ambigedad respecto a su interpretacin.
Actualmente, el intrprete puede configurarse para obligar al
alumno a respetar completamente la sintaxis original, aceptar las
variaciones, o algunos grados intermedios (ver perfiles para una
comparacin entre dos versiones de un mismo algoritmo).

El Pseudo-cdigo

Las caractersticas de este pseudolenguaje fueron propuestas


en 2001 por el responsable de la asignatura Fundamentos de
Programacin de la carrera de Ingeniera Informtica de la
FICH-UNL. Las premisas son:

Sintaxis sencilla
Manejo de las estructuras bsicas de control
Solo 3 tipos de datos bsicos: numrico, caracter /cadenas de caracteres y lgico
(verdadero-falso).
Estructuras de datos: arreglos

Todo algoritmo en pseudocgido tiene la siguiente estructura general:

Proceso SinTitulo
accion 1;
accion 1;
.
.
.
accion n;
FinProceso

Comienza con la palabra clave Proceso seguida del nombre del programa, luego le
sigue una secuencia de instrucciones y finaliza con la palabra FinProceso. Una
secuencia de instrucciones es una lista de una o ms instrucciones, cada una
terminada en punto y coma.

Las acciones incluyen operaciones de entrada y salida, asignaciones de variables,


condicionales si-entonces o de seleccin mltiple y/o lazos mientras, repetir o para.

Asignacin

La instruccin de asignacin permite almacenar una valor en una variable.

<variable> <- <expresin> ;

Al ejecutarse la asignacin, primero se evala la expresin de la derecha y luego se


asigna el resultado a la variable de la izquierda. El tipo de la variable y el de la
expresin deben coincidir.

Entradas

La instruccin Leer permite ingresar informacin desde el ambiente.

Leer <variablel> , <variable2> , ... ,


<variableN> ;

Esta instruccin lee N valores desde el ambiente (en este caso el teclado) y los asigna a
las N variables mencionadas. Pueden incluirse una o ms variables, por lo tanto el
comando leer uno o ms valores.

Salidas

La instruccin Escribir permite mostrar valores al ambiente.

Escribir <exprl> , <expr2> , ... , <exprN> ;

Esta instruccin imprime al ambiente (en este caso en la pantalla) los valores
obtenidos de evaluar N expresiones. Dado que puede incluir una o ms expresiones,
mostrar uno o ms valores.
Dimensionamiento
La instruccin Dimension permite definir un arreglo, indicando sus dimensiones.

Dimesion <identificador> (<maxl>,...,<maxN>);

Esta instruccin define un arreglo con el nombre indicado en <indentificador> y N


dimensiones. Los N parmetros indican la cantidad de dimensiones y el valor mximo
de cada una de ellas. La cantidad de dimensiones puede ser una o ms, y la mxima
cantidad de elementos debe ser una expresin numrica positiva.
Se pueden definir ms de un arreglo en una misma instruccin, separndolos con una
coma (,).

Dimension <ident1> (<max11>,...,<max1N>),..., <identM>


(<maxM1>,...,<maxMN>)

Es importante notar que es necesario definir un arreglo antes de utilizarlo.

Condicional Si-Entonces

La secuencia de instrucciones ejecutadas por la instruccin Si-Entonces-Sino depende


del valor de una condicin lgica.

Si <condicin>
Entonces
<instrucciones>
Sino
<instrucciones>
FinSi

Al ejecutarse esta instruccin, se evala la condicin y se ejecutan las instrucciones


que correspondan: las instrucciones que le siguen al Entonces si la condicin es
verdadera, o las instrucciones que le siguen al Sino si la condicin es falsa. La condicin
debe ser una expresin lgica, que al ser evaluada retorna Verdadero o Falso.
La clusula Entonces debe aparecer siempre, pero la clusla Sino puede no estar. En
ese caso, si la condicin es falsa no se ejecuta ninguna instruccin y la ejecucin del
programa contina con la instruccin siguiente.
Seleccin Multiple

La secuencia de instrucciones ejecutada por una instruccin Segun depende del valor
de una variable numrica.

Segun <variable> Hacer


<nmero1>: <instrucciones>
<nmero2>,<nmero3>: <instrucciones>
<...>
De Otro Modo: <instrucciones>
FinSegun

Esta instruccin permite ejecutar opcionalmente varias acciones posibles,


dependiendo del valor almacenado en una variable de tipo numrico. Al ejecutarse, se
evala el contenido de la variable y se ejecuta la secuencia de instrucciones asociada
con dicho valor.
Cada opcin est formada por uno o ms nmeros separados por comas, dos puntos y
una secuencia de instrucciones. Si una opcin incluye varios nmeros, la secuencia de
instrucciones asociada se debe ejecutar cuando el valor de la variable es uno de esos
nmeros.
Opcionalmente, se puede agregar una opcin final, denominada De Otro Modo, cuya
secuencia de instrucciones asociada se ejecutar slo si el valor almacenado en la
variable no coincide con ninguna de las opciones anteriores.

Lazos Mientras

La instruccin Mientras ejecuta una secuencia de instrucciones mientras una condicin


sea verdadera.

Mientras <condicin> Hacer


<instrucciones>
FinMientras

Al ejecutarse esta instruccin, la condicin es evaluada. Si la condicin resulta


verdadera, se ejecuta una vez la secuencia de instrucciones que forman el cuerpo del
ciclo. Al finalizar la ejecucin del cuerpo del ciclo se vuelve a evaluar la condicin y, si
es verdadera, la ejecucin se repite. Estos pasos se repiten mientras la condicin sea
verdadera.
Note que las instrucciones del cuerpo del ciclo pueden no ejecutarse nunca, si al
evaluar por primera vez la condicin resulta ser falsa.
Si la condicin siempre es verdadera, al ejecutar esta instruccin se produce un ciclo
infinito. A fin de evitarlo, las instrucciones del cuerpo del ciclo deben contener alguna
instruccin que modifique la o las variables involucradas en la condicin, de modo que
sta sea falsificada en algn momento y as finalice la ejecucin del ciclo.

Lazos Repetir

La instruccin Repetir-Hasta Que ejecuta una secuencia de instrucciones hasta que la


condicin sea verdadera.

Repetir
<instrucciones>
Hasta Que <condicin>

Al ejecutarse esta instruccin, la secuencia de instrucciones que forma el cuerpo del


ciclo se ejecuta una vez y luego se evala la condicin. Si la condicin es falsa, el
cuerpo del ciclo se ejecuta nuevamente y se vuelve a evaluar la condicin. Esto se
repite hasta que la condicin sea verdadera.
Note que, dado que la condicin se evala al final, las instrucciones del cuerpo del ciclo
sern ejecutadas al menos una vez.
Adems, a fin de evitar ciclos infinitos, el cuerpo del ciclo debe contener alguna
instruccin que modifique la o las variables involucradas en la condicin de modo que
en algn momento la condicin sea verdadera y se finalice la ejecucin del ciclo.

Lazos Para



La instruccin Para ejecuta una secuencia de instrucciones un nmero determinado de
veces.

Para <variable> <- <inicial> Hasta <final> ( Con Paso


<paso> ) Hacer
<instrucciones>
FinPara

Al ingresar al bloque, la variable <variable> recibe el valor <inicial> y se ejecuta la


secuencia de instrucciones que forma el cuerpo del ciclo. Luego se incrementa la
variable <variable> en <paso> unidades y se evala si el valor almacenado en
<variable> super al valor <final>. Si esto es falso se repite hasta que <variable> supere
a <final>. Si se omite la clusula Con Paso <paso>, la variable <variable> se
incrementar en 1.

Operadores y Funciones
Este pseudolenguaje dispone de un conjunto bsico de operadores y funciones que
pueden ser utilizados para la construccin de expresiones ms o menos complejas.

Las siguientes tablas exhiben la totalidad de los operadores de este lenguaje reducido:

Operador Significado Ejemplo

Relacionales

> Mayor que 3>2

< Menor que 'ABC'<'abc'

= Igual que 4=3

<= Menor o igual que 'a'<='b'

>= Mayor o igual que 4>=5

Logicos

&Y Conjuncin (y). (7>4) & (2=1) //falso

|O Disyuncin (o). (1=1 | 2=1) //verdadero

~ NO Negacin (no). ~(2<5) //falso


Algebraicos

+ Suma total <- cant1 + cant2

- Resta stock <- disp - venta

* Multiplicacin area <- base * altura

/ Divisin porc <- 100 * parte / total

^ Potenciacin sup <- 3.41 * radio ^ 2

% MOD Mdulo (resto de la divisin entera) resto <- num MOD div

La jerarqua de los operadores matemticos es igual a la del lgebra, aunque puede


alterarse mediante el uso de parntesis.

A continuacin se listan las funciones integradas disponibles:

Funcin Significado

RC(X) Raz Cuadrada de X

ABS(X) Valor Absoluto de X

LN(X) Logaritmo Natural de X

EXP(X) Funcin Exponencial de X

SEN(X) Seno de X

COS(X) Coseno de X

ATAN(X) Arcotangente de X

TRUNC(X) Parte entera de X

REDON(X) Entero ms cercano a X

AZAR(X) Entero aleatorio entre 0 y X-1


Algunas Observaciones
Se pueden introducir comentarios luego de una instruccin, o en lneas separadas, mediante
el uso de la doble barra ( // ). Todo lo que precede a //, hasta el fin de la lnea, no ser tomado
en cuenta al interpretar el algoritmo.
Notese que no puede haber instrucciones fuera del programa, aunque si comentarios.
Las estructuras no secuenciales pueden anidarse. Es decir, pueden contener otras adentro,
pero la estructura contenida debe comenzar y finalizar dentro de la contenedora.
Los identificadores, o nombres de variables, deben constar slo de letras y nmeros,
comenzando siempre con una letra, y no pueden ser palabras reservadas (como para,
mientras, y, no, etc...)
Las constantes de tipo carcter se escriben entre comillas ( " ).
En las constantes numricas, el punto ( . ) es el separador decimal.
Las constantes lgicas son Verdadero y Falso.

Ejemplos

Ejercicios
Ejemplos de algoritmos en PSeudoCodigo

En esta seccin puede observar ejemplos de pseudocdigos vlidos en PSeInt, as


como tambin sus correspondientes diagramas de flujo (en cualquiera de las tres
formas soportadas). Recuerde que el lenguaje de PSeInt puede adaptarse a
diferentes perfiles. A modo de ejemplo se incluyen los algoritmos para dos perfiles
diferentes, uno con reglas flexibles, y otro con reglas estrictas.

Suma: Este es el ejemplo ms simple. Muestra cmo cargar dos nmeros de dos
variables, calcular la suma de los mismos y mostrarla en pantalla.

// este es el ejemplo ms simple de esta ayuda,


// toma dos numeros, los suma y muestra el resultado

Proceso Suma

// para cargar un dato, se le muestra un mensaje al usuario


// con la instruccin Escribir, y luego se lee el dato en
// una variable (A para el primero, B para el segundo) con
// la instruccin Leer

Escribir "Ingrese el primer numero:"


Leer A

Escribir "Ingrese el segundo numero:"


Leer B
// ahora se calcula la suma y se guarda el resultado en la
// variable C mediante la asignacin (<-)

C <- A+B

// finalmente, se muestra el resultado, precedido de un


// mensaje para avisar al usuario, todo en una sola
// instruccin Escribir

Escribir "El resultado es: ",C

FinProceso

Mayores: Busca los dos mayores de un arreglo de N datos.

// Busca los dos mayores de una lista de N datos

Proceso Mayores

// primero se declara un arreglo de 200 elementos


Dimension datos[200]

// luego se pide al usuario ingresar la cantidad de datos,


// que no debera ser mayor a 200
Escribir "Ingrese la cantidad de datos (de 2 a 200):"
Leer n

// se leen uno por uno los 200 datos y se los guarda en el arreglo
Para i<-1 Hasta n Hacer
Escribir "Ingrese el dato ",i,":"
Leer datos[i]
FinPara

// se comparan los dos primeros y se toman como may1 (el mayor de los
// dos) y may2 (el segundo mayor).
Si datos[1]>datos[2] Entonces
may1<-datos[1]
may2<-datos[2]
Sino
may1<-datos[2]
may2<-datos[1]
FinSi
// se recorren los demas elementos buscan si hay alguno mayor que may1 o may2
Para i<-3 Hasta n Hacer
Si datos[i]>may1 Entonces // si hay un valor mayor que may1
may2<-may1 // como may1 era el ms grande, pasa a estar en segundo lugar
may1<-datos[i] // y el nuevo dato toma el primer puesto (mayor de todos)
Sino // si no era mas grande que may1, todavia puede ser mas grande que may2
Si datos[i]>may2 Entonces // si supera al segundo mayor que teniamos
may2<-datos[i] // se lo guarda como segundo mayor
FinSi
FinSi
FinPara

// se muestran los resultados


Escribir "El mayor es: ",may1
Escribir "El segundo mayor es: ",may2

FinProceso

Coloquial: En este ejemplo se muestran algunas de las variantes que se pueden


utilizar con el perfil de lenguaje Flexible para que el pseudocdigo se asemeje ms
al lenguaje coloquial.

// Este ejemplo muestra algunas de las variaciones posibles cuando se utiliza


// syntaxis flexible, instrucciones adicionales, y expresiones en lenguaje
// coloquial para las condiciones.

Proceso sin_titulo

Definir a, b Como Entero

Imprimir "Ingrese 3 numeros (los dos primeros deben ser enteros):"


Leer a b c

Si a Es Mayor Que b Y a Es Mayor Que c Entonces


Escribir a " es el mayor"
sino
Si b Es Mayor Que c Entonces
Escribir b " es el mayor"
Sino
Escribir c " es el mayor"
FinSi
FinSi

Mostrar "Pulse una tecla para continuar"


Esperar Tecla
Limpiar Pantalla

Si a Es Par
Escribir a " es par"
Sino
Escribir a " es impar"
FinSi

Escribir Sin Bajar "Los divisores de " b " son: "


Para i Desde 1 Hasta b-1
Si b Es Multiplo De i
Escribir sin bajar i " "
Fin Si
Fin Para
Escribir b
Si c Es Entero
Mostrar C " es entero"
Sino
Mostrar C " es real"
FinSi

FinProceso

Subprocesos: Ejemplo bsico que ilustra la sintaxis para declarar


nuevas funciones en pseudocdigo.
// funcion que no recibe ni devuelve nada
SubProceso Saludar
Escribir "Hola mundo!"
FinSubProceso

// funcion que recibe un argumento por valor, y devuelve su doble


SubProceso res <- CalcularDoble(num)
res <- num*2 // retorna el doble
FinSubProceso

// funcion que recibe un argumento por referencia, y lo modifica


SubProceso Triplicar(num por referencia)
num <- num*3 // modifica la variable duplicando su valor
FinSubProceso

// proceso principal, que invoca a las funciones antes declaradas


Proceso PruebaFunciones

Escribir "Llamada a la funcion Saludar:"


Saludar // como no recibe argumentos pueden omitirse los parntesis vacios

Escribir "Ingrese un valor numrico para x:"


Leer x

Escribir "Llamada a la funcin CalcularDoble (pasaje por valor)"


Escribir "El doble de ",x," es ", CalcularDoble(x)
Escribir "El valor original de x es ",x

Escribir "Llamada a la funcin Triplicar (pasaje por referencia)"


Triplicar(x)
Escribir "El nuevo valor de x es ", x

FinProceso

Adivina Numero: Sencillo juego en el que el usuario debe adivinar un


nmero aleatorio
// Juego simple que pide al usuario que adivine un numero en 10 intentos
Proceso Adivina_Numero

intentos<-10
num_secreto <- azar(100)+1

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

Promedio: Ejemplo bsico de uso de un acumulador y la estructura de


control Para para calcular el promedio de un conjunto de valores
// Calcula el promedio de una lista de N datos

Proceso Promedio

Escribir "Ingrese la cantidad de datos:"


Leer n

acum<-0

Para i<-1 Hasta n Hacer


Escribir "Ingrese el dato ",i,":"
Leer dato
acum<-acum+dato
FinPara

prom<-acum/n

Escribir "El promedio es: ",prom

FinProceso
Triangulo: Este algoritmo determina a partir de las longitudes de tres
lados de un tringulo si corresponden a un tringulo rectngulo (para
utiliza la relacin de Pitgoras, tomando los dos lados de menor
longitud como catetos), y en caso afirmativo informa el rea del mismo.
Ejemplo de la estructura Si-Entonces y anidamiento.
// Lee los tres lados de un triangulo rectangulo, determina
// si corresponden (por Pitargoras) y en caso afirmativo
// calcula el area

Proceso TrianguloRectangulo

// cargar datos
Escribir "Ingrese el lado 1:"
Leer l1
Escribir "Ingrese el lado 2:"
Leer l2
Escribir "Ingrese el lado 3:"
Leer l3

// encontrar la hipotenusa (mayor lado)


Si l1>l2 Entonces
cat1<-l2
Si l1>l3 Entonces
hip<-l1
cat2<-l3
Sino
hip<-l3
cat2<-l1
FinSi
Sino
cat1<-l1
Si l2>l3 Entonces
hip<-l2
cat2<-l3
Sino
hip<-l3
cat2<-l2
FinSi
FinSi

// ver si cumple con Pitagoras


Si hip^2 = cat1^2 + cat2^2 Entonces
// calcualar area
area<-(cat1*cat2)/2
Escribir "El area es: ",area
Sino
Escribir "No es un triangulo rectangulo."
FinSi

FinProceso
Ordena Lista: Este ejemplo almacena una lista de nombres en un
arreglo y luego los ordena alfabticamente. El mtodo de
ordenamiento es relativamente simple. Para la entrada de datos se
utiliza una estructura Mientras, sin saber a priori la cantidad de datos
que se ingresarn
// Se ingresa una lista de nombres (la lista termina
// cuando se ingresa un nombre en blanco) no permitiendo
// ingresar repetidos y luego se ordena y muestra

Proceso OrdenaLista

Dimension lista[200]

Escribir "Ingrese los nombres (enter en blanco para terminar):"

// leer la lista
cant<-0
Leer nombre
Mientras nombre<>"" Hacer
cant<-cant+1
lista[cant]<-nombre
Repetir // leer un nombre y ver que no este ya en la lista
Leer nombre
se_repite<-Falso
Para i<-1 Hasta cant Hacer
Si nombre=lista[i] Entonces
se_repite<-Verdadero
FinSi
FinPara
Hasta Que NO se_repite
FinMientras

// ordenar
Para i<-1 Hasta cant-1 Hacer
// busca el menor entre i y cant
pos_menor<-i
Para j<-i+1 Hasta cant Hacer
Si lista[j]<lista[pos_menor] Entonces
pos_menor<-j
FinSi
FinPara
// intercambia el que estaba en i con el menor que encontro
aux<-lista[i]
lista[i]<-lista[pos_menor]
lista[pos_menor]<-aux
FinPara

// mostrar como queda la lista


Escribir "La lista ordenada es:"
Para i<-1 Hasta cant Hacer
Escribir " ",lista[i]
FinPara

FinProceso

Modulo: Ejemplo trivial del uso del operador de mdulo (MOD o %)

Proceso Modulo
Escribir "Ingrese el numero: "
Leer N
Escribir "Ingrese el divisor: "
Leer M
Si N MOD M = 0 Entonces
Escribir M," es divisor exacto de ",N,"."
Sino
Escribir "El resto de dividir ",N," por ",M," es: ",N MOD M
FinSi
FinProceso

Men: Ejemplo simple de men de opciones, con las estructuras


Repetir-Hasta Que y Segn
// Muestra como hacer un men simple con las estructuras Repetir-Hasta Que y Segn

Proceso sin_titulo
Repetir
// mostrar menu
Limpiar Pantalla
Escribir "Men de recomendaciones"
Escribir " 1. Literatura"
Escribir " 2. Cine"
Escribir " 3. Msica"
Escribir " 4. Videojuegos"
Escribir " 5. Salir"
// ingresar una opcion
Escribir "Elija una opcin (1-5): "
Leer OP
// procesar esa opcin
Segun OP Hacer
1:
Escribir "Lecturas recomendables:"
Escribir " + Esperndolo a Tito y otros cuentos de fbol (Eduardo Sacheri)"
Escribir " + El juego de Ender (Orson Scott Card)"
Escribir " + El sueo de los hroes (Adolfo Bioy Casares)"
2:
Escribir "Pelculas 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 " + Bfalo (La Mississippi, 2008)"
Escribir " + Gaia (Mgo de Oz, 2003)"
4:
Escribir "Videojuegos clsicos recomendables"
Escribir " + Da del tentculo (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 "Opcin no vlida"
FinSegun
Escribir "Presione enter para continuar"
Esperar Tecla
Hasta Que OP=5
FinProceso

Dgitos: Separa los dgitos de un nmero entero utilizando el operador


mdulo
// Separa un numero entero en sus digitos

Proceso Digitos

Escribir "Ingrese un numero entero postivo:"


Leer n

// primero, contar cuantos digitos


cont <- 0
aux <- n
Mientras aux>0 hacer // mientras no sea cero
cont <- cont + 1 // contar cuantos digitos
aux <- trunc(aux/10) // dividir por 10 y despreciar los de
FinMientras
Escribir "El numero tiene ",cont," digitos"

// luego, mostrarlos uno por uno


aux<-n
Para i<-1 hasta cont Hacer
pot <- 10^(cont-i) // por cuanto hay que dividir para obtener el primer digito
digito <- trunc (aux / pot) // obtener el digito
aux <- aux - digito*pot // quitar ese digito al numero
Escribir "El digito ",i," es ",digito
FinPara

FinProceso
Resolvente: Utiliza la frmula resolvente para determinar las races de una
ecuacin de segundo grado a partir de sus tres coeficientes, y las informa
adecuadamente segn su tipo (reales iguales, reales distintas, imaginarias)

// calcula las raices de una ecuacion de segundo grado

Proceso Resolvente

// cargar datos
Escribir "Ingrese el coeficiente A:"
Leer a
Escribir "Ingrese el coeficiente B:"
Leer b
Escribir "Ingrese el coeficiente C:"
Leer c

// determinar si son reales o imaginarias


disc <- b^2-4*a*c
Si disc<0 Entonces
// si son imaginarias
preal<- (-b)/(2*a)
pimag<- rc(-disc)/(2*a)
Escribir "Raiz 1: ",preal,"+",pimag,"i"
Escribir "Raiz 2: ",preal,"-",pimag,"i"
Sino
Si disc=0 Entonces // ver si son iguales o distintas
r <- (-b)/(2*a)
Escribir "Raiz 1 = Raiz 2: ",r
Sino
r1 <- ((-b)+rc(disc))/(2*a)
r2 <- ((-b)-rc(disc))/(2*a)
Escribir "Raiz 1: ",r1
Escribir "Raiz 2: ",r2
FinSi
FinSi

FinProceso

Primos: Calcula iterativamente los N primeros nmeros primos

// Encuentra los primeros N numeros primos

Proceso Primos

Escribir "Ingrese la cantidad de numeros primos a mostrar:"


Leer cant_a_mostrar

Escribir "1: 2" // el primer primo es 2, los otros son todos impares...
cant_mostrados <- 1
n<-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 i<-3 hasta rc(n) con paso 2 Hacer // ya sabemos que es impar
Si n MOD i = 0 entonces // si la division da exacta...
es_primo <- Falso // ...ya no es primo
FinSi
FinPara

Si es_primo Entonces
cant_mostrados <- cant_mostrados + 1
Escribir cant_mostrados, ": ",n
FinSi

n <- n + 2

FinMientras

FinProceso

Factorizacin: Ejemplo de algoritmo para descomponer un nmero en sus


factores primos

Proceso Factorizacion

Escribir "Ingrese el numero: "


Leer num

Escribir "Factorizacion: "

factorizar<-verdadero

Mientras factorizar Y num>1 hacer


div<-0
Si num/2 = trunc(num/2) Entonces
Escribir 2
num<-num/2
Sino
div<-1; factor_primo<-Verdadero
Mientras div<=rc(num) Y factor_primo Hacer
div <- div+2
Si num/div = trunc(num/div) Entonces
factor_primo <- Falso
FinSi
FinMientras
Si factor_primo Entonces
escribir num
factorizar<-falso
sino
escribir div
num<-num/div
factor_primo<-verdadero
FinSi
FinSi
FinMientras

FinProceso

Cadenas: Muestra la utilizacin de las funciones de cadenas para


contar las vocales de una frase
// Este ejemplo muestra como utilizar las funciones para manejo
// de cadenas de caracteres. Requiere que el perfil de lenguaje
// habilite estas funciones. Si al intentar ejecutar obtiene
// errores en las funciones, revise su configuracin en el
// item "Opciones del lenguaje" del men "Configurar".
Proceso sin_titulo

// el usuario ingresa una frase, vamos a contar cuantas vocales tiene


Escribir "Ingrese una frase"
Leer frase
// pasamos toda la frase a minusculas para no tener que preguntar 2 veces por cada vocal
frase<-Minusculas(frase)

// lista de letras que vamos a buscar


Vocales<-"aeiou"
cantvocales<-0

// comparar todas las letras de frase con las de vocales y contar coincidencias
Para i<-1 hasta Longitud(frase) Hacer
Para j<-1 hasta Longitud(vocales) Hacer
Si Subcadena(frase,i,i)=Subcadena(vocales,j,j) Entonces
cantVocales<-cantVocales+1
FinSi
FinPara
FinPara

Escribir "La frase contiene ",cantVocales," vocales."

FinProceso

Para: En este ejemplo se recorre un arreglo utilizando las tres


variantes de la estructura Para
// Para poder ejecutar correctamente este ejemplo debe tener
// habilitada la sintaxis flexible en su perfil de lenguaje

Proceso sin_titulo

// declara un arreglo de 10 elementos


Dimension A[10]

// recorre los 10 elementos y va asignandoles enteros aleatorios


para cada elemento de A Hacer
// elemento toma el contenido de cada posicion del arreglo
// y si se modifica elemento se modifica el arreglo
elemento <- azar(100)
FinPara

Escribir "Los elementos del arreglo son:"


// recorre los 10 elementos utilizando subindices y los muestra en pantalla
para i desde 1 hasta 10 Hacer
escribir "Posicin " i ": " A[i]
FinPara

Escribir "" // deja una linea en blanco

Escribir "En orden inverso:"


// recorre los 10 elementos en orden inverso y los muestra en una misma linea
para i desde 10 hasta 1 Hacer
escribir sin bajar A[i] " "
FinPara

FinProceso

Potencia: Ejemplo de una funcin recursiva para calcular una potencia

// Implementacin del clculo de una potencia mediante una funcin recursiva


// El paso recursivo se basa en que A^B = B*(A^(B-1))
// El paso base se base en que A^0 = 1

SubProceso resultado <- Potencia (base, exponente)


Si exponente=0 Entonces
resultado <- 1;
sino
resultado <- base*Potencia(base,exponente-1);
FinSi
FinSubProceso

Proceso DosALaDiezRecursivo
Escribir "Ingrese Base"
Leer base
Escribir "Ingrese Exponente"
Leer exponente
Escribir "El resultado es ",Potencia(base,exponente)
FinProceso

Promedio2: Ejemplo de cmo crear subprocesos que reciban arreglos como


argumento
// Calcula el promedio de una lista de N datos utilizando un SubProceso

SubProceso prom <- Promedio ( arreglo, cantidad )


suma <- 0
Para i<-1 Hasta cantidad Hacer
suma <- suma + arreglo[i]
FinPara
prom <- suma/cantidad
FinSubProceso

Proceso Principal

Dimension datos[100]
Escribir "Ingrese la cantidad de datos:"
Leer n

Para i<-1 Hasta n Hacer


Escribir "Ingrese el dato ",i,":"
Leer datos[i]
FinPara

Escribir "El promedio es: ",Promedio(datos,n)

FinProceso

Misil: Ejemplo de animacin con cdigos ASCII y la instruccin Esperar

Proceso Misil

Escribir "Presione una tecla para iniciar el lanzamiento!"


Esperar Tecla

// el arreglo cohete tiene el dibujo del cohete como lineas de texto


dimension cohete[9]
cohete[1]<-" /|\ "
cohete[2]<-" |B| "
cohete[3]<-" |O| "
cohete[4]<-" |M| "
cohete[5]<-" |B| "
cohete[6]<-" //|\\ "
cohete[7]<-" ******* "
cohete[8]<-"* * * * *"
cohete[9]<-" * * * * "

// primero se muestra la primer parte del dibujo y la cuenta regresiva


Para i<-1 hasta 11 Hacer
Borrar Pantalla
Para j<-1 hasta 15 Hacer
Escribir ""
FinPara
Para j<-1 hasta 6 Hacer
Escribir cohete[j]
FinPara
Escribir ""
Escribir "Lanzamiento en ",11-i
Esperar 1 Segundo
FinPara

// despues se muestra el dibujo completo y cada vez mas arriba


Para i<-1 hasta 15 Hacer
Borrar Pantalla
Para j<-i hasta 15 Hacer
Escribir ""
FinPara
Para j<-1 hasta 8 Hacer
Escribir cohete[j]
FinPara
si i>1 Entonces
Escribir " * * * * "
finsi
Esperar 1/i Segundo
FinPara

// finalmente se va modificando el dibujo para hacer la explosion


// estado tiene un entero que dice en que parte de la explosion va cada linea del
dibujo
Dimension estado[6]
estado[1]<-3; estado[2]<-2; estado[3]<-1
estado[4]<-2; estado[5]<-3; estado[6]<-4
Para i<-1 hasta 10 Hacer
Borrar Pantalla
Para j<-1 hasta 6 Hacer
Estado[j]<-Estado[j]-1
segun Estado[j] Hacer
0: cohete[j]<-" + "
-1,-5: cohete[j]<-" +X+ "
-2,-4: cohete[j]<-" +XXX+ "
-3: cohete[j]<-" +XXXXX+ "
-6: cohete[j]<-" "
FinSegun
Escribir cohete[j]
FinPara

Esperar .2 Segundos
FinPara
FinProceso

Romanos: Muestra como convertir nmeros enteros a notacin romana


utilizando arreglos

Proceso Romanos

// leer el nmero
Escribir "Ingrese un nmero entre 1 y 1000"
Leer Numero

// controlar que sea vlido para convertir


SePuedeConvertir<-Verdadero
Si Numero=0 Entonces
Escribir "No existe ningn smbolo para representar el 0"
SePuedeConvertir<-Falso
FinSi
Si Numero<>trunc(numero) Entonces
Escribir "El nmero debe ser entero"
SePuedeConvertir<-Falso
FinSi
Si Numero>1000 Entonces
Escribir "Muy alto"
SePuedeConvertir<-Falso
FinSi
Si Numero<0 Entonces
Escribir "Debe ser positivo"
SePuedeConvertir<-Falso
FinSi

// realizar la conversin
Si SePuedeConvertir Entonces
Si Numero=1000 Entonces
Escribir "M"
Sino
Dimension nu[10], nd[10], nc[10] // notacin para unidades, decenas y
centenas
nu[1]<-''; nu[2]<-'I'; nu[3]<-'II'; nu[4]<-'III'; nu[5]<-'IV'; nu[6]<-'V'; nu[7]<-
'VI'; nu[8]<-'VII'; nu[9]<-'VIII'; nu[10]<-'IX'
nd[1]<-''; nd[2]<-'X'; nd[3]<-'XX'; nd[4]<-'XXX'; nd[5]<-'XL'; nd[6]<-'L';
nd[7]<-'LX'; nd[8]<-'LXX'; nd[9]<-'LXXX'; nd[10]<-'XC'
nc[1]<-''; nc[2]<-'C'; nc[3]<-'CC'; nc[4]<-'CCC'; nc[5]<-'CD'; nc[6]<-'D';
nc[7]<-'DC'; nc[8]<-'DCC'; nc[9]<-'DCCC'; nc[10]<-'CM'
centenas<-trunc(Numero/100) MOD 10
decenas<-trunc(Numero/10) MOD 10
unidades<-Numero MOD 10
Escribir nc[centenas+1],nd[decenas+1],nu[unidades+1]
FinSi
FinSi

FinProceso

Hanoi: Implementa el conocido juego de las torres de Hanoi en pseudocdigo

// El objetivo del juego es mover los discos de la torre 1 a la 3 en la


// menor cantidad de movimientos posible. No se puede colocar un disco de
// un tamanio sobre otro mas chico

// Hay una matriz que representa las torres, cada columna contiene
// nros que representan los tamanios de los discos en esas torres (solo
// interesan los valores hasta la cantidad de discos de esa torre).
// Cuantos discos tiene cada torre lo dice el vector cant_discos.

Proceso Hanoi

Dimension torres[3,10], cant_discos[3]

// pedir y validar cuantos discos colocar en la primer torre


Escribir "Ingrese el nro de discos (1-8):"
leer discos
mientras discos<1 O discos>8 Hacer
Escribir "El numero de discos debe ser mayor a 0 y menor a 5:"
leer discos
finmientras

// inicializar los datos


cant_discos[1]<-discos
cant_discos[2]<-0
cant_discos[3]<-0
Para i<-1 Hasta discos hacer
torres[1,i]<-discos-i+1
FinPara

// jugar!
cant_movs<-0
Mientras cant_discos[3]<>discos Hacer // mientras no esten todos los discos en
la tercer torre, el juego sigue

Limpiar Pantalla

Para i<-1 Hasta 3 Hacer // dibujar las tres torres


escribir "Torre ",i
si cant_discos[i]=0 Entonces
Escribir ""
sino
para j<-cant_discos[i] hasta 1 con paso -1 Hacer // recorrer los discos de
la torre, de arriba hacia abajo
segun torres[i,j] Hacer // dibujar cada disco
1: Escribir " XX"
2: Escribir " XXXXXX"
3: Escribir " XXXXXXXXXX"
4: Escribir " XXXXXXXXXXXXXX"
5: Escribir " XXXXXXXXXXXXXXXXXX"
6: Escribir " XXXXXXXXXXXXXXXXXXXXXX"
7: Escribir " XXXXXXXXXXXXXXXXXXXXXXXXXX"
8: Escribir " XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
finsegun
FinPara
finsi
Escribir " ----------------------------------"
Escribir ""
FinPara

// solicitar movimiento
Escribir "Mover desde la torre: "
leer t1
Escribir "hacia la torre: "
leer t2

si t1<1 O t1>3 O t2<1 O t2>3 Entonces // controlar que el nro de torre sea
valido
Escribir "Movimiento invalido"
Esperar Tecla
sino
Si cant_discos[t1]=0 Entonces // controlar que la torre 1 tengo al menos un
disco
Escribir "Movimiento invalido"
Esperar Tecla
Sino
disco_a_mover <- torres[t1,cant_discos[t1]] // obtener tamanio del disco
que se quiere mover
puede_mover<-verdadero
Si cant_discos[t2]<>0 entonces // controlar que la torre dos no tenga
discos o tenga solo discos mas grandes
Si torres[t2,cant_discos[t2]]<disco_a_mover Entonces
puede_mover<-Falso
FinSi
FinSi
Si puede_mover Entonces // si paso todos los controles, mover
cant_movs <- cant_movs+1
cant_discos[t2]<-cant_discos[t2]+1
torres[t2,cant_discos[t2]] <- disco_a_mover
cant_discos[t1]<-cant_discos[t1]-1
Sino
Escribir "Movimiento invalido"
Esperar Tecla
FinSi
FinSi
FinSi

FinMientras

// mostrar resultado
Limpiar Pantalla
Escribir "Juego finalizado en ",cant_movs," movimientos!"

FinProceso

TaTeTi: Algoritmo para el juego del TaTeTi

Proceso TaTeTi

// incializa dos matrices de 3x3, una para guardar la ficha que se ve,
// y otra para un valor asociado a la ficha, para un jugador sera 1, para
// el otro 2, entoces para ver quien gano se multiplica por fila, por
// columna y por diagonal, si el resultado es 1 gano el primer jugador,
// si es 8 gano el segundo, si es 0 es porque faltaba completar, si
// es otra cosa, estan las tres fichas, pero no son del mismo jugador
Dimension Tab1[3,3]
Dimension Tab2[3,3]
Para i<-1 Hasta 3 Hacer
Para j<-1 Hasta 3 Hacer
Tab1[i,j]<-0
Tab2[i,j]<-" "
FinPara
FinPara
TurnoJugador1<-Verdadero
Terminado<-Falso
Ganador<-Falso
CantTurnos<-0

Mientras ~ Terminado hacer

// dibuja el tablero
Borrar Pantalla
Escribir " "
Escribir " || || "
Escribir " ",Tab2[1,1]," || ",Tab2[1,2]," || ",Tab2[1,3]
Escribir " 1|| 2|| 3"
Escribir " =====++=====++======"
Escribir " || || "
Escribir " ",Tab2[2,1]," || ",Tab2[2,2]," || ",Tab2[2,3]
Escribir " 4|| 5|| 6"
Escribir " =====++=====++======"
Escribir " || || "
Escribir " ",Tab2[3,1]," || ",Tab2[3,2]," || ",Tab2[3,3]
Escribir " 7|| 8|| 9"
Escribir " "

Si ~ Ganador y CantTurnos<9 Entonces

// carga auxiliares segun a qu jugador le toca


Si TurnoJugador1 Entonces
Ficha<-'O'; Valor<- 1; Objetivo<-1
Escribir "Turno del jugador 1 (X)"
Sino
Ficha<-'X'; Valor<- 2; Objetivo<-8
Escribir "Turno del jugador 2 (O)"
FinSi

// pide la posicin para colocar la ficha y la valida


Escribir "Ingrese la Posicin (1-9):"

Repetir
Leer Pos
Si Pos<1 o Pos>9 Entonces
Escribir "Posicin incorrecta, ingrese nuevamente: "
Pos<-99;
Sino
i<-trunc((Pos-1)/3)+1
j<-((Pos-1) MOD 3)+1
Si Tab1[i,j]<>0 Entonces
pos<-99
Escribir "Posicin incorrecta, ingrese nuevamente: "
FinSi
FinSi
Hasta Que Pos<>99
// guarda la ficha en la matriz tab2 y el valor en tab1
CantTurnos<-CantTurnos+1
Tab1[i,j]<-Valor
Tab2[i,j]<-Ficha

// verifica si gan, buscando que el producto de las fichas en el tablero de


Objetivo
aux_d1<-1; aux_d2<-1
Para i<-1 hasta 3 hacer
aux_i<-1; aux_j<-1
aux_d1<-aux_d1*Tab1[i,i]
aux_d2<-aux_d2*Tab1[i,4-i]
Para j<-1 hasta 3 hacer
aux_i<-aux_i*Tab1[i,j]
aux_j<-aux_j*Tab1[j,i]
FinPara
Si aux_i=Objetivo o aux_j=Objetivo Entonces
Ganador<-Verdadero
FinSi
FinPara
Si aux_d1=Objetivo o aux_d2=Objetivo Entonces
Ganador<-Verdadero
Sino
TurnoJugador1 <- ~ TurnoJugador1
FinSi

Sino

Si Ganador Entonces
Escribir "Ganador: "
Si TurnoJugador1 Entonces
Escribir "Jugador 1!"
Sino
Escribir "Jugador 2!"
FinSi
Sino
Escribir "Empate!"
FinSi
Terminado<-Verdadero

FinSi

FinMientras

FinProceso
Calculadora Bsica (PSeInt)
Calculadora n1

Proceso sin_titulo

Escribir "Eliga la operacion:";


Escribir "1=Suma";
Escribir "2=Resta";
Escribir "3=Multiplicacion";
Escribir "4=Division";
Leer a;
Escribir "Introduzca dos cifras";
Leer b;
Mientras b<0 Hacer
Escribir "Este numero no es valido, Introduzca otro";
Leer b;
FinMientras
Leer c;
Mientras c=0 Hacer
Escribir "Valor 0 no sirve";
Leer c;
FinMientras
Si a=1 Entonces
Escribir "Vas a sumar";
d<-b+c;
Sino
Si a=2 Entonces
Escribir "Vas a restar";
d<-b-c;
Sino
si a=3 Entonces
Escribir "Vas a multiplicar";
d<-b*c;
Sino
si a=4 Entonces
Escribir "Vas a dividir";
d<-b/c;
Finsi
Finsi
Finsi
FinSi
Escribir "Tu resultado es:";
Escribir d;
FinProceso

Calculadora n2

Proceso sin_titulo

//Entrada

n1<-0

n2<-0

menu<-0

Escribir "Ingrese dos numeros para posteriormente elegir la


operacion a realizar";

Escribir " ";

Escribir "Inserte primer numero: ";

leer n1;

Escribir "Inserte segundo numero: ";

leer n2;

Escribir " ";


Escribir "Menu de Opciones";

Escribir " ";

Escribir "(1) Sumar";

Escribir "(2) Restar";

Escribir "(3) Multiplicar";

Escribir "(4) Dividir";

Escribir "(5) Porcentaje (X por ciento de Y)";

Escribir " ";

leer menu;

escribir " ";

//Proceso//Fin

segun menu Hacer

1: Escribir "Vas a sumar";

Escribir "La suma es: ",n1+n2;

2: escribir "Vas a restar";

Escribir "La resta es: ",n1-n2;

3: Escribir "vas a multiplicar";

Escribir "La multiplicacion es: ",n1*n2;

4: Escribir "Vas a Dividir";

Mientras n2=0 Hacer


Escribir "Divides por 0. Resultado Indefinido";

Escribir " ";

Escribir "Vuelve a insertar el segundo numero:";

leer n2;

FinMientras

Escribir "La division es: ",n1/n2;

5: Escribir "El ",n1," por ciento de ",n2," es: ",(n1/100)*n2;

De Otro Modo:

Escribir "No se encuentra numero de operacion";

FinSegun

FinProceso

Proceso calculadora
Definir n1 Como Entero;
Definir n2 como entero ;
Definir tabla como entero;
definir resultado como entero;

Escribir "inserte numero 1:" ;


Leer n1;

Escribir "inserte numero 2:" ;


leer n2;
Escribir "1.-sumar";
Escribir "2.-restar";
Escribir "3.-multiplicar";
Escribir "4.-dividir";
Leer tabla;

Segun tabla Hacer


1: resultado = n1+n2;
Escribir "su resultado es:" ,resultado;

2:resultado = n1-n2;
Escribir "su resultado es:" ,resultado;
3:resultado= n1*n2;
escribir "su resultado es:" ,resultado;

4: resultado= n1/n2;
Escribir "su resultado es:", resultado;

De Otro Modo:
Escribir "No ves que tenes 4 opciones nomas ? pedaso de imbecil escribi bien";

Fin Segun

FinProceso