Información importante para docentes usuarios de PSeInt PSeInt permite personalizar algunos aspectos del lenguaje. Para evitar confusión en los alumnos, la idea es que la primera vez que se ejecute el programa, solicite al estudiante elegir un "perfil de configuración" para su universidad/facultad/carrera, definiendo rápidamente y en un solo paso la configuración del lenguaje de acuerdo a las exigencias de su docente. Este mensaje es para solicitar a los docentes que envíen sus perfiles para agregarlos a la lista. Para ello, deben realizar los siguientes pasos: 1. Ejecute PSeInt (asegúrese de haber instalado la última versión). 2. Seleccione el ítem "Opciones del Lenguaje (perfiles)" del menú "Configurar". 3. En el cuadro de diálogo que aparece, haga click en "Personalizar". 4. En el nuevo cuadro de diálogo que aparece, configure el perfil como lo desee. 5. Haga click en el segundo botón de la esquina inferior izquierda del cuadro de diálogo (el que muestra un disquete) para guardar el perfil en un archivo. 6. Seleccione una ubicación cualquiera para el archivo e introduzca una breve descripción del perfil (se recomienda mencionar la institución donde se utiliza, la cátedra o carrera, y el nombre del docente responsable o de quien envía el perfil). 7. Envíe el archivo por email a zaskar_84
yahoo.com.ar. En el correo incluyan además del archivo generado e información de la cátedra donde lo utilizan (nombre de la universidad y facultad o instituto, nombre de la carrera, nombre de la cátedra/materia, docente responsable de la misma, y qué lenguaje de programación real utilizan en las clases luego de la etapa de pseudocódigo). Además, cada perfil se muestra con un pequeño ícono de 24x24px, que tomaré del favicon del sitio web de la institución a menos que sugieran o envíen otro (tengan en cuenta que si el logo de la institución es muy complejo, al reducirlo a 24x24 puede que ya no se reconozca). Si creen que sería util agregar otras personalizaciones además de las ya implementadas no duden en sugerirlo.
A continuación 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; Dimension ARREGLO[100]; Escribir "Ingrese la cantidad de
Escribir "Ingrese la cantidad de numeros:" Leer CANT
numeros:"; Leer CANT; Para I<-0 Hasta CANT-1 Hacer Escribir "Ingrese un numero:"; Leer ARREGLO[I]; FinPara VAL_MAYOR<-0; Para I<-0 Hasta CANT-1 Hacer ARREGLO[I]>VAL_MAYOR Si ARREGLO[I]>VAL_MAYOR Entonces ARREGLO[i]; ARREGLO[i]; VAL_MAYOR
Entonces Si VAL_MAYOR % 2 = 0 Entonces Escribir "El mayor es ",VAL_MAYOR," y es par"; Sino Escribir "El mayor es ",VAL_MAYOR," y es impar"; FinSi FinProceso
Dimension ARREGLO[CANT] Para Cada Elemento de ARREGLO Escribir "Ingrese un numero:" Leer ELEMENTO Fin Para VAL_MAYOR<-0 Para Cada ELEMENTO de ARREGLO Si ELEMENTO Es Mayor Que VAL_MAYOR VAL_MAYOR<-ELEMENTO Fin Si Fin Para
Es Par Si VAL_MAYOR Es Escribir "El mayor es " VAL_MAYOR " y es par" Sino Escribir "El mayor es " VAL_MAYOR " y es impar" Fin Si FinAlgoritmo
¿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 ademas algunas herramientas adicionales que le ayuden a encontrar errores y comprender la lógica de los algoritmos.
Características y Funcionalidades de PSeInt: Puede encontrar en este enlace un resúmen rápido y gráfico de las principales funcionalidades.
Presenta herramientas de edición para escribir algoritmos en pseudocodigo 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
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 ejecucion
o
Ofrece descripciones detalladas de cada error, con sus causas y soluciones más frecuentes.
Permite convertir el algoritmo de pseudocodigo 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
Ofrece perfiles de configuración predefinidos para numerosas instituciones
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 pseudocódigo pese más la parte pseudo que la de código. Para ello se han agregado posibles sinónimos, sintaxis alternativas o versiones incompletas de algunas construcciones en pos de desrigidizar el pseudolenguaje utilizado, siempre y cuando no se caiga en ninguna ambigüedad respecto a su interpretación. Actualmente, el intérprete puede configurarse para obligar al alumno a respetar completamente la sintaxis original, aceptar las variaciones, o algunos grados intermedios (ver perfiles para una comparación entre dos versiones de un mismo algoritmo).
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 l a 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 una valor en una variable. <- ;
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 , , ... , ;
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 , , ... , ;
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 (,...,);
Esta instrucción define un arreglo con el nombre indicado en 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 (,...,),..., (,...,)
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 Entonces Sino 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 Segun depende del valor de una variable numérica. Segun Hacer : ,: <...> De Otro Modo: FinSegun
Esta instrucción permite ejecutar opcionalmente varias acc iones 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 m ientras una condición sea verdadera. Mientras Hacer
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 Hasta Que
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 c ondició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 <- Hasta ( Con Paso ) Hacer FinPara
Al ingresar al bloque, la variable recibe el valor y se ejecuta la secuencia de instrucciones que forma el cuerpo del ciclo. Luego se incrementa la variable en unidades y se evalúa si el valor almacenado en superó al valor . S i esto es falso se repite hasta que supere a . Si se omite la cláusula Con Paso , la 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 totali dad 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
&ó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
Logicos
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
Módulo (resto de la división entera)
resto <- num MOD div
% ó MOD
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
Ejercicios Ejemplos de algoritmos en PSeudoCodigo En esta sección puede observar ejemplos de pseudocódigos válidos en PSeInt, así como también 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 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
Adivina Numero: 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
Ordena Lista: 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]
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
Menú: Ejemplo simple de menú de opciones, con las estructuras Repetir-Hasta Que y Según // 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
Dígitos: 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
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
Factorización: 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 FinProceso
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 como 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 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]]
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
Calculadora Básica (PSeInt) Calculadora nº1
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 nº2
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;
