¿Para qué sirve PSeInt?

PSeInt está pensado para asistir a los estudiantes que se inician en la construcción de programas o algoritmos
computacionales. El pseudocódigo se suele utilizar como primer contacto para introducir conceptos básicos
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 además algunas
herramientas adicionales que le ayuden a encontrar errores y comprender la lógica de los algoritmos.

Características y Funcionalidades de PSeInt:

 Presenta herramientas de edición para escribir algoritmos en pseudocódigo en español
o Autocompletado
o Ayudas Emergentes
o Plantillas de Comandos
o Coloreado de Sintaxis
o Resaltado de bloques lógicos
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 clásicos y de Nassi-Shneiderman
 Permite la edición simultánea de múltiples algoritmos
 El pseudo-lenguaje utilizado es configurable
o Ofrece perfiles de configuración predefinidos para numerosas
instituciones
 Puede interpretar (ejecutar) los algoritmos escritos
o Puede modificar el algoritmo y ver los cambios en la ejecución
inmediatamente (sin reingresar los datos)
o Permite modificar uno o más datos selectos de una ejecución ya
finalizada para observar cómo varían los resultados
o Permite deshacer una ejecución 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 automáticamente 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 Señala errores de sintaxis en tiempo real (mientras escribe)
o Señala claramente errores en tiempo de ejecución
o Ofrece descripciones detalladas de cada error, con sus causas y
soluciones más frecuentes.
 Permite convertir el algoritmo de pseudocódigo a código numerosos lenguajes de
programación
 o C, C++, C#, Java, JavaScript, MatLab, Pascal, PHP, Python 2, Python 3,
QBasic Visual Basic
 Ofrece un sistema de ayuda integrado acerca del pseudocódigo 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)
 El Pseudo-código
Las características de este pseudolenguaje fueron propuestas en 2001 por el responsable de la asignatura
Fundamentos de Programación de la carrera de Ingeniería Informática de la FICH-UNL. Las premisas son:

 Sintaxis sencilla

 Manejo de las estructuras básicas de control

 Solo 3 tipos de datos básicos: numérico, caracter /cadenas de caracteres y lógico

(verdadero-falso).

 Estructuras de datos: arreglos

Todo algoritmo en pseudocógido 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 más
instrucciones, cada una terminada en punto y coma.

Las acciones incluyen operaciones de entrada y salida, asignaciones de variables, condicionales si-entonces o
de selección múltiple y/o lazos mientras, repetir o para.
 Asignación

La instrucción de asignación permite almacenar un valor en una variable.

<variable> <- <expresión> ;

Al ejecutarse la asignación, primero se evalúa la expresión de la derecha y luego se asigna el resultado a la

variable de la izquierda. El tipo de la variable y el de la expresión deben coincidir.

Entradas

La instrucción Leer permite ingresar información desde el ambiente.

Leer <variablel> , <variable2> , ... ,
<variableN> ;

Esta instrucción lee N valores desde el ambiente (en este caso el teclado) y los asigna a las N variables
mencionadas. Pueden incluirse una o más variables, por lo tanto el comando leerá uno o más valores.
Salidas

La instrucción Escribir permite mostrar valores al ambiente.

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

Esta instrucción imprime al ambiente (en este caso en la pantalla) los valores obtenidos de evaluar N
expresiones. Dado que puede incluir una o más expresiones, mostrará uno o más valores.
Dimensionamiento

La instrucción Dimension permite definir un arreglo, indicando sus dimensiones.

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

Esta instrucción define un arreglo con el nombre indicado en <indentificador> y N dimensiones. Los N
parámetros indican la cantidad de dimensiones y el valor máximo de cada una de ellas. La cantidad de
dimensiones puede ser una o más, y la máxima cantidad de elementos debe ser una expresión numérica
positiva.
Se pueden definir más de un arreglo en una misma instrucción, separándolos 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 instrucción Si-Entonces-Sino depende del valor de una
condición lógica.
Si <condición>
Entonces
<instrucciones>
Sino
<instrucciones>
FinSi

Al ejecutarse esta instrucción, se evalúa la condición y se ejecutan las instrucciones que correspondan: las
instrucciones que le siguen al Entonces si la condición es verdadera, o las instrucciones que le siguen al Sino
si la condición es falsa. La condición debe ser una expresión lógica, que al ser evaluada retorna Verdadero o
Falso.
La cláusula Entonces debe aparecer siempre, pero la cláusla Sino puede no estar. En ese caso, si la condición
es falsa no se ejecuta ninguna instrucción y la ejecución del programa continúa con la instrucción siguiente.
Selección Multiple

La secuencia de instrucciones ejecutada por una instrucción Según depende del valor de una variable
numérica.
Segun <variable> Hacer
<número1>: <instrucciones>
<número2>,<número3>: <instrucciones>
<...>
De Otro Modo: <instrucciones>
FinSegun
Esta instrucción permite ejecutar opcionalmente varias acciones posibles, dependiendo del valor almacenado
en una variable de tipo numérico. Al ejecutarse, se evalúa el contenido de la variable y se ejecuta la secuencia
de instrucciones asociada con dicho valor.
Cada opción está formada por uno o más números separados por comas, dos puntos y una secuencia de
instrucciones. Si una opción incluye varios números, la secuencia de instrucciones asociada se debe ejecutar
cuando el valor de la variable es uno de esos números.
Opcionalmente, se puede agregar una opción final, denominada De Otro Modo, cuya secuencia de
instrucciones asociada se ejecutará sólo si el valor almacenado en la variable no coincide con ninguna de las
opciones anteriores.
Lazos Mientras

La instrucción Mientras ejecuta una secuencia de instrucciones mientras una condición sea verdadera.
Mientras <condición> Hacer
<instrucciones>
FinMientras

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

La instrucción Repetir-Hasta Que ejecuta una secuencia de instrucciones hasta que la condición sea verdadera.
Repetir
<instrucciones>
 Hasta Que <condición>

Al ejecutarse esta instrucción, la secuencia de instrucciones que forma el cuerpo del ciclo se ejecuta una vez y
luego se evalúa la condición. Si la condición es falsa, el cuerpo del ciclo se ejecuta nuevamente y se vuelve a
evaluar la condición. Esto se repite hasta que la condición sea verdadera.
Note que, dado que la condición se evalúa al final, las instrucciones del cuerpo del ciclo serán ejecutadas al
menos una vez.
Además, a fin de evitar ciclos infinitos, el cuerpo del ciclo debe contener alguna instrucción que modifique la o
las variables involucradas en la condición de modo que en algún momento la condición sea verdadera y se
finalice la ejecución del ciclo.
Lazos Para

La instrucción Para ejecuta una secuencia de instrucciones un número 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 evalúa 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 cláusula Con Paso <paso>, la variable <variable> se incrementará en 1.

Operadores y Funciones
Este pseudolenguaje dispone de un conjunto básico de operadores y funciones que pueden ser utilizados para
la construcción de expresiones más 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

Lógicos

&óY Conjunción (y). (7>4) & (2=1) //falso

|óO Disyunción (o). (1=1 | 2=1) //verdadero

~ ó NO Negación (no). ~(2<5) //falso

Algebraicos

+ Suma total <- cant1 + cant2

- Resta stock <- disp - venta

* Multiplicación area <- base * altura

/ División porc <- 100 * parte / total

^ Potenciación sup <- 3.41 * radio ^ 2

% ó MOD Módulo (resto de la división entera) resto <- num MOD div

La jerarquía de los operadores matemáticos es igual a la del álgebra, aunque puede alterarse mediante el uso
de paréntesis.

A continuación se listan las funciones integradas disponibles:

Función Significado

RC(X) Raíz Cuadrada de X

ABS(X) Valor Absoluto de X

LN(X) Logaritmo Natural de X

EXP(X) Función 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 más cercano a X

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

 Algunas Observaciones
 Se pueden introducir comentarios luego de una instrucción, o en líneas separadas, mediante el
uso de la doble barra ( // ). Todo lo que precede a //, hasta el fin de la línea, 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 sólo de letras y números, comenzando
siempre con una letra, y no pueden ser palabras reservadas (como para, mientras, y, no, etc...)

 Las constantes de tipo carácter se escriben entre comillas ( " ).

 En las constantes numéricas, el punto ( . ) es el separador decimal.

 Las constantes lógicas son Verdadero y Falso.

Ejemplos de algoritmos en PSeudoCodigo

 Suma: Este es el ejemplo más simple. Muestra cómo cargar dos números de dos
variables, calcular la suma de los mismos y mostrarla en pantalla.

// este es el ejemplo más 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 instrucción Escribir, y luego se lee el dato
en
// una variable (A para el primero, B para el segundo)
con
// la instrucción 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 asignación (<-)

C <- A+B
 // finalmente, se muestra el resultado, precedido de un
// mensaje para avisar al usuario, todo en una sola
// instrucción 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 más 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 pseudocódigo se asemeje más
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 básico que ilustra la sintaxis para declarar nuevas funciones
en pseudocódigo.
 // 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 paréntesis vacios

 Escribir "Ingrese un valor numérico para x:"
  Leer x

 Escribir "Llamada a la función CalcularDoble
(pasaje por valor)"
 Escribir "El doble de ",x," es ", CalcularDoble(x)
 Escribir "El valor original de x es ",x

 Escribir "Llamada a la función Triplicar (pasaje
por referencia)"
 Triplicar(x)
 Escribir "El nuevo valor de x es ", x

 FinProceso


 AdivinaNumero: Sencillo juego en el que el usuario debe adivinar un número 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 básico 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

triángulo si corresponden a un triángulo rectángulo (para utiliza la relación de
Pitágoras, 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

 OrdenaLista: Este ejemplo almacena una lista de nombres en un arreglo y luego los
ordena alfabéticamente. El método 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 ingresarán
 // 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 módulo (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
 Menu: Ejemplo simple de menú de opciones, con las estructuras Repetir-Hasta Que
y Segun
 // Muestra como hacer un menú simple con las
estructuras Repetir-Hasta Que y Según

 Proceso sin_titulo
 Repetir
 // mostrar menu
 Limpiar Pantalla
 Escribir "Menú de recomendaciones"
 Escribir " 1. Literatura"
 Escribir " 2. Cine"
 Escribir " 3. Música"
 Escribir " 4. Videojuegos"
 Escribir " 5. Salir"
 // ingresar una opcion
 Escribir "Elija una opción (1-5): "
 Leer OP
 // procesar esa opción
 Segun OP Hacer
 1:
 Escribir "Lecturas recomendables:"
 Escribir " + Esperándolo a Tito y otros
cuentos de fúbol (Eduardo Sacheri)"
 Escribir " + El juego de Ender (Orson
Scott Card)"
 Escribir " + El sueño de los héroes
(Adolfo Bioy Casares)"
 2:
 Escribir "Películas recomendables:"
 Escribir " + Matrix (1999)"
 Escribir " + El último samuray (2003)"
 Escribir " + Cars (2006)"
 3:
 Escribir "Discos recomendables:"
 Escribir " + Despedazado por mil partes
(La Renga, 1996)"
 Escribir " + Búfalo (La Mississippi,
2008)"
 Escribir " + Gaia (Mägo de Oz, 2003)"
 4:
 Escribir "Videojuegos clásicos
recomendables"
 Escribir " + Día del tentáculo
(LucasArts, 1993)"
 Escribir " + Terminal Velocity
(Terminal Reality/3D Realms, 1995)"
 Escribir " + Death Rally
(Remedy/Apogee, 1996)"
 5:
 Escribir "Gracias, vuelva prontos"
  De otro modo:
 Escribir "Opción no válida"
 FinSegun
 Escribir "Presione enter para continuar"
 Esperar Tecla
 Hasta Que OP=5
 FinProceso

 Digitos: Separa los dígitos de un número entero utilizando el operador módulo

 // 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 fórmula resolvente para determinar las raíces de una ecuación
de segundo grado a partir de sus tres coeficientes, y las informa adecuadamente
según 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 números 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

 Factorizacion: Ejemplo de algoritmo para descomponer un número 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

 Cadenas: Muestra la utilización 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 configuración 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 "Posición " 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 función recursiva para calcular una potencia

 // Implementación del cálculo de una potencia mediante
una función 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 cómo 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 animación con códigos ASCII y la instrucción 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 cómo convertir números enteros a notación romana utilizando

arreglos
 Proceso Romanos

 // leer el número
 Escribir "Ingrese un número entre 1 y 1000"
 Leer Numero

 // controlar que sea válido para convertir
 SePuedeConvertir<-Verdadero
 Si Numero=0 Entonces
 Escribir "No existe ningún símbolo para
representar el 0"
 SePuedeConvertir<-Falso
 FinSi
 Si Numero<>trunc(numero) Entonces
 Escribir "El número 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 conversión
 Si SePuedeConvertir Entonces
 Si Numero=1000 Entonces
 Escribir "M"
 Sino
  Dimension nu[10], nd[10], nc[10] //
notación 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 pseudocódigo

 // 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 tamaño sobre otro mas chico

 // Hay una matriz que representa las torres, cada
columna contiene
 // nros que representan los tamaños 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 posición para colocar la ficha y
la valida
 Escribir "Ingrese la Posición (1-9):"

 Repetir
 Leer Pos
 Si Pos<1 o Pos>9 Entonces
 Escribir "Posición 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 "Posición 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