ESTRUCTURA DE PROGRAMAS EN PASCAL Y PSEINT

PASCAL

Las cinco secciones de declaración -Label, Const, Type y Procedure y/o Function , así como la cláusula Uses y Program, no tiene que estar presentes en todos los programas. Turbo Pascal es muy flexible al momento de escribir las secciones de declaración, ya que se pueden hacer en cualquier orden (en Pascal estándar ISO si se require este orden). Sin embargo es conveniente seguir el orden establecido, le evitará futuros problemas.
Ejemplo:

Program MiPrimerPrograma;   ____________________________{cabecera}
Uses 
  Crt; _________________________________________________{declaraciones}
Const
  iva =0.10;
Type
  cadena =string[35];
  meses  =1..12;
Var ___________________________________________________{declarador vareables}
  sueldo :real;
  numero :integer;_____________________________________{variables de carácter int}
  nombre :cadena;
  Nmes   :meses;
begin
  ClrScr; ______________________________________________{Limpia la pantalla} 

  Write ('Escribe tu nombre : ');_______________________{Visualiza información en pantalla} 

  ReadLn(nombre);_______________________________________{Leer un dato del teclado}

  WriteLn ('Bienvenido ', nombre);______________________ {Visualiza información en pantalla} 

  Readkey; ______________________________________________{Espera la pulsación de una tecla}

  ClrScr;________________________________________________{limpiar pantalla}

end.  ___________________________________________________{fin del programa}

A CONTINUACIÓN SE LE PRESENTA UN LISTADO DE PALABRAS 

RESERVADAS EN PASCAL

Las reglas de estructura que se deben seguir siempre que se escriban
programas en PASCAL es la siguiente:


program

 identificador {cabecera del programa}

uses 

identificadores

label lista de etiquetas {sección de etiquetas}

const

 definición de constantes

type
 declaración de tipos de datos definidos por el usuario

var
 declaración de variables

procedure
definición de procedimientos

function
definición de funciones

begin
sentencias {cuerpo del programa}

end. 

Tipos caracter (Char)
El tipo char es un tipo de datos que puede contener un solo caracter. Un
literal char se debe encerrar entre simples apóstrofos (sin embargo, no se
puede utilizar apóstrofos cuando se introducen caracteres desde la Terminal).
Algunos ejemplos son los siguientes:
‘Z’ ‘x’ ‘$’ ‘3’ ‘<’ ‘¿’ ‘ ‘ ‘12’ ‘^’ ‘_’ ‘ - ‘
Un caracter se almacena en memoria como un solo byte.
Tipos lógicos (boolean)
 Los valores de tipo lógico pueden tomar sólo dos valores posibles: true
(verdadero) y false (falso). Al igual que el tipo char, el tipo boolean es un tipo
ordinal, que significa que tiene un número fijo de posibles valores que existen
en un orden definido. Ocupa un solo byte en memoria. La relación es:
false < true
Tipos cadena (string)
Un tipo string (cadena) es una secuencia de caracteres de cero o más
cararcteres, escrita en una línea sobre el programa y encerrado entre
apóstrofos. Ejemplos:
 ‘ ‘ ‘Laura’ ‘hola, mundo’ ‘ ; ‘
Una cadena sin algo entre los apóstrofos se llama cadena nula o cadena
vacía.
La longitud de una cadena es el número de caracteres encerrados entre
los apóstrofos.
En cuanto al orden de evaluación de expresiones aritméticas (la
prioridad), al aparecer dos o más operadores, ¿qué operación se realiza
primero? Esto se refiere a cuál es el orden de prioridad (jerarquía) de las
operaciones aritméticas. Veamos la siguiente tabla que resume las reglas de
evaluación de expresiones. 

En este capítulo tenéis un listado de las palabras reservadas del pascal orientado a objetos. Las palabras reservadas son identificadores, pero como su nombre indica, estas palabras están reservadas, y no se pueden usar como identificadores de usuario.


absolute
abstract
alias
and
array
as
asm
assembler
begin
break
case
cdecl
class
const
constructor
continue
default
destructor
dispose
div


do
downto
else
end
except
exit
export
exports
external
false
far
file
finalization
finally
for
forward
function
goto
if
implementation


in
index
inherited
initialization
inline
interface
is
label
library
mod
name
near
new
nil
not
object
of
on
on
operator


or
override
packed
pascal
popstack
private
procedure
program
property
protected
public
published
raise
read
record
register
repeat
saveregisters
self
set


















shl
shr
stdcall
string
then
to
true
try
type
unit
until
uses
var
virtual
while
with
xor



A CONTINUACIÓN TE PRESENTAMOS UN PROGRAMA DONDE TE DARAS

 CUENTA DONDE USAMOS ESAS

 PALABRAS RESERVADAS

VE ESTE VIDEO TE PUEDE SERVIR PARA ENTENDER MEJOR

SUMA DE NUMEROSA PASCAL

PSEINT

Condicionales 

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.
   El ejemplo Triangulo lee las medidas de los tres lados de un triángulo y utiliza esta estructura para determinar cual es el mayor de los tres, y verificar luego si se trata de un triángulo rectángulo o no.

Selección Multiple 

   La secuencia de instrucciones ejecutada por una instrucción Segun 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.

Repetitivas

Lazos Mientras 

   La instrucción Mientras ejecuta una secuencia de instrucciones mientras una condición sea verdadera. 
      Mientras <condición> Hacer 
            <instrucciones> 
      FinMientras 
vAl 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.
   El ejemplo AdivinaNumero le da al usuario 10 intentos para adivinar un número generado aleatoriamente, utilizando esta estructura para verificar si el usuario acierta el número o si se agotan los intentos.

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.
   Si se utiliza sintaxis flexible (ver Opciones del PSeudocódigo) se permite opcionalmente utilizar Mientras Que en lugar de Hasta Que, de modo que el conjunto de acciones contenidas en el bucle se ejecuta mientras que la condición sea verdadera. Notar que la palabra Que es la que diferencia el uso de la palabra Mientras en la estructura repetir de la estructura Mientras. Es decir, si se omite la palabra que se considera como el comienzo de un bucle Mientras en lugar de el final de un bucle Repetir.

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.
   Si se habilita la sintaxis flexible en las configuración del lenguaje se pueden utilizar dos alternativas. La primer variante consiste en reemplazar el operador de asignación por la palabra clave Desde:
      Para <variable> Desde <inicial> Hasta <final> Con Paso <paso> Hacer ... 
De esta forma, la lectura de la sentencia resulta más obvia. Además, con sintaxis flexible, si no se especifica el paso pero el valor final es menor al inicial, el bucle recorrerá los valores en orden inverso como si el paso fuera -1. La segunda variante solo sirve para recorrer arreglos de una o más dimensiones. Se introduce con la construcción Para Cada seguida de un identificador, la palabra clave De y otro identificador:
      Para Cada <elemento> De <Arreglo> Hacer ... 
El segundo identificador debe corresponder a un arreglo. El primero será el que irá variando en cada iteración. El ciclo realizará tantas iteraciones como elementos contenga el arreglo y en cada uno el primer identificador servirá para refererirse al elemento del arreglo en cuestión.
   El ejemplo Promedio utiliza un bucle de este tipo para leer N valores numéricos con los cuales calcula un promedio.
   El ejemplo Para utiliza las tres variantes de este tipo de bucles para recorrer un arreglo.

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 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 una 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 Segun 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 Logicos & ó 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.

A CONTINUACIÓN SE MUESTRA UN VIDEO COMO DONDE USA LAS 
VARIABLES DE PSEINT

"GRACIAS POR VISITAR MI BLOG"

IR AL MENÚ