Para que 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.

Caracteristicas y Funcionalidades de PSeInt:
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 Indentado Inteligente
Permite generar y editar el diagrama de flujo del algoritmo
Permite la edicin simultnea de mltiple algoritmos
El lenguaje pseudocdigo utilizado es configurable
o Ofrece perfiles de configuracin predefinidos para numerosas instituciones
Puede interpretar (ejecutar) los algoritmos escritos
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
Determina y marca claramente errores de sintaxis (mientras escribe) y en tiempo de
ejecucion
Permite convertir el algoritmo de pseudocodigo a cdigo C++
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 GPL)
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.
AdivinaNumero.psc

// Juego simple que pide al usuario que adivine un numero en 10 intentos

Proceso Adivina_Numero

intentos<-9;
num_secreto <- azar(100)+1;

Escribir "Adivine el numero (de 1 a 100):";
Leer num_ingresado;
Mientras num_secreto<>num_ingresado Y intentos>0 Hacer
Si num_secreto>num_ingresado Entonces
Escribir "Muy bajo";
Sino
Escribir "Muy alto";
FinSi
Escribir "Le quedan ",intentos," intentos:";
Leer num_ingresado;
intentos <- intentos-1;
FinMientras

Si intentos=0 Entonces
Escribir "El numero era: ",num_secreto;
Sino
Escribir "Exacto! Usted adivino en ",11-intentos,"
intentos.";
FinSi

FinProceso

Factorizacion.psc
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
Hanoi.psc

// 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-5):";
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

cant_movs<-0;

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

para i<-1 hasta 3 Hacer // dibujar las tres
torres
escribir "";
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<0 O t1>3 O t2<0 O t2>3 Entonces //
controlar que el nro de torre sea valido
escribir "Movimiento invalido";
sino
si cant_discos[t1]=0 Entonces //
controlar que la torre 1 tengo al menos un disco
escribir "Movimiento
invalido";
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
discos mas grandes
si
torres[t2,cant_discos[t2]]<disco_a_mover Entonces
puede_m
over<-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_di
scos[t2]] <- disco_a_mover;
cant_discos[t1]<-
cant_discos[t1]-1;
Sino
escribir
"Movimiento invalido";
finsi
FinSi
finsi

finmientras

// mostrar resultado
escribir "";
escribir "";
escribir "Juego finalizado en ",cant_movs,"
movimientos!";
escribir "";

FinProceso
Matematicas.psc

// Este ejemplo muestra el uso de expresiones, operadores y
funciones matematicas

Proceso Matematicas
Salir<-0;
Escribir 'Ingresar Numero:';
Leer N;
Repetir
Escribir ' ';
Escribir 'Presione Enter para continuar';
Leer x;
Escribir '1 - Seno, Coseno, ArcoTangente';
Escribir '2 - Lograritmo Natural, Funcion Exponencial';
Escribir '3 - Truncar, Redondear';
Escribir '4 - Raiz Cuadrada';
Escribir '5 - Valor Absoluto';
Escribir '6 - Separar parte entera y decimal';
Escribir '7 - Hallar Factorial';
Escribir '8 - Averiguar si es primo';
Escribir '9 - Ingresar Otro Numero';
Escribir ' ';
Escribir '0 - para Salir';
Escribir ' ';
Leer Opcion;
Segun Opcion Hacer
1:
Escribir 'Seno:',Sen(N);
Escribir 'Coseno:',Cos(N);
Escribir 'ArcTangente:',Atan(N);
2:
Si N<=0
Entonces Escribir 'El numero debe ser mayor a
cero!';
Sino
Escribir 'Log Nat.:',ln(N);
Escribir 'Func Expon.:',exp(N);
FinSi
3:
Escribir 'Turncar:',trunc(N);
Escribir 'Redondear:',redon(N);
4: Escribir 'Raiz Cuad.:',rc(N);
5: Escribir 'Valor Abs.:',abs(N);
6:
Escribir 'Parte Entera:',Trunc(n);
Escribir 'Parte Decimal:',n-Trunc(n);
7:
Si N<>Trunc(N)
Entonces
Escribir 'El numero debe ser entero!';
Sino
Si abs(N)>50
Entonces Escribir 'Resultado muy grande!';
Sino
r<-1; f<-1;
Mientras f<=abs(N) Hacer
Si N<0
Entonces r<-(-f)*r;
Sino r<-f*r;
FinSi
f<-f+1;
FinMientras
Escribir 'Factorial:',r;
FinSi
FinSi
8:
Si N<>Trunc(N)
Entonces
Escribir 'El numero debe ser entero!';
Sino
Primo<-'Si';
Si N/2=trunc(N/2)
Entonces
Primo<-'No';
FinSi
Si N<0
entonces Nu<-N*-1;
sino Nu<-N;
FinSi
Nu<-RC(Nu);
f<-3;
Mientras f<=Nu Y Primo='Si' Hacer
Si N/F=trunc(N/F)
Entonces Primo<-'No';
FinSi
f<-f+2;
FinMientras
Escribir 'Numero Primo:',Primo;
Si f=3
Entonces F<-4;
FinSi
Si Primo='No'
Entonces
Escribir N,'=',f-2,'x',N/(f-2);
FinSi
FinSi
9:
Escribir 'Ingrese Numero:';
Leer N;
0: Salir<-1;
De Otro Modo:
Escribir 'Opcion No Valida!';
FinSegun
Hasta que Salir=1
FinProceso
Mayores.psc

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

Proceso Mayores

Dimension datos[200];

Escribir "Ingrese la cantidad de datos:";
Leer n;

Para i<-1 Hasta n Hacer
Escribir "Ingrese el dato ",i,":";
Leer datos[i];
FinPara


Si datos[1]>datos[2] Entonces
may1<-datos[1];
may2<-datos[2];
Sino
may1<-datos[2];
may2<-datos[1];
FinSi

Para i<-3 Hasta n Hacer
Si datos[i]>may1 Entonces
may2<-may1;
may1<-datos[i];
Sino
Si datos[i]>may2 Entonces
may2<-datos[i];
FinSi
FinSi
FinPara


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

FinProceso
Modulo.psc
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
OrdenaLista.psc

// 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
Promedio.psc

// 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
Resolvente.psc

// 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
Sucursales.psc

// Problema Ejemplo:

// Se ingresan los precios de 5 articulos y las cantidades vendidas
// por una empresa en sus 4 sucursales. Informar:
// * Las cantidades totales de cada articulo.
// * La cantidad de articulos en la sucursal 2.
// * La cantidad del articulo 3 en la sucursal 1.
// * La recaudacion total de cada sucursal.
// * La recaudacion total de la empresa.
// * La sucursal de mayor recaudacion.

Proceso Sucursales

// Inicializar Prec=Arreglo de precios y Cant=Arreglo para cantidades
Dimension Prec[5], Cant[4,5];

// Leer Precios
Para I<-1 Hasta 5 Hacer
Escribir 'Ingrese Precio Articulo ',I,':';
Leer Prec[I];
FinPara

// Leer Cantidades
Para J<-1 Hasta 4 Hacer
Para I<-1 Hasta 5 Hacer
Escribir 'Ingrese Cant. de Articulo ',I,', en Sucursal ',J,':';
Leer Cant[J,I];
FinPara
FinPara

// Sumar cantidades por articulos
Escribir 'Cantidades por articulos:';
Para I<-1 Hasta 5 Hacer
Suma<-Cant[1,I]+Cant[2,I]+Cant[3,I]+Cant[4,I];
Escribir 'Total articulo ',I,':',Suma;
FinPara

// Informar Total de Articulos Sucursal 2
Suc2<-0;
Para I<-1 Hasta 5 Hacer
Suc2<-Suc2+Cant[2,I];
FinPara
Escribir 'Total Sucursal 2:',Suc2;

// Informar Sucursal 1, Articulo 3:
Escribir 'Sucursal 1, Articulo 3:',Cant[1,3];


// Acumular total de cada sucursal (TotSuc) y
// total de la empresa (TotEmp)
MayorRec<-0; NumMayor<-0; TotEmp<-0;
Para J<-1 Hasta 4 Hacer
TotSuc<-0;
Para I<-1 Hasta 5 Hacer
TotSuc<-TotSuc+(Cant[J,I]*Prec[i]);
FinPara
Escribir 'Recaudaciones Sucursal ',J,':',TotSuc;
Si TotSuc>MayorRec
entonces MayorRec<-TotSuc; NumMayor<-J;
FinSi
TotEmp<-TotEmp+TotSuc;
FinPara
Escribir 'Recaudacion total de la empresa:',TotEmp;
Escribir 'Sucursal de Mayor Recaudacion:',NumMayor;

FinProceso
Triangulo.psc

// 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