Para qu sirve PSeInt?

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

Caractersticas y Funcionalidades de PSeInt:

Presenta herramientas de edicin bsicas para escribir algoritmos en pseudocodigo en espaol Permite la edicin simultnea de mltiple algoritmos Presenta ayudas para la escritura o Autocompletado o Ayudas Emergentes o Plantillas de Comandos o Coloreado de Sintaxis o Indentado Inteligente Puede ejecutar los algoritmos escritos Permite ejecutar el algoritmo paso a paso controlando la velocidad e inspeccionando expresiones Puede confeccionar automticamente la tabla de prueba de escritorio Determina y marca los errores de sintaxis y en tiempo de ejecucin Genera diagramas de flujo a partir del algoritmo escrito Convierte el algoritmo de pseudocodigo a cdigo C++ Ofrece un sistema de ayuda integrado acerca del pseudocdigo y el uso del programa (esta ltima, an en construccin) Incluye un conjunto de ejemplos de diferentes niveles de dificultad Es multiplataforma (probado en Microsoft Windows y GNU/Linux) Es totalmente libre y gratuito (licencia GPL)

El Pseudo-cdigo

Las caractersticas del este pseudolenguaje fueron propuestas en 2001 por el responsable de la asignatura Fundamentos de Programacin (Horacio Loyarte) 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 un 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 Relacionales > Mayor que < Menor que = Igual que <= Menor o igual que >= Mayor o igual que Lgicos & Conjuncin (y). | Disyuncin (o). ~ Negacin (no). Algebraicos + Suma * Multiplicacin / Divisin ^ Potenciacin

Ejemplo
3>2 'ABC'<'abc' 4=3 'a'<='b' 4>=5 (7>4) & (2=1) //falso (1=1 | 2=1) //verdadero ~(2<5) //falso

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
RC(X) ABS(X) LN(X) EXP(X) SEN(X) COS(X) ATAN(X)

Significado
Raz Cuadrada de X Valor Absoluto de X Logaritmo Natural de X Funcin Exponencial de X Seno de X Coseno de X Arcotangente de X

TRUNC(X) Parte entera de X REDON(X) Entero ms cercano a X

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. Note que no puede haber instrucciones fuera del programa, aunque si comentarios.

Algunas Observaciones

 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. Las constantes de tipo carcter se escriben entre comillas ( " ). En las constantes numricas, el punto ( . ) es el separador decimal. Las constantes lgicas son Verdadero y Falso.

Ejemplos de algoritmos en PSeudoCodigo

AdivinaNumero: simple juego en el que hay que adivinar un nro aleatorio entre 1 y 100 en menos de 10 intentos. Factorizacin: descompone un nmero en sus factores primos. Hanoi: juego de las torres de Hanoi, donde se deben mover discos entre tres torres cumpliendo ciertas limitaciones, hasta colocarlos todos en la ltima torre. Matematicas: presenta un men que permite realizar diferentes operaciones matemticas sobre un nmero (funciones trigonomtricas, calcular valor absoluto, truncar, determinar si es primo, hallar el factorial, hallar la raz cuadrada, etc.). OrdenaLista: ordena una lista de nombres alfabticamente. Promedio: calcula el promedio de una lista de datos. Resolvente: calcula e informa las races de una ecuacin de cuadrtica, considerando los tres casos (reales iguales, reales distintas, o complejas conjugadas). Sucursales: se obtienen datos acerca de las ventas de una empresa ingresando las cantidades vendidas por artculo y sucursal, junto con el listado de precios. Triangulo: calcula el rea de un tringulo rectngulo, verificando primero que lo sea mediante el teorema de Pitgoras.

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 & 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 & 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) & 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 | 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 | t1>3 | t2<0 | 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_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"; 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 matemticas 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 & 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 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 ~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 recaudacin total de cada sucursal.

// * La recaudacin total de la empresa. // * La sucursal de mayor recaudacin. 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