Vous êtes sur la page 1sur 110

Algoritmos en PSeInt

Jfferson Beltrn Morales

Algoritmos en PSeInt

Algoritmos
en
PSeInt

Jfferson Beltrn Morales

Jfferson Beltrn Morales

Algoritmos en PSeInt.
Todos los derechos reservados. No est permitida la reproduccin total o parcial
de este libro, ni su tratamiento informtico, ni la transmisin de ninguna forma o
por cualquier medio, ya sea electrnico, mecnico, por fotocopia u otros
mtodos, sin el permiso previo y por escrito del titular del Copyright.
Copyright 2015. Jfferson Beltrn Morales.
ISBN- 978-9942-21-557-4
Septiembre 2015
Quito Ecuador

Algoritmos en PSeInt

CONTENIDO
INTRODUCCIN. .............................................................................................. 6
OBJETIVO.......................................................................................................... 6
EL LIBRO COMO HERRAMIENTA DOCENTE.................................................. 6
ORGANIZACIN DEL LIBRO. ........................................................................... 6
ACERCA DEL AUTOR. ...................................................................................... 7
PARTE I: ALGORITMOS.................................................................................... 8
1

ALGORITMOS. ............................................................................................ 8
1.1

CARACTERSTICAS DE LOS ALGORITMOS. ..................................... 8

1.2

PARTES DE UN ALGORITMO. ............................................................ 8

1.2.1 DATOS Y TIPOS DE DATOS. .............................................................. 8


1.2.2 CONSTANTES Y VARIABLES. ............................................................ 9
1.2.3 SENTENCIAS O INSTRUCCIONES. .................................................... 9
1.2.4 OPERADORES Y EXPRESIONES. ...................................................... 9
1.2.5 ESTRUCTURAS DE CONTROL. ........................................................ 11
1.3
1.4

PASOS PARA CREAR UN ALGORITMO. .......................................... 11


REPRESENTACIN GRFICA DE LOS ALGORITMOS. ..................... 12

1.4.1 DESCRIPCIN NARRADA. ................................................................ 12


1.4.2 DIAGRAMAS DE FLUJO O FLUJOGRAMAS. .................................... 12
1.4.3 PSEUDOCDIGO............................................................................... 14
1.5

PSEINT. .............................................................................................. 14

PARTE II: ALGORITMOS EN PSeInt. .............................................................. 16


2

PROGRAMACIN ESTRUCTURADA....................................................... 16
2.1

ESTRUCTURA SECUENCIAL. ........................................................... 23

2.2

ESTRUCTURAS SELECTIVAS O CONDICIONALES. ....................... 26

2.2.1 ESTRUCTURA SELECTIVA SI-ENTONCES. .................................. 27


2.2.1.1

EXPRESIONES LGICAS. .......................................................... 31

2.2.1.2

ESTRUCTURAS ANIDADAS........................................................ 35

2.2.2 ESTRUCTURA DE SELECCIN MLTIPLE SEGN...................... 40


2.3

ESTRUCTURAS REPETITIVAS O ITERATIVAS. .............................. 45

2.3.1 ESTRUCTURA REPETITIVA PARA. ................................................ 46

Jfferson Beltrn Morales

2.3.1.1

CONTADOR. ................................................................................ 47

2.3.1.2

ACUMULADOR O TOTALIZADOR. ............................................. 47

2.3.2 ESTRUCTURA ITERATIVA MIENTRAS. ......................................... 50


2.3.2.1

CENTINELAS. .............................................................................. 53

2.3.2.2

BANDERAS. ................................................................................. 55

2.3.3 ESTRUCTURA ITERATIVA REPETIR. ............................................ 58


2.4

ESTRUCTURA DE DATOS Y ARREGLOS............................................ 63

2.4.1 ESTRUCTURA DE DATOS. ............................................................... 64


2.4.2 ARREGLOS. ....................................................................................... 64
2.4.2.1

ARREGLO UNIDIMENSIONAL. ................................................... 68

2.4.2.1.1

PARTES DE UN ARREGLO. .................................................... 68

2.4.2.1.2

OPERACIONES CON ARREGLOS. ......................................... 69

2.4.3 ARREGLO BIDIMENSIONAL. ............................................................. 78


2.5

MODULARIDAD. .................................................................................... 82

2.5.1 PROCEDIMIENTOS Y FUNCIONES. ................................................. 83


2.5.1.1

IMPLEMENTACIN DE PROCEDIMIENTOS Y FUNCIONES..... 84

2.6

RECURSIVIDAD. ................................................................................. 102

2.7

ESTILO DE PROGRAMACIN. ........................................................... 108

BIBLIOGRAFA. ............................................................................................. 110

Algoritmos en PSeInt

ALGORITMOS EN PSeInt
INTRODUCCIN.
Este libro muestra al estudiante y futuro programador, los conceptos bsicos y
fundamentos de los algoritmos computacionales, mediante el diseo y
elaboracin de algoritmos bsicos y sencillos que se presentan comnmente en
el proceso de aprendizaje, utilizando tcnicas algortmicas estructuradas y
modulares, como pseudocdigo y diagramas de flujo y herramientas
especializadas, y de esta manera entender de manera ms sencilla el fascinante
mundo de la algoritmia y programacin. Ya que un programador, es decir, la
persona que disea y construye sistemas computacionales o aplicaciones de
software, antes de comenzar a interactuar con la computadora, tiene que
aprender a pensar diferente a las dems personas, para poder analizar y resolver
problemas mediante aplicaciones de software, los cuales primero debe
plasmarlos en papel o en alguna herramienta de software especfica para ello
como PSeInt, para luego implementarlos en un lenguaje de programacin.

OBJETIVO.
El objetivo del libro es servir como material de lectura y estudio en un curso
introductorio a la programacin, mostrando los fundamentos de los algoritmos
computacionales mediante tcnicas de programacin estructurada y modular,
usando PSeInt como herramienta para el diseo de algoritmos en pseudocdigo
y/o diagramas de flujos.

EL LIBRO COMO HERRAMIENTA DOCENTE.


El libro es una gua y aporte sobre los fundamentos de algoritmos
computacionales para los docentes de Programacin I, de las carreras de
Ingeniera Informtica, Ingeniera Matemtica, Ingeniera en Computacin
Grfica e Ingeniera en Diseo Industrial de la Universidad Central del Ecuador.
Puede ser extendido su uso en otras materias introductorias a la
programacin y algoritmos, pues las bases de la algoritmia son similares, est
pensando su uso para la mitad de un semestre de un primer curso de
programacin, no pretende ser un manual de PSeInt, sino una gua prctica para
el diseo de algoritmos mediante ejemplos, usando pseudocdigo y diagramas
de flujo en PSeInt, mediante tcnicas de programacin estructurada y modular.
La bibliografa principal se tom del sitio web del desarrollador de PSeInt [14].

ORGANIZACIN DEL LIBRO.


El libro se dividi en dos partes para efecto de un estudio gradual y de fcil
lectura. Se inicia enunciando conceptos bsicos sobre algoritmos

Jfferson Beltrn Morales

computacionales, para luego ponerlos en prctica en la segunda parte, con el


diseo de algoritmos usando tcnicas de programacin estructurada y modular.
Se incluyen ejemplos en pseudocdigo y diagramas de flujo escritos en PSeInt.

ACERCA DEL AUTOR.


El autor tiene 15 aos de experiencia como docente universitario en materias
relacionadas a la matemtica aplicada y al desarrollo de software. En el mismo
nmero de aos, es responsable del Desarrollo de Software y de la Gestin de
Tecnologa de Informacin y Comunicaciones en empresas privadas.

Algoritmos en PSeInt

PARTE I: ALGORITMOS.

1 ALGORITMOS.
Un algoritmo es un mtodo para resolver un problema mediante una serie de
pasos precisos, definidos y finitos. Es un conjunto de reglas para resolver
determinado problema, describiendo de forma lgica su solucin. Cada una de
las acciones de que consta un algoritmo computacional se denomina sentencia
(instrucciones o acciones) y stas deben ser escritas en trminos de cierto
lenguaje comprensible para el computador, que es el lenguaje de programacin.
1.1 CARACTERSTICAS DE LOS ALGORITMOS.
Las caractersticas que debe satisfacer un algoritmo computacional son:

Entrada. Son cero o ms parmetros (datos) que ingresan al algoritmo


para ser usados dentro de l.
Salida. Al menos un dato es producido como salida del algoritmo.
Exactitud/precisin. Cada instruccin debe ser clara y sin ambigedad
(hacen lo que deben hacer).
Finito. Terminar despus de un nmero finito de pasos.
Eficiente. Cada instruccin puede ser verificada por una persona con una
prueba manual que satisfaga los requerimientos planteados por el
problema.
Repetible. Dada una misma entrada, siempre debe dar la misma salida.

1.2 PARTES DE UN ALGORITMO.


Los algoritmos computacionales se construyen utilizando un pseudolenguaje que
usa elementos simples para su escritura, centrando la atencin en los conceptos
de la algoritmia computacional, antes que en la dificultad propia de un lenguaje
de programacin. Entre ellos se tienen:
1.2.1 DATOS Y TIPOS DE DATOS.
Las diferencias piezas de informacin con las que un algoritmo computacional
trabaja se conoce colectivamente como datos. Todos los datos tienen un
tipo asociado con ellos, que determina la naturaleza del conjunto de valores
que puede tomar. Por ejemplo, un dato puede ser un simple carcter, tal como
B, un valor entero como 36, un nmero real como 5.75, una cadena de
caracteres como Hola Mundo, un valor de verdad como Verdadero o Falso,
entre otros.

Jfferson Beltrn Morales

1.2.2 CONSTANTES Y VARIABLES.


Los algoritmos computacionales y programas necesitan almacenar datos
temporalmente para poder procesarlos y generar as la salida esperada. Estos
datos, a grandes rasgos, pueden clasificarse en dos grupos:

A un dato cuyo valor no puede cambiar (se mantiene constante) durante


la ejecucin de un programa se lo denomina Constante. Las constantes
deben ser declaradas y asignadas un valor antes de su utilizacin.
En cambio, los datos de un programa cuyo valor puede cambiar durante
la ejecucin del mismo se conocen como Variables. Una variable es, en
realidad, una posicin o localidad de memoria donde se puede almacenar
informacin, tiene un nombre (Nombre de la Variable), y almacena un
valor (Valor de la Variable). Existen tantos tipos de variables como tipos
de datos diferentes.

1.2.3 SENTENCIAS O INSTRUCCIONES.


Las sentencias describen acciones algortmicas que pueden ser ejecutadas. En
general, las sentencias se clasifican en ejecutables (especifican, por ejemplo,
operaciones de clculos aritmticos y entradas/salidas de datos) y no
ejecutables (no realizan acciones concretas ni afectan a la ejecucin del
programa, sino que ayudan a su legibilidad) como la declaracin de variables.
Las sentencias se clasifican, segn su tipo y nmero, en:

Sentencias simples: Son sentencias que no contiene ninguna otra


sentencia. El ejemplo ms tpico de sentencia simple, es la sentencia de
asignacin, la cual se utiliza para almacenar un valor en una variable. La
operacin de asignacin suele representarse en pseudocdigo con el
smbolo , para denotar que el valor situado a su derecha se almacena
en la variable situada a la izquierda:
o variable Valor
o Ejemplo: suma0 (la asignacin slo ser vlida si el valor es
vlido para el tipo de dato definido para la variable).
Otros ejemplos de sentencias simples son las de entrada/salida.

Sentencias estructuradas: Son sentencias compuestas de otras


sentencias que se ejecutan en secuencia, condicionalmente o
repetidamente.

1.2.4 OPERADORES Y EXPRESIONES.

Algoritmos en PSeInt

Las variables y constantes se pueden procesar utilizando operaciones y


funciones adecuadas para sus tipos.
Se denomina expresin a un conjunto de variables y/o constantes unidas por
operadores.
Un operador es un smbolo o palabra que sirve para indicar la realizacin de
una accin entre uno o dos valores que son llamados operandos.
Si en una expresin existe ms de una operacin, debe tenerse en cuenta que
existen una serie de reglas para definir la prioridad en la que stas se ejecutarn.
Por este motivo, se suele utilizar parntesis para establecer la prioridad de
aplicacin de los operandos.
Existen diversos tipos de operadores, por ejemplo:

Aritmticos: Son apropiados nicamente para tipos de datos numricos.


Ejemplos de operadores aritmticos son: + , - , * y / , etc., los
cuales permiten obtener el resultado de la suma, la resta, la multiplicacin
y la divisin de dos datos respectivamente. Su resultado es un nmero.
De relacin: Los operadores de relacin (o relacionales), se utilizan para
expresar condiciones y describen una relacin entre dos valores.
Ejemplos de operadores relacionales son: < (Menor que), > (Mayor
que), = (Igual a) y <> (Distinto a), etc. Su resultado es un valor de
verdad.
Los operadores aritmticos y los relacionales se utilizan de la siguiente
forma: variable o constante operador variable o constante. Por ejemplo:
a + b, c/d, a<b, c<>d, etc.

Lgicos: Estos operadores se utilizan con valores lgicos, de forma


similar al modo en que los operadores aritmticos se utilizan con los
valores numricos. Estos operadores trabajan con operandos que son
expresiones lgicas. La operacin and (y) combina dos condiciones
simples y produce un resultado verdadero slo si los dos operandos son
verdaderos. La operacin or (o) es verdadera si uno de los dos operandos
es verdadero. La operacin not (no) acta sobre una sola condicin simple
u operando y simplemente, niega (o invierte) su valor. Su resultado es un
valor de verdad. Existen otros operadores lgicos adems de los
mencionados.

Ejemplo de expresin: Cos (2*pi * X) + 75.69 * X

10

11

Jfferson Beltrn Morales

1.2.5 ESTRUCTURAS DE CONTROL.


El concepto de flujo de control a travs de un algoritmo y luego del programa, se
refiere al orden en que se ejecutan las acciones individuales del mismo. Aunque
un flujo normal de un programa estructurado es lineal, existen mtodos que
permiten salir del flujo lineal, a travs del uso de las llamadas estructuras de
control.
Las estructuras de control son fundamentales en el diseo de un algoritmo
computacional, pues son mtodos para especificar el orden en que las
instrucciones de un algoritmo se ejecutarn.
Las estructuras de control son:

Secuenciales: Sucesin simple de dos o ms instrucciones o sentencias


(una tras otra).
De Seleccin o Condicionales: Bifurcacin condicional de una o ms
instrucciones.
De Repeticin o Iteracin: Repeticin de una instruccin mientras se
cumple una condicin.

1.3 PASOS PARA CREAR UN ALGORITMO.


Para disear un algoritmo se debe comenzar por identificar las tareas ms
importantes para resolver el problema y disponerlas en el orden en que han de
ser ejecutadas. Los pasos para crear un algoritmo son:

Anlisis del problema. Para resolver cualquier problema, se debe


comprenderlo completamente, es una actividad que debe realizarse con
mucha responsabilidad, nunca se debe disear un algoritmo sin haberse
hecho un anlisis completo del problema.
Diseo del algoritmo. Se describen los pasos para resolver el problema.
Es mejor solucionar problemas pequeos. Los pasos generales son:
o Lectura de datos.
o Validacin de datos.
o Lgica de negocio: Clculos, lgica / comparacin, proceso de
datos, etc.
o Salida de resultados.
Prueba del algoritmo. Se realiza las pruebas manuales necesarias
mediante casos de prueba, para comprobar que el algoritmo arroje los
resultados deseados.

Algoritmos en PSeInt

En general, los algoritmos reciben datos de entrada, los procesa y genera la


salida.

El proceso se refiere a los clculos que se deben hacer para obtener la salida
deseada. A partir de los datos de entrada, se procesan, y se consigue la salida.
Los algoritmos generalmente se representan mediante diagramas de flujo y
pseudocdigo.
1.4 REPRESENTACIN GRFICA DE LOS ALGORITMOS.
1.4.1 DESCRIPCIN NARRADA.
Este algoritmo se caracteriza porque sigue un proceso de ejecucin comn y
lgico, se describe textualmente paso a paso cada una de las actividades a
realizarse.
Ejemplo: Algoritmo para asistir a clases:
1. Levantarse
2. Baarse
3. Vestirse
4. Desayunar
5. Cepillarse los dientes
6. Salir de casa
7. Tomar el autobs
8. Llegar a la Universidad
9. Buscar el aula
10. Ubicarse en un asiento
1.4.2 DIAGRAMAS DE FLUJO O FLUJOGRAMAS.
Son la representacin grfica de la solucin algortmica de un problema. Para
disearlos se utilizan determinados smbolos o figuras, que representan una
accin dentro de la solucin. Se utiliza unos smbolos normalizados, con los
pasos del algoritmo escritos en el smbolo adecuado, los smbolos se unen con
flechas, denominadas lneas de flujo, que indican el orden en que los pasos
deben ser ejecutados.
Para su elaboracin se sigue las siguientes reglas:

12

13

1.
2.
3.
4.

Jfferson Beltrn Morales

Se escribe de arriba hacia abajo y de izquierda a derecha.


Siempre se usan flechas verticales u horizontales, jams curvas.
Evitar cruce de flujos.
En cada paso expresar una accin concreta.

La secuencia de un flujo normal en una solucin de un problema es:


1. Un inicio.
2. Una lectura o entrada de datos.
3. El proceso de datos.
4. Una salida de informacin.
5. Un final
Ejemplo: Dibujar un diagrama de flujo que imprima en pantalla Hola Mundo.

Entre las ventajas de usar diagrama de flujos se tiene:


o Rpida comprensin de las relaciones.
o Anlisis efectivo de las diferentes secciones del algoritmo.
o Pueden usarse como modelos de trabajo en el diseo de nuevos
algoritmos.
o Comunicacin con el usuario.
o Documentacin adecuada de los algoritmos.
o Codificacin eficaz de los algoritmos.
o Depuracin y pruebas ordenadas de los algoritmos.
Entre las desventajas podemos anotar:
o Diagramas complejos y detallados suelen ser laboriosos en su
planteamiento y diseo.
o Acciones a seguir tras la salida de un smbolo de decisin, pueden ser
difciles de seguir si existen diferentes caminos.
o No existen normas fijas para la elaboracin de los diagramas de flujo que
permitan incluir todos los detalles que el usuario desee introducir.

Algoritmos en PSeInt

o Diagramas de flujo muy grandes son difciles de leer y seguir su


secuencia.
1.4.3 PSEUDOCDIGO.
Pseudo = falso. El pseudocdigo no es realmente un cdigo, sino una imitacin
y una versin abreviada de instrucciones reales de los lenguajes de
programacin. Es una tcnica para diseo de algoritmos, que permite definir las
estructuras de datos, las operaciones que se aplicarn a los datos y la lgica que
tendr el algoritmo computacional para solucionar un determinado problema.
Utiliza un pseudolenguaje muy parecido a nuestro idioma, pero que respeta las
directrices y los elementos de los lenguajes de programacin. Se concibi para
superar las dos principales desventajas de los diagramas de flujo: lento de crear
y difcil de modificar sin un nuevo dibujo. La principal ventaja es que, como se
parece a un lenguaje de programacin, la evolucin de pseudocdigo hacia un
lenguaje de programacin es ms fcil, que a partir de un diagrama de flujo.
Ejemplo: Escribir un algoritmo que imprima en pantalla Hola Mundo.
Proceso HolaMundo
Escribir 'Hola Mundo';
FinProceso
1.5 PSEINT.
PSeInt es una herramienta para asistir a un estudiante en sus primeros pasos en
programacin. Mediante un simple e intuitivo pseudolenguaje en espaol
(complementado con un editor de diagramas de flujo), le permite centrar su
atencin en los conceptos fundamentales de la algoritmia computacional,
minimizando las dificultades propias de un lenguaje y proporcionando un entorno
integrado de trabajo con numerosas ayudas y recursos didcticos [14].
PSeInt, es un pseudoentorno de desarrollo integrado (pseudo IDE) en espaol,
cuyas principales caractersticas son:

Un editor, que proporciona el medio para introducir el texto y los


smbolos que constituyen el pseudocdigo fuente.
Un compilador que convierte el pseudocdigo en cdigo de un
lenguaje de programacin que la computadora puede comprender y
ejecutar, de esta manera se puede ejecutar un algoritmo que
realmente no es ejecutable.
Un depurador que ayuda a analizar y corregir errores en tiempo de
ejecucin.
Ayuda (manuales, tutoriales, ejemplos, etc.) integrada.

14

Jfferson Beltrn Morales

15

Convierte diagramas de flujo en pseudocdigo y viceversa.


Convierte pseudocdigo a cdigo de varios lenguajes de
programacin, entre ellos: C, C++, C#, Java, JavaScript, MatLab,
Pascal, PHP, Python 2, Python 3, QBasic Visual Basic.

El presente libro, no pretende ser un manual de uso de PSeInt, sino una gua de
cmo crear algoritmos con la ayuda de PSeInt.
La configuracin de Opciones de Lenguaje que se us en los ejemplos del libro,
es la enviada por la Universidad Central del Ecuador, pues hace que el
pseudocdigo en PSeInt se parezca a un lenguaje de programacin, se trata de
que la transicin a un lenguaje de programacin sea ms fcil.

Algoritmos en PSeInt

PARTE II: ALGORITMOS EN PSeInt.


2 PROGRAMACIN ESTRUCTURADA.
Programacin Estructurada es una tcnica en la cual la estructura de un
algoritmo o programa se lo realiza tan claramente como sea posible mediante el
uso de tres estructuras de control:

Secuenciales: Sucesin simple de dos o ms instrucciones, sentencias


o acciones (una tras otra).
Selectivas o Condicionales: Bifurcacin condicional de una o ms
instrucciones.
Repetitivas o Iterativas: Repeticin de una instruccin mientras se
cumple una condicin.

Escribiremos los algoritmos bajo el paradigma de la programacin estructurada,


para ello usaremos un pseudolenguaje cuyas caractersticas son:
Sintaxis sencilla (sin la complejidad de los lenguajes de programacin).
Manejo de las estructuras bsicas de control.
Slo 3 tipos de datos bsicos:
o Numrico: Nmeros, tanto enteros como reales. Para separar
decimales se utiliza el punto. Ejemplos: 12 23 0 -2.3 3.14
o Lgico: Slo puede tomar dos valores: VERDADERO o FALSO.
o Caracter: Caracteres o cadenas de caracteres encerrados entre
comillas (pueden ser dobles o simples). Ejemplos 'hola' "hola mundo"
'123' 'FALSO' 'etc'. (generalmente se usa comillas simples para un
carcter y dobles para cadena de caracteres o texto)

Estructuras de datos: Arreglos.

Todo algoritmo en pseudocgido tiene la siguiente estructura general:


Proceso <NombrePrograma>
<accin 1>;
<accin 2>;
.
.
.
<accin n>;
FinProceso

16

17

Jfferson Beltrn Morales

Se inicia con la palabra clave Proceso seguida del nombre del programa, luego
le sigue una secuencia de instrucciones (acciones) 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. No puede haber
instrucciones fuera del proceso, aunque si comentarios.
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.
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. 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.
En diagrama de flujo en cambio se usa la siguiente estructura general para
diagramar algoritmos:
Inicio

Acciones

Fin

Constantes e identificadores.
o Los identificadores deben constar slo de letras y nmeros,
comenzando siempre con una letra.
o Las constantes de tipo carcter se escriben entre comillas ( " ).
o En las constantes numricas, el punto ( . ) es el separador decimal.
o Las constates lgicas son Verdadero y Falso.

Definicin de variables.
La instruccin Definir permite explicitar el tipo de una o ms variables. Esta
definicin puede ser opcional u obligatoria, aunque la asignacin de tipos a
los datos tiene dos objetivos principales:
1. Detectar errores de operaciones en los programas durante la fase de
codificacin.
2. Determinar cmo se ejecutarn las operaciones entre datos.

Algoritmos en PSeInt

Una operacin de suma no tiene sentido con caracteres de texto, slo con
nmeros. Por consiguiente, si el compilador detecta una operacin de suma
de dos caracteres normalmente producir un error. Incluso entre tipos
numricos la operacin de suma se almacena de modo distinto, ya que los
nmeros enteros y los reales se almacenan de formas distintas en memoria.
A menos que el programa conozca los tipos de datos no puede ejecutar
correctamente la operacin de suma.
A los lenguajes que exigen que todos los datos utilizados deban tener sus
tipos declarados explcitamente se los conoce como fuertemente tipados.
El tipo de un dato puede ser convertido bajo ciertas condiciones a otro tipo.
Este mecanismo explcito de conversin de tipos de datos se suele
denominar CAST.
La sintaxis es:
Definir <var1> , <var2> , , <varN> Como [Real/Entero/Logico/Caracter] ;
Una variable debe ser definida antes de ser utilizada por primera vez.
Ejemplo:
Definir var Como Real; // se define la variable var como Real
Definir acumulador Como Entero; // acumulador es una variable Entero

Constantes.
La nica constante definida en PSeInt es PI (3.141592653).

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.
Ejemplo:
var<-1.0; // asigna 1.0 a var
acumulador<-acumulador +1; // incrementa en 1 el acumulador

18

19

Jfferson Beltrn Morales

Entradas.

La instruccin Leer permite ingresar informacin por teclado.


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.
Ejemplo:
Leer cantidad;
Leer valor1, valor2, valor3;

Salidas.

Las instrucciones Escribir y Escribir Sin Saltar permiten mostrar valores al


ambiente.
Escribir <exprl>, <expr2> , ... , <exprN> ;
Escribir Sin Saltar <exprl>, <expr2> , ... , <exprN> ;
Estas instrucciones imprimen en pantalla los valores obtenidos de evaluar N
expresiones. Dado que puede incluir una o ms expresiones, mostrar uno o
ms valores. Con Escribir, el cursor luego de imprimir, avanzar a la
siguiente lnea, si se usa Escribir Sin Saltar, el cursor se mantendr en la
misma lnea.
Ejemplo:
Escribir Ingrese el nombre: ;
Escribir El Resultado es: , resp*2 ;

Otras Acciones Secuenciales.


La instruccin "Borrar Pantalla" (o "Limpiar Pantalla") permite, como su
nombre lo indica, borrar la pantalla y colocar el cursor en la esquina superior
izquierda.
Ejemplo:

Algoritmos en PSeInt

Borrar Pantalla;
La instruccin "Esperar Tecla" detiene su algoritmo hasta que el usuario
presione una tecla cualquiera de su teclado.
Ejemplo:
Esperar Tecla;
La instruccin "Esperar" tambin puede utilizarse para pausar el algoritmo
durante un intervalo de tiempo predefinido, indicando a continuacin de la
palabra clave la longitud y unidad de dicho intervalo. Las unidades vlidas
son Segundos y Milisegundos.
Ejemplo:
Esperar 3 Segundos;

Arreglos.
Los arreglos son estructuras de datos homogneas (todos sus datos son del
mismo tipo) que permiten almacenar un determinado nmero de datos bajo
un mismo identificador, para luego referirse a los mismos utilizando uno o
ms subndices.
Para utilizar un arreglo, primero es obligatorio su dimensionamiento, es decir,
definirlo declarando los rangos de sus subndices, lo cual determina cuantos
elementos se almacenarn y como se acceder a los mismos. Con mayor
detalle se estudiar los arreglos ms adelante.

Dimensionamiento.
Pseudocdigo:
La instruccin Dimension permite definir un arreglo, indicando sus
dimensiones.
Dimension <identificador> (<max1>,...,<maxN>);
Esta instruccin define un arreglo con el nombre indicado en <identificador>
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 (,).

20

Jfferson Beltrn Morales

21

Dimension <ident1>
(<max11>,..,<max1N>),..,<identM>(<maxM1>,..,<maxMN>);
Es importante notar que es necesario definir un arreglo antes de utilizarlo.
Ejemplo:
Definir vector, matriz Como Entero;
Dimension vector[100], matriz[10,20];
Diagrama de flujo: El grfico que se usa en diagrama de flujo para la
definicin de variables y dimensionamiento de arreglos es el mismo que se
utiliza para la asignacin.

Operadores y Funciones.
PSeInt 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

<>

Diferente que

4<>3

<=

Menor o igual que

'a'<='b'

>=

Mayor o igual que

4>=5

&

Conjuncin (y / and).

(7>4) & (2=1) //falso

Disyuncin (o / or).

(1=1 | 2=1) //verdadero

Negacin (no / not).

~(2<5) //falso

Suma

suma <- suma+1

Multiplicacin

area <- base * altura

Resta

stock <- disponible - venta

Divisin

porc <- 100 * parte / total

Potenciacin

sup <- 3.41 * radio ^ 2

Mdulo (resto de la divisin


resto <- num % 2
entera)

Lgicos

Algebraicos

Algoritmos en PSeInt

22

La jerarqua de los operadores matemticos es igual a la del lgebra, aunque


puede alterarse mediante el uso de parntesis. Para el caso de los
operadores & y |, la evaluacin se realiza en cortocircuito, es decir, que si dos
expresiones estn unidas por el operador & y la primera se evala como
Falso, o estn unidas por el operador | y la primera se evala como
Verdadero, la segunda no se evala ya que no altera el resultado.
A continuacin se listan las funciones integradas disponibles:
Funcin
RC(X) o RAIZ(X)
ABS(X)
LN(X)
EXP(X)
SEN(X)
COS(X)
TAN(X)
ASEN(X)
ACOS(X)
ATAN(X)
TRUNC(X)
REDON(X)
AZAR(X)
ALEATORIO(A,B)
LONGITUD(S)
MAYUSCULAS(S)
MINUSCULAS(S)
SUBCADENA(S,X,Y)

CONCATENAR(S1,S2)

Significado
Raz Cuadrada de X
Valor Absoluto de X
Logaritmo Natural de X
Funcin Exponencial de X
Seno de X
Coseno de X
Tangente de X
Arcoseno de X
Arcocoseno de X
Arcotangente de X
Parte entera de X
Entero ms cercano a X
Entero aleatorio en el rango [0;x-1]
Entero aleatorio en el rango [A;B]
Cantidad de caracteres de la cadena S
Retorna una copia de la cadena S con
todos sus caracteres en maysculas
Retorna una copia de la cadena S con
todos sus caracteres en minsculas
Retorna una nueva cadena que consiste
en la parte de la cadena S que va desde
la posicin X hasta la posicin Y
(incluyendo ambos extremos). Las
posiciones utilizan la misma base que los
arreglos, por lo que la primera letra ser
la 0 o la 1 de acuerdo al perfil del lenguaje
utilizado.
Retorna una nueva cadena resulta de
unir las cadenas S1 y S2.

Jfferson Beltrn Morales

23

CONVERTIRANUMERO(X)

CONVERTIRATEXTO(S)

Recibe una cadena de caracteres que


contiene un nmero y devuelve una
variable numrica con el mismo.
Recibe un real y devuelve una variable
numrica con la representacin como
cadena de caracteres de dicho real.

Como habamos mencionado anteriormente, un problema se puede dividir en


acciones elementales o instrucciones, usando un nmero limitado de estructuras
de control (bsicas) y sus combinaciones que pueden servir para resolver dicho
problema.
2.1 ESTRUCTURA SECUENCIAL.
Se caracteriza porque una accin se ejecuta detrs de otra. El flujo del programa
coincide con el orden fsico en el que se han ido poniendo las instrucciones.
Dentro de este tipo podemos encontrar operaciones de inicio/fin, inicializacin de
variables, operaciones de asignacin, clculo, sumarizacin, etc. Este tipo de
estructura se basa en las 5 fases de que consta todo algoritmo o programa:
1.
2.
3.
4.
5.

Definicin de variables (Declaracin)


Inicializacin de variables.
Lectura de datos.
Clculo.
Salida.

Ejemplo 1: Se desea encontrar la longitud y el rea de un crculo de radio


ingresado por teclado.
Solucin. El objetivo del ejercicio es encontrar la longitud y el rea de un crculo
con un radio ingresado por teclado. Las salidas sern entonces la longitud y el
rea. (Fase 5 del algoritmo) Sabemos que la longitud de un crculo viene dada
por la frmula 2 * PI * radio y que el rea viene dada por PI * radio al cuadrado.
(Fase 4 del algoritmo) Si definimos las variables como: (fase 1 del algoritmo)
long = Longitud, area = rea, radio = radio, hagamos el algoritmo:
Pseudocdigo:
Proceso Algoritmo1

Algoritmos en PSeInt

//este algoritmo calcula el rea y la longitud de un crculo de radio


//ingresado por teclado
Definir Radio, Area, Long Como Real; //definicin de variables
Escribir "Ingrese el radio: "; //despliega en pantalla
Leer Radio; //Ingresa por teclado el radio
Area <- PI * Radio ^ 2; //asignacin del valor del rea
Long <- 2 * PI * Radio ; //asignacin del valor de la longitud
Escribir "Area: ", Area, " Longitud: ", Long; //salida del algoritmo
FinProceso

Diagrama de Flujo:

24

Jfferson Beltrn Morales

25

Ejemplo 2. Leer el sueldo de tres empleados y aplicarles un aumento del 10%,


12% y 15% respectivamente. Desplegar el resultado.
Solucin.
Salidas: Sueldos finales.
Entradas: Salarios de los empleados.
Datos adicionales: aumentos del 10%, 12% y 15%
Clculos:
Sueldo final = sueldo inicial * (1+porcentaje/100)
Definicin de variables:
sueldoFinal1, sueldoFinal2, sueldoFinal3 = los sueldos finales
sueldo1, sueldo2, sueldo3 = salarios de los empleados
Pseudocdigo:
Proceso Algoritmo2
//Leer el sueldo de tres empleados y aplica un aumento del 10, 12 y
//15% respectivamente
Definir sueldo1, sueldo2, sueldo3 Como Real; //definicin de variables
Definir sueldoFinal1, sueldoFinal2, sueldoFinal3 Como Real;
sueldo1 <- 0; //inicializamos variables
sueldo2 <- 0;
sueldo3 <- 0;
sueldoFinal1 <- 0;
sueldoFinal2 <- 0;
sueldoFinal3 <- 0;
Escribir "Ingrese el sueldo de los 3 empleados";
Leer sueldo1, sueldo2, sueldo3; //lee los sueldos
sueldoFinal1 <- sueldo1 * 1.10; //incrementa el 10% al sueldo original
//y lo asigna en sueldoFinal1
sueldoFinal2 <- sueldo2 * 1.12; //incrementa el 12% al sueldo original

Algoritmos en PSeInt

//y lo asigna en sueldoFinal2


sueldoFinal3 <- sueldo3 * 1.15; //incrementa el 15% al sueldo original
//y lo asigna en sueldoFinal3
Escribir "Sueldos incrementados: ", sueldoFinal1," ", sueldoFinal2," ",
sueldoFinal3;
FinProceso
Diagrama de flujo:

2.2 ESTRUCTURAS SELECTIVAS O CONDICIONALES.

26

27

Jfferson Beltrn Morales

Con frecuencia nos enfrentamos a situaciones en las que se deben proporcionar


instrucciones alternativas que pueden o no ejecutarse dependiendo de los datos
de entrada, reflejando el cumplimiento o no de una determinada condicin. La
realizacin de acciones alternativas o decisiones se especifican utilizando
condiciones que son verdaderas o falsas. Estas condiciones se llaman
expresiones lgicas, o booleanas. Dado que las expresiones lgicas toman el
valor verdadero o falso, se necesita una sentencia de control que dirija a la
computadora a ejecutar una sentencia si la expresin es verdadera, y otra
sentencia en caso de que sea falsa.
2.2.1 ESTRUCTURA SELECTIVA SI-ENTONCES.
La siguiente figura muestra el diagrama de flujo de la estructura Si-Entonces:

EL pseudocdigo es:
Si <condicin>
Entonces
<instrucciones>
Sino
<instrucciones>
FinSi
La estructura Si funciona de la siguiente manera:
1. Se evala la expresin lgica.
2. Si la expresin toma el valor verdadero, se ejecutar la sentencia A y el
control pasar a la sentencia inmediatamente siguiente.
3. Si la expresin toma el valor falso, entonces slo se ejecutar la sentencia
B y el control pasa de nuevo inmediatamente a la siguiente sentencia del
programa. La clusula sino es optativa, en ese caso, si la condicin es
falsa no se ejecuta ninguna instruccin y la ejecucin del programa
contina con la instruccin siguiente.
.

Algoritmos en PSeInt

Ejemplo 3. Construir un algoritmo que lea la calificacin de un alumno en un


examen, escriba "Aprobado" en caso que esa calificacin fuese mayor o igual
que 7.
Solucin.
Salidas: Mensaje de aprobado si se cumple la condicin.
Entradas: Calificacin.
Datos adicionales: Un alumno aprueba si la calificacin es mayor o igual
que 7.
Variables:
Cal = calificacin
Pseudocdigo:
Proceso Algoritmo3
//lee la calificacin de un alumno y escribe "Aprobado" si es mayor o
//igual que 7
Definir cal Como Real; //declaro la variable
Escribir "Ingrese la calificacin del alumno: ";
Leer cal;
Si cal>=7 Entonces
Escribir "Aprobado";
FinSi
FinProceso.
Diagrama de flujo:

28

Jfferson Beltrn Morales

29

Ejemplo 4. Dada la calificacin de un alumno en un examen, escriba "Aprobado"


si su calificacin es mayor o igual que 7 y "Reprobado" en caso contrario.
Pseudocdigo:
Proceso Algoritmo4
//escribe "Aprobado" si es mayor o igual que 7 o "Reprobado" caso
//contrario
Definir cal Como Real; //declaro la variable
Escribir "Ingrese la calificacin del alumno: ";
Leer cal;
Si cal>=7 Entonces
Escribir "Aprobado";
Sino

Algoritmos en PSeInt

Escribir "Reprobado";
FinSi
FinProceso
Diagrama de flujo:

Ejemplo 5. Dado como dato el sueldo de un trabajador, aplicar un aumento del


15% si su sueldo es inferior a $1000 y 12% en caso contrario, luego imprimir el
nuevo sueldo del trabajador.
Pseudocdigo:
Proceso Algoritmo5
//aumento el 15% si su sueldo es inferior a $1000 y 12% en caso
//contrario

30

Jfferson Beltrn Morales

31

Definir sueldo, nuevoSueldo Como Real; //declaro la variable


Escribir "Ingrese el sueldo del trabajador: ";
Leer sueldo;
Si sueldo<1000 Entonces
NuevoSueldo <- sueldo*1.15;
Sino
NuevoSueldo <- sueldo*1.12;
FinSi
Escribir "El nuevo sueldo es: ", nuevoSueldo;
FinProceso
Diagrama de flujo:

2.2.1.1

EXPRESIONES LGICAS.

Algoritmos en PSeInt

Sirven para plantear alternativas o decisiones y dan como resultado un valor


booleano verdadero o falso, es decir, se cumple o no se cumple la condicin. Se
pueden clasificar en simples y complejas. Las simples son las que usan
operadores relacionales y las complejas las que usan operadores lgicos.
Ejemplo 6: Operador lgico Y (&): Una escuela aplica dos exmenes a sus
aspirantes, por lo que cada uno de ellos obtiene dos calificaciones denotadas
como calif1 y calif2. El aspirante que obtenga calificaciones mayores o iguales
que 7 en ambos exmenes es aceptado; en caso contrario es rechazado.
Pseudocdigo:
Proceso Algoritmo6
//escribe aceptado si las 2 calificaciones son >= que 7, caso contrario es
//rechazado
Definir calif1, calif2 Como Real;
Escribir "Ingrese la nota 1: ";
Leer calif1;
Escribir "Ingrese la nota 2: ";
Leer calif2;
Si ((calif1>=7) & (calif2>=7)) Entonces
Escribir "Estudiante aceptado";
Sino
Escribir "Estudiante rechazado";
FinSi
FinProceso
Diagrama de flujo:

32

Jfferson Beltrn Morales

33

En este ejemplo, ntese que tambin se usa operadores relacionales. Por lo


general cuando hay operadores lgicos, stos van acompaados de operadores
relacionales.
Ejemplo 7: Operador lgico O (|): Una escuela aplica dos exmenes a sus
aspirantes, por lo que cada uno de ellos obtiene dos calificaciones denotadas
como calif1 y calif2. El aspirante que obtenga una calificacin mayor o igual
que 9 en cualquiera de los exmenes es aceptado; en caso contrario es
rechazado.
Pseudocdigo:
Proceso Algoritmo7
//escribe aceptado si una de las 2 calificaciones es >= que 9, caso
//contrario es rechazado
Definir calif1, calif2 Como Real;
Escribir "Ingrese la nota 1: ";
Leer calif1;
Escribir "Ingrese la nota 2: ";
Leer calif2;
Si ((calif1>=9) | (calif2>=9)) Entonces

Algoritmos en PSeInt

Escribir "Estudiante aceptado";


Sino
Escribir "Estudiante rechazado";
FinSi
FinProceso
Diagrama de flujo:

La instruccin del ejemplo 7 equivale a OR ya que nos dice que puede ser en
cualquiera de los exmenes no necesariamente en los dos. En ejemplo 6 la
palabra ambos equivale a seleccionar la instruccin AND. Si la instruccin nos
dijera que obtenga una nota en cualquiera de los exmenes pero no en ambos,
nos estara indicando una instruccin XOR que es un tipo de OR pero exclusivo.
Es decir, no puede considerarse el caso en que tenga la misma nota en los dos
exmenes, solo en uno de los dos.

34

Jfferson Beltrn Morales

35

2.2.1.2

ESTRUCTURAS ANIDADAS.

Recordemos que las estructuras no secuenciales se pueden anidar, es decir,


pueden contener otras adentro, pero la estructura contenida debe comenzar y
finalizar dentro de la contenedora.
En la solucin de problemas encontramos numerosos casos en los que luego de
tomar una decisin y marcar el camino correspondiente a seguir, es necesario
tomar otra decisin. Dicho proceso puede repetirse numerosas veces. En los
problemas en donde un bloque condicional incluye otro bloque condicional se
dice que un bloque est anidado dentro del otro.
Ejemplo 8. Determinar la cantidad de dinero que recibir un trabajador por
concepto de las horas extras trabajadas en una empresa, sabiendo que cuando
las horas de trabajo exceden de 40, el resto se consideran horas extras y que
stas se pagan al doble de una hora normal cuando no exceden de 8; si las horas
extras exceden de 8 se pagan las primeras 8 al doble de lo que se paga por una
hora normal y el resto al triple.
Solucin. Lo primero que hay que determinar es si el trabajador trabaj horas
extras o no. Encontrar las horas extras de la siguiente forma:
Horas extras = horas trabajadas - 40
En caso que s trabaj horas extras:
Si horas extras>8 entonces a horas extras excedentes de 8=horas extras-8
y pago por horas extras = pago por hora normal * 2 * 8 + pago por hora
normal * 3 * horas extras excedentes de 8
De otra forma (slo horas al doble) pago por horas extras = pago por hora
normal * 2 * horas extras.
Finalmente, pago total que recibir el trabajador ser:
Pago = pago * hora normal * 40 + pago por horas extras.
Si no trabaj horas extras tendremos:
Pago = pago por hora normal * horas trabajadas.
Datos de salida: Pago.
Datos de entrada: nmero de horas trabajadas y pago por hora normal.
Definicin de variables:
ht = horas trabajadas
het = horas extras que exceden de 8
ph = pago por hora normal
phe = pago por horas extras
he = horas extras
pt = pago que recibe el trabajador

Algoritmos en PSeInt

Pseudocdigo:
Proceso Algoritmo8
Definir he, het, ht Como Entero; //variable de horas trabajadas
Definir ph, phe, pt Como Real; //variables para pago
Escribir "Ingrese las horas trabajadas: ";
Leer ht;
Escribir "Ingrese el valor por hora normal: ";
Leer ph;
Si ht > 40 entonces
//determinamos las horas extras
he <- ht - 40;
Si he > 8 entonces
//determinamos las horas a pagar al triple
het <- he - 8;
//las 8 se pagan al doble y el resto al triple
phe <- ph * 2 * 8 + ph * 3 * het;
Sino
//se pagan al doble
phe <- ph * 2 * he;
FinSi
//pago horas normales ms horas extras
pt <- ph * 40 + phe;
Sino
//no hay horas extras

36

Jfferson Beltrn Morales

37

pt <- ph * ht;
FinSi
Escribir "El valor a pagar es: ", pt;
FinProceso
Diagrama de flujo:

Algoritmos en PSeInt

Ejemplo 9. Dados los datos A, B y C que representan nmeros enteros


diferentes, construir un algoritmo para escribir estos nmeros en forma
descendente. Este es un ejemplo de los algoritmos conocidos como de Lgica
Pura, ya que poseen muchas decisiones y muchas bifurcaciones.

38

Jfferson Beltrn Morales

39

Observacin: Para ordenar nmeros no es un algoritmo eficiente, pero nos sirve


para ejemplarizar estructuras anidadas.
Solucin:
Salida: A, B y C ordenados descendentemente.
Entradas: A, B y C.
La dinmica del problema es comparar dos nmeros a la vez para
conocer cul es el mayor.
Pseudocdigo:
Proceso Algoritmo9
//ordenar 3 nmeros de mayor a menor
Definir a,b,c Como Entero;
Escribir "Ingrese 3 nmeros: ";
Leer a,b,c;
Escribir "Los nmeros ordenados descendentemente son: ";
Si a>b Entonces
Si a>c Entonces
Si b>c Entonces
Escribir a," ",b," ",c;
Sino
Escribir a," ",c," ",b;
FinSi
Sino
Escribir c," ",a," ",b;
FinSi
Sino
Si b>c Entonces

Algoritmos en PSeInt

Si a>c Entonces
Escribir b," ",a," ",c;
Sino
Escribir b," ",c," ",a;
FinSi
Sino
Escribir c," ",b," ",a;
FinSi
FinSi
FinProceso
Diagrama de flujo:

2.2.2 ESTRUCTURA DE SELECCIN MLTIPLE SEGN.


Con frecuencia es necesario que existan ms de dos elecciones posibles. Este
problema se podra resolver por estructuras selectivas anidadas o en cascada,
pero si el nmero de alternativas es grande puede plantear serios problemas de
escritura y de legibilidad.

40

Jfferson Beltrn Morales

41

Usando la estructura de decisin mltiple se evaluar una expresin que podr


tomar n valores distintos, 1, 2, 3,,n y segn que elija uno de estos valores en
la condicin, se realizar una de las n acciones o lo que es igual, el flujo del
algoritmo seguir slo un determinado camino entre los n posibles.
Esta estructura se representa por un selector el cual si toma el valor 1 ejecutar
la accin A, si toma el valor 2 ejecutar la accin B, si toma el valor N realizar
la accin N.
La estructura de seleccin mltiple se implementa con la sentencia Segn, cuyo
diagrama de flujo y pseudocdigo son:
Diagrama de flujo:

Pseudocdigo:
Segun <variable> Hacer
<nmero1>: <instrucciones>
<nmero2>,<nmero3>: <instrucciones>
<...>
De Otro Modo: <instrucciones>
FinSegun
Reglas:
o Esta instruccin permite ejecutar opcionalmente varias acciones
posibles (distintas entre si), dependiendo del valor almacenado en una
variable de tipo numrico.
o Al ejecutarse, se evala el contenido de la variable y se ejecuta la
secuencia de instrucciones asociada con dicho valor.
o Cada opcin est formada por uno o ms nmeros separados por
comas, dos puntos y una secuencia de instrucciones.

Algoritmos en PSeInt

o 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.
o 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.
Ejemplo 10: Escribir un algoritmo tal que si opc=1 realice la suma, si opc=2, el
producto, si opc=3, la divisin y 0 en cualquier otro caso, despliegue el resultado:
Pseudocdigo:
//Ejemplo de estructura Segun
Proceso Algoritmo10
Definir num1, num2, opc Como Entero;
Definir resp Como Real;
resp <-0;
Escribir "Ingrese una opcin: 1 (Suma), 2 (Producto), 3 (Divisin) :";
Leer opc;
Escribir "Ingrese los dos nmeros a operar: ";
Leer num1, num2;
Segun opc Hacer
1:
resp <- num1+num2;
2:
resp <- num1*num2;
3:
Si num2=0 Entonces
Escribir "El denominador no puede ser 0";

42

Jfferson Beltrn Morales

43

Sino
resp <- num1/num2;
FinSi
De Otro Modo:
resp <- 0;
FinSegun
Escribir "El resultado es : ",resp;
FinProceso
Diagrama de Flujo:

Ejemplo 11. Dados como datos la categora y el sueldo de un trabajador, calcule


el aumento correspondiente teniendo en cuenta la siguiente tabla. Imprimir la
categora del trabajador y el nuevo sueldo.

Algoritmos en PSeInt

Incrementos
Categora
Aumento
1
15%
2
10%
3
8%
4
7%
Pseudocdigo:
Proceso Algoritmo11
//ejemplo de estructura Segun
Definir cat Como Entero;
Definir sueldo, inc, nuevoSueldo Como Real;
Escribir "Ingrese la categora: ";
Leer cat;
Escribir "Ingrese el sueldo: ";
Leer sueldo;
Segun cat Hacer
1:
inc <- sueldo*0.15;
2:
inc <- sueldo*0.1;
3:
inc <- sueldo*0.08;
4:
inc <- sueldo*0.07;
De Otro Modo:

44

Jfferson Beltrn Morales

45

inc<- 0;
FinSegun
nuevoSueldo <- sueldo + inc;
Escribir "Categora: ",cat,", nuevo sueldo: ",nuevoSueldo;
FinProceso
Diagrama de Flujo:

2.3 ESTRUCTURAS REPETITIVAS O ITERATIVAS.


Las computadoras estn especialmente preparadas para ejecutar tareas
repetidamente. Los clculos simples o la manipulacin de pequeos conjuntos
de datos se pueden realizar fcilmente a mano, pero las tareas grandes o
repetitivas son realizadas con mayor eficiencia por una computadora. Las
estructuras de control repetitivas son aquellas en las que una sentencia o grupos
de sentencias se repiten muchas veces. Este conjunto de sentencias se
denomina bucle, ciclo, lazo, o loop. Las acciones que se repiten en un bucle
constituyen el cuerpo del bucle, y cada repeticin del cuerpo del bucle se
denomina iteracin.

Algoritmos en PSeInt

Las estructuras repetitivas bsicas son:

Estructura Para.
Estructura Mientras.
Estructura Repetir.

2.3.1 ESTRUCTURA REPETITIVA PARA.


En numerosas ocasiones se puede necesitar un bucle que se ejecute un nmero
determinado de veces, y cuyo nmero se conozca por anticipado. Para
aplicaciones de este tipo se utiliza la sentencia Para. Esta sentencia requiere
que conozcamos por anticipado el nmero de veces que se ejecutarn las
sentencias del interior del bucle.
En la siguiente figura se muestra el diagrama de flujo de la estructura Para:

El pseudocdigo es:
Para <variable> <- <inicial> Hasta <final> (Con Paso <paso>) Hacer
<instrucciones>
FinPara
Al ejecutarse la sentencia Para la primera vez, el valor <inicial> se asigna a la
variable <variable>, denominada variable de control, y a continuacin se ejecuta
las sentencias de instrucciones que forman el cuerpo del bucle. Al llegar al final
del bucle (FinPara), se incrementa la variable <variable> en <paso> unidades y
se verifica si el valor almacenado en <variable> es mayor que el valor <final>; en
caso negativo se vuelve a ejecutar todas las sentencias del interior del bucle
hasta que la variable de control <variable> sea mayor que el valor final <final>.
Algunos lenguajes permiten definir lo que se llama paso, que es la cantidad de
unidades en las que se incrementar o decrementar la variable de control en
cada iteracin. Si se omite la clusula Con Paso <paso>, la variable <variable>
se incrementar en uno.

46

Jfferson Beltrn Morales

47

Es comn usar en las estructuras repetitivas los contadores y acumuladores


que los describimos a continuacin:
2.3.1.1

CONTADOR.

Un contador es una variable cuyo valor se incrementa o decrementa en una


cantidad constante cada vez que se produce un determinado suceso o accin.
Los contadores se utilizan con la finalidad de contar sucesos o acciones internas
de un bucle; deben realizar una operacin de inicializacin y posteriormente las
sucesivas de incremento o decremento del mismo. La inicializacin consiste en
asignarle al contador un valor. Se situar antes y fuera del bucle.
Representacin:
<nombre del contador> <- <nombre del contador> + <valor constante>;
Si en vez de incremento es decremento se coloca un menos en lugar del ms.
Ejemplo:
i <- i + 1;
2.3.1.2

ACUMULADOR O TOTALIZADOR.

Es una variable que suma sobre s misma un conjunto de valores para de esta
manera tener la suma de todos ellos en una sola variable. La diferencia entre un
contador y un acumulador es que mientras el primero va aumentando un valor
constante, el acumulador va aumentando en una cantidad variable.
Representacin:
<Nombre del acumulador> <- <nombre del acumulador> + <valor variable>;
Ejemplo 12. Calcular la suma de los cuadrados de los primeros 100 enteros y
escribir el resultado. Se desea resolver el problema usando estructura Para.
Pseudocdigo:
Proceso Algoritmo12
//Ejemplo estructura Para
Definir i,suma Como Entero;
//inicializo el acumulador

Algoritmos en PSeInt

suma <- 0;
Para i<-1 Hasta 100 Con Paso 1 Hacer
suma <- suma + i*i;
FinPara
Escribir "La suma de los 100 primeros enteros es: ",suma;
FinProceso
Diagrama de flujo:

Ejemplo 13. Calcular la promedio de N nmeros enteros y escribir el resultado.


Pseudocdigo:
// Calcula el promedio de una lista de N datos
Proceso Algoritmo13
Definir i, numDatos Como Entero;

48

Jfferson Beltrn Morales

49

Definir acum, promedio, dato Como Real;


acum <- 0;
Escribir "Ingrese la cantidad de datos:";
Leer numDatos;
Para i<-1 Hasta numDatos Hacer
Escribir "Ingrese el dato ",i,": ";
Leer dato;
acum <- acum + dato;
FinPara
promedio <- acum / numDatos;
Escribir "El promedio es: ",promedio;
FinProceso
Diagrama de flujo:

Algoritmos en PSeInt

2.3.2 ESTRUCTURA ITERATIVA MIENTRAS.


La estructura iterativa Mientras es aquella en la que el nmero de iteraciones no
se conoce por anticipado y el cuerpo del bucle se repite mientras se cumple una
determinada condicin. Por esta razn, se lo conoce como bucle condicional.
El diagrama de flujo y pseudocdigo de la estructura iterativa mientras son:

50

51

Jfferson Beltrn Morales

Diagrama de flujo:

Pseudocdigo:
Mientras <condicin> Hacer
<instrucciones>
FinMientras
Cuando la sentencia mientras se ejecuta, lo primero que sucede es la evaluacin
de la expresin lgica <condicin>. Si se evala como falsa, ninguna accin se
realiza y el programa sigue en la siguiente sentencia despus del bucle. Si la
expresin lgica se evala como verdadera, entonces se ejecuta el cuerpo del
bucle y se evala de nuevo la expresin lgica <condicin>, es decir, se puede
ejecutar el bucle, cero o ms veces. Este proceso se repite mientras la expresin
lgica sea verdadera. Despus de cada iteracin la expresin lgica se evala y
se verifica de nuevo; si cambia de verdadera a falsa la sentencia mientras
finaliza. Mientras que la condicin sea verdadera el bucle se ejecutar. Esto
significa que el bucle se ejecutar indefinidamente a menos que algo en el
interior del mismo modifique la condicin haciendo que su valor pase a falso. Si
la expresin nunca cambia de valor, entonces el bucle no termina nunca y se
denomina bucle o loop infinito (en general, esta situacin no es deseable), a fin
de evitarlo, las instrucciones del cuerpo del bucle deben contener alguna
instruccin que modifique la o las variables involucradas en la expresin lgica
<condicin>, de modo que sea falsa en algn momento y as finalice la ejecucin
del ciclo.
Ejemplo 14. Calcular la suma de los cuadrados de los primeros 100 nmeros
enteros y escribir el resultado.
Solucin. Como recordars, resolvimos este ejercicio en la leccin anterior pero
utilizando la estructura Para. Ahora lo haremos con la estructura Mientras.

Algoritmos en PSeInt

En este caso, se necesita un contador (un ndice), para llevar la cuenta de las
veces que entramos al cuerpo del bucle. Tambin es importante notar que esta
variable se debe inicializar antes de entrar al cuerpo del ciclo y dentro del cuerpo
se incrementar en uno cada vez que ingrese a l.
Esta variable adems nos sirve para compararla con el valor dado en la
condicin, cuando no se cumple la condicin, se sale del ciclo.
Pseudocdigo:
//Ejemplo estructura Mientras
Proceso Algoritmo14
Definir i,suma Como Entero;
//inicializo el acumulador y el contador
suma <- 0;
i <- 1;
Mientras i<=100 Hacer
//sumo al acumulador
suma <- suma + i*i;
//incremento el contador
i <- i+1;
FinMientras
Escribir "La suma de los 100 primeros enteros es: ",suma;
FinProceso
Diagrama de flujo:

52

Jfferson Beltrn Morales

53

En las estructuras cclicas condicionales es comn controlar los ciclos con


centinelas y banderas.
2.3.2.1

CENTINELAS.

En un bucle mientras controlado por tarea, la condicin mientras especifica que


el cuerpo del bucle debe continuar ejecutndose mientras la tarea no haya sido
completada, esto puede ser controlado por centinelas.
Centinelas son variables que toman valores adecuados para suspender el
ingreso a un bucle.
Por ejemplo, si se tienen las calificaciones de un test (comprendida entre 0 y
100); un valor centinela en esta lista puede ser -1, ya que nunca ser una

Algoritmos en PSeInt

calificacin vlida y cuando aparezca este valor se terminar de ejecutar


el
bucle. Si la lista de datos son nmeros positivos, un valor centinela puede ser un
nmero negativo.
Ejemplo 15. Suponga que debemos obtener la suma de los gastos que hicimos
en nuestro ltimo viaje, pero no sabemos exactamente cuntos fueron.
Solucin: Si definimos gasto1, gasto2, gasto3, ...., -1 donde gastoi es el gasto
nmero i y sumaGasto es el acumulador de gastos efectuados. -1 es el centinela
de fin de datos.
Pseudocdigo:
//Ejemplo de centinelas
Proceso Algoritmo15
Definir gasto, sumaGasto Como Real;
sumaGasto <- 0;
Escribir "Ingrese -1 para salir";
Escribir "Ingrese el gasto realizado: ";
//leemos gasto fuera del bucle mientras
Leer gasto;
Mientras gasto <> -1 Hacer
sumaGasto <- sumaGasto + gasto;
Escribir "Ingrese el gasto realizado: ";
Leer gasto;
FinMientras
Escribir "El gasto total es: ",sumaGasto;
FinProceso
Diagrama de flujo:

54

Jfferson Beltrn Morales

55

2.3.2.2

BANDERAS.

Conocidas tambin como interruptores, switch, flags o conmutadores, son


variables que pueden tomar solamente dos valores durante la ejecucin del

Algoritmos en PSeInt

programa, los cuales pueden ser 0 1, o bien los valores booleanos True o False.
Se les suele llamar interruptores porque cuando toman los valores 0 1 estn
simulando un interruptor abierto/cerrado o encendido/apagado.
Ejemplo 16: Leer un nmero entero N y calcular el resultado de la siguiente
serie: 1 - 1/2+ 1/3 - 1/4+.... +/- 1/N.
Pseudocdigo:
//Ejemplo de banderas
Proceso Algoritmo16
Definir bandera Como Logico;
Definir serie Como Real;
Definir i, num Como Entero;
serie <- 0;
i <- 1;
Escribir "Ingrese el valor de N: ";
Leer num;
//inicializamos la bandera
bandera <- Verdadero;
Mientras i <= num Hacer
Si bandera = Verdadero Entonces
serie <- serie + 1/i;
bandera <- Falso;
Sino
serie <- serie - 1/i;
bandera <- Verdadero;
FinSi

56

Jfferson Beltrn Morales

57

i <- i+1;
FinMientras
Escribir "La suma de la serie es: ",serie;
FinProceso
Diagrama de flujo:

Algoritmos en PSeInt

2.3.3 ESTRUCTURA ITERATIVA REPETIR.

58

59

Jfferson Beltrn Morales

La estructura iterativa Repetir es una bucle condicional como lo es tambin la


estructura Mientras. Se usa cuando el nmero de iteraciones no se conoce por
anticipado (lo cual si se conoce en la estructura Para).
La diferencia entre ambas es que la condicin se sita al inicio (Mientras) o al
final (Repetir) de la secuencia de instrucciones. Entonces, en el primero, el bucle
contina mientras la condicin es verdadera (la cual se comprueba antes de
ejecutar la accin, es decir se ejecuta cero o ms veces) y en el segundo, el
bucle contina hasta que la condicin se hace verdadera (la condicin se
comprueba despus de ejecutar la accin, es decir, se ejecutar al menos una
vez).
El diagrama de flujo de la estructura Repetir es el siguiente:

El pseudocdigo de la estructura Repetir es:


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 <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.
Un ciclo Repetir controlado por centinela, por ejemplo es cuando el usuario digita
una letra para salir como S o N para indicar si desea continuar o no. El bucle
debe repetirse hasta que la respuesta del usuario sea n o N. (Observe que los

Algoritmos en PSeInt

centinelas solamente pueden usarse con las estructuras Mientras y Repetir, no


con estructuras Para).
Ejemplo 17: Calcular la suma de los cuadrados de los primeros 100 nmeros
enteros y escribir el resultado.
Solucin. Nuevamente resolveremos el ejercicio de las dos lecciones anteriores,
ahora utilizando la estructura Repetir.
Como sabemos, en los bucles condicionales podemos usar una variable
contador que debe inicializarse antes del ciclo e incrementarse dentro del bucle
para controlar el nmero de veces que se ingresar al mismo. A diferencia de la
estructura Mientras, la condicin ahora estar colocada al final del bucle para
que primero se ejecute la instruccin y luego se verifique si la condicin se
cumple. Esto quiere decir, que en esta estructura el bucle se realizar por lo
menos una vez. Tambin podrs observar que la condicin est al revs, porque
el bucle se repite hasta que la condicin se cumpla. En el bucle Mientras, la
condicin se evaluaba mientras era verdadera.
Pseudocdigo:
//Ejemplo estructura Repetir
Proceso Algoritmo17
Definir i,suma Como Entero;
//inicializo el acumulador y el contador
suma <- 0;
i <- 1;
Repetir
//sumo al acumulador
suma <- suma + i*i;
//incremento el contador
i <- i+1;
Hasta Que i>100

60

Jfferson Beltrn Morales

61

Escribir "La suma de los 100 primeros enteros es: ",suma;


FinProceso
Diagrama de flujo:

Ejemplo 18. Se desea calcular la suma de N nmeros ingresados por el usuario,


hasta que l decida no ingresar ms nmeros.
Pseudocdigo:
//Ejemplo estructura Repetir con centinelas
Proceso Algoritmo18
Definir suma, num Como Real;;

Algoritmos en PSeInt

Definir resp Como Caracter;


//inicializo acumulador
suma <- 0;
//inicializo la centinela
Repetir
Escribir "Ingrese un nmero: ";
Leer num;
//sumo al acumulador
suma <- suma + num;
//pregunto se desea continuar
Escribir "Desea ingresar otro nmero (S/N): ";
// leo la respuesta
Leer resp;
Hasta Que (resp='N' | resp='n')
Escribir "La suma es: ",suma;
FinProceso
Diagrama de flujo:

62

63

Jfferson Beltrn Morales

2.4 ESTRUCTURA DE DATOS Y ARREGLOS.


Todas las variables que se han considerado hasta ahora son de tipo simple. Una
variable de tipo simple consiste de una sola localidad o caja de memoria y slo
puede contener un valor a la vez. Una variable de tipo estructurado consiste en
toda una coleccin de casillas de memoria. Los tipos de datos estudiados:
entero, real, carcter, lgico son considerados como datos de tipo simple, puesto
que una variable que se define con alguno de estos tipos slo puede almacenar

Algoritmos en PSeInt

un valor a la vez, es decir, existe una relacin de uno a uno entre la variable y el
nmero de elementos (valores) que es capaz de almacenar. En cambio un dato
de tipo estructurado, puede almacenar ms de un elemento (valor) a la vez, con
la condicin de que todos los elementos deben ser del mismo tipo, es decir, que
se puede tener un conjunto de datos enteros, reales, etc.
2.4.1 ESTRUCTURA DE DATOS.
Estructura de Datos es una coleccin de datos que se caracterizan por su
organizacin y las operaciones que se definen en ella. Las estructuras de datos
tienen en comn que un identificador o nombre, puede representar a mltiples
datos individuales.
Los datos de tipo estndar pueden ser organizados en diferentes estructuras de
datos: estticas y dinmicas.

Estructura de Datos Estticas. Son aquellas en las que se asigna una


cantidad fija de memoria cuando se declara la variable y no puede ser
modificada durante la ejecucin del programa. Corresponden a este tipo
los arreglos y registros.

Estructuras de Datos Dinmicas. Son aquellas en las que el espacio


ocupado en memoria puede ser modificado en tiempo de ejecucin.
Corresponden a este tipo las listas, rboles y grafos. Estas estructuras no
son soportadas en todos los lenguajes. La eleccin de la estructura de
datos idnea depender de la naturaleza del problema a resolver y, en
menor medida, del lenguaje.

2.4.2 ARREGLOS.
Un arreglo es una estructura de datos en la que se almacena una coleccin de
datos del mismo tipo (por ejemplo, los sueldos de los empleados de una
empresa). Dicho de otra forma, un arreglo y es una lista de un nmero finito n de
elementos del mismo tipo que se caracteriza por:

Almacenar sus elementos en posiciones de memoria contiguas


Tener un nico nombre de variable (por ejemplo salarios) que representa
a todos los elementos
Permitir acceso directo o aleatorio a sus elementos individuales, para ello
se utiliza un ndice que especifique la posicin relativa en el arreglo.

En resumen, un arreglo es una coleccin finita, homognea y ordenada de


elementos.

64

65

Jfferson Beltrn Morales

Finita. Todo arreglo tiene un lmite, es decir, debe determinarse cul ser
el nmero mximo de elementos que podrn formar parte del arreglo.
Homognea. Todos los elementos del arreglo deben ser del mismo tipo.
Ordenada: Se puede determinar cul es el primer elemento, el segundo,
el tercero,...., y el n-simo elemento.

Los arreglos se clasifican de acuerdo con el nmero de dimensiones que tienen.


As se tienen los arreglos:

Unidimensionales (vectores).
Bidimensionales (tablas o matrices).
Multidimensionales (tres o ms dimensiones).

Algoritmos en PSeInt

Ejemplo.
Suponga que se desea desarrollar un programa para:
1.
2.
3.
4.

Leer una lista de calificaciones de un examen.


Encontrar su media.
Escribir una lista de las calificaciones mayores que la media.
Ordenar la lista de las calificaciones en orden ascendente.

Supongamos tambin que hay 100 calificaciones. Con lo estudiado hasta el


momento, deberamos utilizar 100 variables diferentes nota1, nota2, ...., nota100,
de ese modo son 100 direcciones diferentes de memoria para almacenar las
calificaciones del examen. Se imagina declarar las 100 variables, cuntas
instrucciones involucra?
Definir nota1, nota2, nota3,.........nota100 Como Entero;
(En la declaracin real de un algoritmo en pseudocdigo no pueden usarse
puntos suspensivos, por lo tanto sern 100 veces). En la fase de lectura de datos,
sern tambin 100 veces las instrucciones para ir leyendo cada valor.
Leer nota1, nota2, nota3,........., nota100;
Para calcular la media:
media (nota1+nota2+.......+nota100)/100;
Para la lista de calificaciones mayores que la media, deber tambin compararse
una por una:
Si nota1 > media Entonces
Escribir nota1;
FinSi
Si nota2 > media Entonces
Escribir nota2;
FinSi

Si nota100 > media Entonces


Escribir nota100;
FinSi
Y despus de muchsimas lneas de cdigo..... Todava falta ordenar la lista de
calificaciones en orden ascendente!

66

67

Jfferson Beltrn Morales

Los arreglos nos permiten ahorrar instrucciones, porque es fcil recorrer toda la
lista de notas con unas pocas instrucciones. En el caso anterior, cuando el
acceso a la informacin es secuencial, slo se puede acceder a un elemento
buscando desde el principio de la lista, y esto es algo lento. Lo que se necesita
es una estructura de acceso directo que permita almacenar y recuperar los datos
directamente especificando su posicin en la estructura, de esa manera se
requerir el mismo tiempo para acceder al elemento de la posicin 100 que el de
la posicin 5.
Queremos tambin que esta estructura se almacene en memoria principal para
que su almacenaje y recuperacin sea ms rpida. Es por ello que existen los
arreglos, que estn organizados en una secuencia de elementos, todos del
mismo tipo y se puede acceder a cada elemento directamente especificando su
posicin en esta secuencia.
Para poder utilizar un arreglo, debemos indicar su tipo, un nombre nico y su
dimensionamiento, es decir, declarar los rangos de sus ndices, lo cual determina
cuantos elementos se almacenarn y como se acceder a los mismos. Al
declarar un arreglo, se debe inicializar sus elementos antes de utilizarlos

Definicin y Dimensionamiento.

La instruccin Dimension permite declarar un arreglo, indicando sus


dimensiones.
Dimesion <identificador> (<max1>,...,<maxN>);
Esta instruccin define un arreglo con el nombre indicado en <identificador> 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.
Ejemplo:
Definir vector, matriz Como Entero;
Dimension vector[100], matriz[10,20];

Algoritmos en PSeInt

2.4.2.1

ARREGLO UNIDIMENSIONAL.

Un arreglo de una dimensin (tambin conocido como vector) es un tipo de


datos estructurado compuesto de un nmero de elementos finitos, tamao fijo y
elementos homogneos que se almacenan bajo un mismo nombre, y se
diferencian por la posicin que tiene cada elemento dentro del arreglo de datos.
Finitos indica que hay un ltimo elemento, tamao fijo significa que el tamao del
arreglo debe ser conocido en tiempo de compilacin y homogneo significa que
todos sus elementos son del mismo tipo.
Los elementos del arreglo se almacenan en posiciones contiguas de memoria, a
cada una de las cuales se puede acceder directamente mediante un nmero
entero denominado ndice del arreglo, que identifica la posicin del elemento
dentro del conjunto.
Generalmente los ndices de los elementos de los arreglos inician en 0, es decir,
si declaramos un arreglo de 100 elementos, los ndices de elementos vlidos van
de 0 a 99 (aunque existen lenguajes que inician los ndices de los arreglos en 1).
vector[0]
vector[1]
vector[2]
..
vector[97]
vector[98]
vector[99]

2.4.2.1.1 PARTES DE UN ARREGLO.

Los componentes. Hacen referencia a los elementos que forman el arreglo,


es decir, a los valores que se almacenan en cada una de las casillas del
mismo.
Los ndices. Permiten hacer referencia a los componentes del arreglo en
forma individual, especifican cuntos elementos tendr el arreglo y adems,
de qu modo podrn accederse esos componentes.

68

Jfferson Beltrn Morales

69

valoro
valor1
valor2
...
valor97
valor98
valor99

Componentes

Definicin y Dimensionamiento.

Ejemplo. Definir un arreglo llamado vector de 100 elementos de tipo Real.


Definir vector Como Real;
Dimension vector[100];
2.4.2.1.2 OPERACIONES CON ARREGLOS.
Las operaciones que se pueden realizar con vectores durante el proceso de
resolucin de un problema son:
o Lectura/ Escritura,
o Asignacin.
o Actualizacin (insercin, eliminacin, modificacin).
o Recorrido (acceso secuencial).
o Ordenacin.
o Bsqueda.

Lectura. El proceso de lectura de un arreglo consiste en leer y asignar un


valor a cada uno de sus elementos. Normalmente se realizan con estructuras
repetitivas. Usamos los ndices para recorrer los elementos del arreglo.
Ejemplo:
Para i <- 0 Hasta 99 Con Paso 1 Hacer
Leer vector[i];
FinPara

Escritura. Es similar al caso de lectura, slo que en lugar de leer el


componente del arreglo, lo escribimos.
Ejemplo:

Algoritmos en PSeInt

Para i <- 0 Hasta 99 Con Paso 1 Hacer


Escribir vector[i];
FinPara

Asignacin. No es posible asignar directamente un valor a todo el arreglo;


sino que se debe asignar el valor deseado en cada componente. Podemos
recorrer el arreglo con una estructura repetitiva y asignar un valor a todos los
elementos del arreglo.
Ejemplo:
vector[1] <- 5; //asigna el valor 5 a la posicin 1 del arreglo vector
vector[10] <- vector[1] / 2; //asigna una operacin al arreglo vector
//Se puede asignar un valor constante a todos los elementos del vector
Para i <- 0 Hasta 99 Con Paso 1 Hacer
vector[i] <- 10;
FinPara

Inicializacin. Siempre es importante inicializar las variables y por lo tanto


tambin los arreglos. Por ejemplo, inicializar con 0 cada elemento del arreglo.
Ejemplo:
Para i <- 0 Hasta 99 Con Paso 1 Hacer
vector[i] <- 0;
FinPara

Acceso Secuencial. (Recorrido). El acceso a los elementos de un vector


puede ser para leer en l o para escribir (visualizar su contenido). Recorrido
del vector es la accin de efectuar una accin general sobre todos los
elementos de ese vector.

Actualizacin. Incluye aadir (insertar), borrar o modificar algunos de los ya


existentes. Se debe tener en cuenta si el arreglo est o no ordenado. Aadir
datos a un vector consiste en agregar un nuevo elemento al final del vector,
siempre que haya espacio en memoria (recordemos que el tamao de un
arreglo es fijo).

70

Jfferson Beltrn Morales

71

Observacin. Las partes de un arreglo unidimensional y las operaciones son las


mismas que en los arreglos multidimensionales (pueden extenderse), salvo que
se trata de varias dimensiones y no slo de una.
Ejemplo19. Se desea ingresar una lista de n valores numricos y calcular la
suma, el promedio, los nmeros mayor y menor de dicha lista
Pseudocdigo:
//Ejemplo de arreglos
Proceso Algoritmo19
Definir lista, i, mayor, menor, suma, n Como Entero;
Definir promedio como Real;
//supongamos que n es 10
n<-10;
//defino el arreglo y su tamao
Dimension lista[n];
//inicializo variables
suma<-0;
//inicializo el arreglo
Para i<-0 Hasta n-1 Con Paso 1 Hacer
lista[i]<-0;
FinPara
//leo los elementos del arreglo
Para i<-0 Hasta n-1 Con Paso 1 Hacer
Escribir "Ingrese el valor ",(i+1)," de la lista: ";
Leer lista[i];
FinPara

Algoritmos en PSeInt

//inicializo los nmeros mayor y menor con el primer


//elemento del arreglo
mayor<-lista[0];
menor<-mayor;
//calculo la suma recorriendo el arreglo
Para i<-0 Hasta n-1 Con Paso 1 Hacer
suma<-suma+lista[i];
FinPara
//calculo el promedio
promedio<-suma/n;
//calculo los nmeros mayor y menor de la lista
Para i<-1 Hasta n-1 Con Paso 1 Hacer
Si lista[i]>mayor Entonces
mayor<-lista[i];
FinSi
Si lista[i]<menor Entonces
menor<-lista[i];
FinSi
FinPara
//presento los resultados
Escribir "Suma: ", suma, ", Promedio: ", promedio;
Escribir "Nmero mayor: ", mayor, ", Nmero menor: ", menor;
FinProceso
Diagrama de flujo:

72

73

Jfferson Beltrn Morales

Algoritmos en PSeInt

Ejemplo 20. Ingresar una lista de nombres (la lista termina cuando se ingresa
un nombre en blanco), no se permite ingresar nombres repetidos y luego ordenar
y presentar la lista.
Pseudocdigo:
//Ordenamiento de un arreglo
Proceso Algoritmo20
Definir nombre,lista,aux Como Cadenas;
Definir seRepite Como Logico;
Definir cant,i,j,posMenor Como Enteros;
Dimension lista[200];
Escribir "Ingrese un nombre (enter en blanco para terminar):";
// leer la lista
cant <- 0;
Leer nombre;
Mientras nombre<>"" Hacer
Escribir "Ingrese un nombre: ";
lista[cant] <- nombre;
cant <- cant+1;
Repetir // leer un nombre y ver que no est ya en la lista
Leer nombre;
seRepite <- Falso;
//no es "" el nombre no se necesita buscar un repetido
Si nombre<>"" Entonces
Para i <- 0 Hasta cant-1 Hacer
Si nombre=lista[i] Entonces

74

Jfferson Beltrn Morales

75

seRepite <- Verdadero;


//salgo del bucle pues es ya
//repetido y no necesito seguir buscando
i <- cant;
Escribir "Nombre repetido";
Escribir "Ingrese un nombre: ";
FinSi
FinPara
FinSi
Hasta Que ~ seRepite
FinMientras
// ordenamos la lista
Para i <- 0 Hasta cant-2 Hacer
// busca el menor entre i y cant
posMenor <- i;
Para j <- i+1 Hasta cant-1 Hacer
Si lista[j] < lista[posMenor] Entonces
posMenor <- j;
FinSi
FinPara
// intercambia el que estaba en i con el menor que encontr
aux <- lista[i];
lista[i] <- lista[posMenor];
lista[posMenor] <- aux;
FinPara

Algoritmos en PSeInt

// mostrar como queda la lista


Escribir "La lista ordenada en forma ascendente es:";
Para i <- 0 Hasta cant-1 Hacer
Escribir " ",lista[i];
FinPara
FinProceso
Diagrama de flujo:

76

77

Jfferson Beltrn Morales

Algoritmos en PSeInt

2.4.3 ARREGLO BIDIMENSIONAL.


Hasta ahora hemos visto cmo se puede manipular informacin con una sola
columna o lista de entrada con los llamados vectores, o arreglos de una
dimensin. Sin embargo, en numerosas ocasiones es necesario trabajar con
datos que tengan ms de una dimensin (se representan por ejemplo como
tablas de doble entradas, cubos, etc.).
Un arreglo bidimensional (matriz o tabla) es un arreglo con dos ndices. Para
localizar o almacenar un valor en el arreglo se deben especificar dos posiciones
(dos subndices), uno para la fila y otro para la columna. Internamente en
memoria se reservan MxN posiciones consecutivas para almacenar todos los
elementos del arreglo.

Declaracin de una matriz.

Ejemplo: Definir una arreglo bidimensional de 10 filas y 20 columnas de nmeros


enteros llamado matriz.
Definir matriz Como Entero;
Dimension matriz[10,20];
Una matriz se representa como una tabla, donde: 1IM y 1JN (observe que
al igual que en los vectores, las filas y columnas de las matrices inician en 0).
1
2
J
N
1 matriz[0,0] matriz[0,1]
.. matriz[0,j]
matriz[0,n-1]
2 matriz[1,0] matriz[1,1]
.. matriz[1,j]
matriz[1,n-1]
..
I matriz[i,0]
matriz[i,1]
.. matriz[i,j]
matriz[i,n-1]
matriz[mmatriz[mmatriz[m-1,nM 1,0]
matriz[m-1,1] .. 1,j]
1]

Ejemplo 21. Se desea realizar la suma de dos matrices, ingresar las


dimensiones por teclado.
Pseudocdigo:
//Ejemplo de matrices
Proceso Algoritmo21
Definir i, j, m, n, matriz1, matriz2, matriz3 Como Entero;

78

Jfferson Beltrn Morales

79

Escribir "Ingrese el nmero de filas: ";


Leer m;
Escribir "Ingrese el nmero de columnas: ";
Leer n;
//defino la dimensin de las matrices
Dimension matriz1[m,n], matriz2[m,n], matriz3[m,n];
Limpiar Pantalla;
//ingreso la primera matriz
Escribir "Ingrese la matriz A:";
Para i <- 0 Hasta m-1 Con Paso 1 Hacer
Para j <- 0 Hasta n-1 Con Paso 1 Hacer
Escribir "Ingrese el valor A[",i+1,",",j+1,"]";
Leer matriz1[i,j];
FinPara
FinPara
Limpiar Pantalla;
//ingreso la segunda matriz
Escribir "Ingrese la matriz B:";
Para i <- 0 Hasta m-1 Con Paso 1 Hacer
Para j <- 0 Hasta n-1 Con Paso 1 Hacer
Escribir "Ingrese el valor B[",i+1,",",j+1,"]";
Leer matriz2[i,j];
FinPara
FinPara

Algoritmos en PSeInt

Escribir "Presione enter...";


Esperar Tecla;
Limpiar Pantalla;
//sumo las matrices y las presento en pantalla
Escribir "La suma de A+B es:";
Para i <- 0 Hasta m-1 Con Paso 1 Hacer
Para j <- 0 Hasta n-1 Con Paso 1 Hacer
matriz3[i,j] <- matriz1[i,j] + matriz2[i,j];
Escribir "C[",i+1,",",j+1,"]=",matriz3[i,j];
FinPara
FinPara
FinProceso
Diagrama de flujo:

80

81

Jfferson Beltrn Morales

Algoritmos en PSeInt

2.5 MODULARIDAD.
Una estrategia para la resolucin de problemas complejos con computadoras es
la divisin o descomposicin del problema en otros problemas ms pequeos y
fciles de resolver. Estos sub problemas se implementan mediante mdulos o
subprogramas. Los subprogramas son una herramienta importante para el
desarrollo de algoritmos y programas, de modo que normalmente un proyecto de
programacin se compone de un programa principal y un conjunto de
subprogramas, con las llamadas a los mismos dentro del programa principal. Un
subprograma realiza una tarea concreta que se describe con una serie de
instrucciones y que, idealmente, debera ser independiente de otros
subprogramas. El descomponer un programa en mdulos independientes ms
simples se conoce tambin como el mtodo de "Divide y vencers".
Cundo es til la modularizacin?
Este enfoque de segmentacin o modularizacin es til en dos casos:
1. Cuando existe un grupo de instrucciones o una tarea especfica que deba
ejecutarse en ms de una ocasin.
2. Cuando un problema es complejo o extenso, la solucin se divide o
segmenta en mdulos que ejecutan partes o tareas especficas.

Ventajas de la Programacin Modular.

Las ventajas ms sobresalientes de utilizar subprogramas o mdulos son:


o El uso de subprogramas facilita el diseo descendente y modular, que
permite descomponer un problema complejo en sub problemas hasta
que stos sean concretos y fciles de resolver.
o Los procedimientos se pueden ejecutar ms de una vez en un
programa y en diferentes programas, ahorrando en consecuencia
tiempo de programacin. Un subprograma, en esencia, se puede ver
como una caja negra (encapsulamiento) que ejecuta una tarea en
particular en un programa, acepta entradas y produce ciertas salidas.
Una vez que el mdulo se ha escrito y comprobado, se puede utilizar
en otros programas eliminando la duplicacin innecesaria de cdigo
(reutilizacin de cdigo).
o Aumenta la facilidad de depuracin y bsqueda de errores en un
programa ya que stos se pueden aislar fcilmente depurndose sus
errores individualmente antes de su inclusin en bibliotecas
independientes y de ser llamados en el programa principal.

82

83

Jfferson Beltrn Morales

o El uso de subprogramas facilita la divisin de tareas de programacin


entre un equipo de programadores.
o El uso de mdulos facilita la proyeccin y la comprensin de la lgica
subyacente para el programador y el usuario.
2.5.1 PROCEDIMIENTOS Y FUNCIONES.
Los subprogramas en programacin estructurada se clasifican en
procedimientos y funciones, que son unidades de programas diseados para
ejecutar una tarea especfica.
Las funciones normalmente devuelven un slo valor a la unidad de programa
(programa principal u otro subprograma) que los referencia (que los llama o
invoca). Los procedimientos pueden devolver cero, uno o varios valores.
Las funciones se dividen en estndares y definidas por el usuario.

Estndar. Son funciones proporcionadas por lenguaje de programacin.


Definidas por el usuario. Son funciones definidas el programador con el
propsito de ejecutar alguna funcin especfica, y que por lo general se
usan cuando se trata de hacer algn clculo que ser requerido en varias
ocasiones en la parte principal del algoritmo.

Las funciones y procedimientos estn compuestos por un grupo de sentencias a


las que se asigna un nombre (identificador) y constituyen una unidad de
programa a la que se puede invocar desde el programa principal u otra funcin
o procedimiento.
Una de las caractersticas importantes y diferenciadoras de los subprogramas es
la posibilidad de comunicacin entre el programa principal y los subprogramas
(o entre dos subprogramas). Esta comunicacin se realiza a travs de una lista
de parmetros. Un parmetro es un medio para pasar informacin valores a
variables del programa principal a un subprograma y viceversa. No es
obligatorio que un subprograma utilice parmetros, ya que stos no siempre son
necesarios.
Un parmetro es, prcticamente, una variable cuyo valor debe ser o bien
proporcionado por el programa principal al subprogramas o ser devuelto desde
el subprogramas al programa principal. Por consiguiente, hay dos tipos de
parmetros: parmetros de entrada y parmetros de salida. Los de entrada
son aquellos cuyos valores deben ser proporcionados por el programa principal,
mientras que los de salida son aquellos cuyos valores se calcularn en el

Algoritmos en PSeInt

subprograma y se deben devolver al programa principal para su proceso


posterior.

Visibilidad de las variables.


Las variables que intervienen en un programa con subprogramas pueden ser
de dos tipos: variables locales y variables globales.
Una variable local es una variable que est declarada dentro de un
subprograma, y se dice que es local al subprograma. Una variable local slo
est disponible durante el funcionamiento del mismo, y su valor se pierde una
vez que el subprograma termina. Dos variables locales pueden
tener
el mismo nombre siempre que estn declaradas en funciones o
procedimientos diferentes.
Las variables declaradas en el programa principal se denominan variables
globales. A diferencia de las variables locales, cuyos valores se pueden
utilizar slo dentro del subprograma en el que estn declaradas, las variables
globales pueden ser utilizadas en el programa principal y en todos los
subprogramas, permanecen activas durante toda la ejecucin del programa.
Hay que tener especial precaucin al trabajar con variables globales, ya que
al ser recursos compartidos todos los subprogramas pueden tener acceso
simultneo a ellas y se pueden producir errores lgicos debidos a la
concurrencia. Por lo general, es una buena prctica evitar el uso de variables
globales desde subprogramas a menos que sea estrictamente necesario.
Las variables tambin pueden ser declaradas dentro de un bloque o
estructura de control, y se comportarn como variables locales nicamente
dentro de dicho bloque o estructura.
Si dos variables, una global y una local, tienen el mismo nombre, la local
prevalecer sobre la global dentro del mdulo en que ha sido declarada.

2.5.1.1

IMPLEMENTACIN DE PROCEDIMIENTOS Y FUNCIONES.

En PSeInt el pseudocdigo para la implementacin de procedimientos y


funciones se realiza de la siguiente manera:
SubProceso variable_de_retorno
argumento_2, ... )
accin 1;

<-

nombre_de_la_funcion(argumento_1,

84

Jfferson Beltrn Morales

85

accin 1;
.
.
.
accin n;
FinSubproceso
Comienza con la palabra clave SubProceso (o Funcin, son equivalentes)
seguida de la variable de retorno, el signo de asignacin, el nombre del
subproceso, y finalmente, la lista de argumentos entre parntesis, en este caso
el SubProceso se denomina una funcin. Si el SubProceso no retorna ningn
valor, se denomina procedimiento, entonces pueden omitirse el identificador
variable_de_retorno y el signo de asignacin, es decir, colocar directamente el
nombre y los argumentos a continuacin de la palabra clave SubProceso. Si el
subproceso no recibe ningn valor pueden colocarse los parntesis vacos u
omitirse, finalizando la primer lnea con el nombre del subproceso. Las reglas
para los nombres de subprocesos, variables de retorno y argumentos son las
mismas que para cualquier identificador en pseudocdigo.
Adems, opcionalmente pueden agregarse las palabras claves Por Valor o Por
Referencia para indicar el tipo de paso de variables en cada argumento. Si no se
indica, los arreglos se pasan por referencia, las dems expresiones por valor. El
paso por referencia implica que si el SubProceso modifica el argumento, se
modificar en realidad la variable que se utiliz en la llamada, mientras que el
paso por valor implica que el SubProceso opera con una copia de la variable (o
el resultado de la expresin) que se utiliz en la llamada, por lo que las
modificaciones que aplique el SubProceso no se vern reflejadas fuera de la
misma.
Para invocar o llamar a un SubProceso (funcin o procedimiento) se debe utilizar
su nombre y entre parntesis los parmetros, que podrn ser expresiones slo
si el tipo de pasaje es por referencia. Una llamada puede ser en s una
instruccin, pero si la funcin retorna algn valor, tambin puede utilizarse como
operando dentro de una expresin.
Ejemplo 22. Realizar una funcin que acepte dos nmeros como parmetros y
devuelva la suma de dichos nmeros.

Algoritmos en PSeInt

Solucin. Crearemos una funcin llamada sumarNumeros que ser llamada en


el programa principal.
Pseudocdigo:
Subproceso suma <- sumarNumeros(parametro1 Por Valor, parametro2 Por
Valor)
definir suma como Real;
suma<-parametro1+parametro2;
FinSubproceso
Proceso Algoritmo22
Definir suma, num1, num2 como Real;
suma<-0;
num1<-0;
num2<-0;
Escribir "Ingrese el primer nmero";
Leer num1;
Escribir "Ingrese el segundo nmero";
Leer num2;
suma<-sumarNumeros(num1,num2);
Escribir "La suma es: ", suma;
FinProceso
En este ejemplo, vemos la definicin (declaracin) de una funcin en
pseudocdigo para calcular la suma de dos nmeros reales, los cuales son
pasados al subprograma como parmetros de entrada Por Valor. La funcin
sumarNumeros calcula la suma y la devuelve como un parmetro de salida y
se asigna en la variable suma.
Esta funcin la podemos invocar desde el programa principal u otra funcin o
procedimiento. Ntese que los nombres de los parmetros en la definicin

86

87

Jfferson Beltrn Morales

(parametro1 y parametro2) no necesariamente tienen que ser los mismos que


los utilizados en la invocacin (num1 y num2). Ntese tambin que el compilador
chequear previamente que el tipo de dato del parmetro de salida de la funcin
(en este caso un nmero real) pueda ser asignado a la variable suma segn su
tipo.
Al nombre de la funcin junto con la lista ordenada de sus parmetros de entrada
se lo conoce como firma de la funcin. En general, no puede haber dentro del
mismo programa dos funciones con la misma firma.
A primera vista, las funciones parecen dificultar la escritura de un programa. Sin
embargo, no slo no es as, sino que la organizacin de un programa en
funciones y/o procedimientos lo hace ms fcil de escribir y depurar, adems
que se reutiliza cdigo en cada llamada a una funcin o procedimiento.
Diagrama de flujo:

Observe como dentro del programa principal se llama o invoca a la funcin


sumarNumeros, se le pasa num1 y num2 como parmetros por valor y el
resultado se asigna en la variable suma.

Algoritmos en PSeInt

Ejemplo 23. Se desea crear un procedimiento que de la bienvenida al usuario


que ingresa al programa.
SubProceso bienvenida (nombre)
Escribir "Bienvenido " +nombre;
FinSubProceso

88

Jfferson Beltrn Morales

89

Proceso Algoritmo23
Definir nombre Como Caracter;
Escribir "Ingrese su nombre";
Leer nombre;
//llamada al procedimiento
bienvenida(nombre);
FinProceso
Al nombre del procedimiento junto con la lista ordenada de sus parmetros de
entrada se lo conoce como firma del procedimiento. En general, no puede
haber dentro del mismo programa dos procedimientos con la misma firma.
A primera vista, los procedimientos parecen dificultar la escritura de un
programa. Sin embargo, no slo no es as, sino que la organizacin de un
programa en funciones y/o procedimientos lo hace ms fcil de escribir y
depurar, adems que se reutiliza cdigo al llamar a las funciones o
procedimientos haciendo ms eficiente la escritura de un programa y el
mantenimiento del mismo.
Diagrama de flujo:

Algoritmos en PSeInt

Note como en el programa principal se llama o invoca al procedimiento llamado


bienvenida.
Ejemplo 24. Realizar un algoritmo que calcule las operaciones matemticas
bsicas (suma, resta, multiplicacin y divisin) de dos nmeros. Use funciones y
procedimientos.
Pseudocdigo:
SubProceso suma <- sumar (num1, num2)
Definir suma como Real;
suma <- num1 + num2;
FinSubProceso
SubProceso multiplicacion <- multiplicar (num1, num2)
Definir multiplicacion como Real;
multiplicacion <- num1 * num2;
FinSubProceso

90

Jfferson Beltrn Morales

91

SubProceso resta <- restar (num1, num2)


Definir resta como Real;
resta <- num1 - num2;
FinSubProceso
SubProceso division <- dividir (num1, num2)
Definir division como Real;
division <- num1 / num2;
FinSubProceso
Subproceso calculadora (num1, num2)
Escribir "El resultado de la suma es: ", sumar(num1,num2);
Escribir "El resultado de la resta es: ", restar(num1,num2);
Escribir "El resultado del producto es: ", multiplicar(num1,num2);
Si num2!=0 Entonces
Escribir "El resultado de la divisin es: ", dividir(num1,num2);
Sino
Escribir "El resultado de la divisin es: Denominador igual a 0";
FinSi
FinSubProceso
Proceso Algoritmo24
Definir num1,num2 como Real;
num1<-0;
num2<-0;
Escribir "CALCULADORA";
Escribir "Ingrese el primer nmero: ";

Algoritmos en PSeInt

Leer num1;
Escribir "Ingrese el segundo nmero: ";
Leer num2;
calculadora(num1,num2);
FinProceso
En el programa principal se orquesta (invoca) al resto de funciones o
procedimientos, armando de esta manera el programa deseado; el
procedimiento calculadora imprime en pantalla el resultado de las operaciones
matemticas bsicas calculadas con funciones dentro del procedimiento.
Note que en el programa principal no existe lgica de negocio, solamente debe
haber escritura, lectura, validacin de datos de entrada y llamadas a funciones
y/o procedimientos.
Diagrama de flujo:

92

93

Jfferson Beltrn Morales

Algoritmos en PSeInt

Ejemplo 25. Realice la suma de dos matrices usando funciones y/o


procedimientos, ingresar las dimensiones por teclado.
Pseudocdigo:
//Ejemplo de matrices con procedimientos y paso de valores por referencia
//(matrices) y por valor
//los arreglos por defecto se pasan por referencia
//las variables por defecto se pasan por valor

94

Jfferson Beltrn Morales

95

SubProceso leerMatriz (matriz Por Referencia, m Por Valor, n Por Valor )


Definir i, j Como Entero;
Para i<-0 Hasta m-1 Con Paso 1 Hacer
Para j<-0 Hasta n-1 Con Paso 1 Hacer
Escribir "Ingrese el valor M[",i+1,",",j+1,"]";
Leer matriz[i,j];
FinPara
FinPara
FinSubProceso
SubProceso escribirMatriz (matriz , m , n)
Definir i, j Como Entero;
Para i<-0 Hasta m-1 Con Paso 1 Hacer
Para j<-0 Hasta n-1 Con Paso 1 Hacer
Escribir sin Saltar "C[",i+1,",",j+1,"]=",matriz[i,j],"

";

FinPara
Escribir "";
FinPara
FinSubProceso
SubProceso sumarMatrices (matriz1, matriz2, matriz3 por referencia, m, n )
Definir i,j Como Entero;
Para i<-0 Hasta m-1 Con Paso 1 Hacer
Para j<-0 Hasta n-1 Con Paso 1 Hacer
matriz3[i,j]<-matriz1[i,j]+matriz2[i,j];
FinPara

Algoritmos en PSeInt

FinPara
FinSubProceso
Proceso Algoritmo25
Definir i,j,m,n,matriz1,matriz2,matriz3 Como Entero;
Escribir "Ingrese el nmero de filas: ";
Leer m;
Escribir "Ingrese el nmero de columnas: ";
Leer n;
//defino la dimensin de las matrices
Dimension matriz1[m,n], matriz2[m,n], matriz3[m,n];
Limpiar Pantalla;
//ingreso la primera matriz
Escribir "Ingrese la matriz A:";
leerMatriz(matriz1,m,n);
Limpiar Pantalla;
//ingreso la segunda matriz
Escribir "Ingrese la matriz B:";
leerMatriz(matriz2,m,n);
Escribir "Presione enter...";
Esperar Tecla;
Limpiar Pantalla;
//sumo las matrices y las presento en pantalla
sumarMatrices(matriz1, matriz2, matriz3, m, n);
Escribir "La suma de matrices es:";

96

Jfferson Beltrn Morales

97

escribirMatriz(matriz3 , m , n);
FinProceso
En uno de los ejercicios anteriores, habamos realizado el mismo ejercicio, note
como ahora al usar funciones y/o procedimientos se hace ms fcil de leer el
programa, adems de ser eficiente la escritura del mismo al no reescribir por
ejemplo el mismo cdigo cuando se lee cada matriz.
Los arreglos por defecto se pasan por referencia y las variables por defecto se
pasan por valor.
Diagrama de flujo:

Algoritmos en PSeInt

98

99

Jfferson Beltrn Morales

Algoritmos en PSeInt

100

Ejemplo 26. Realizar un algoritmo que ingrese una cadena de caracteres y


cuente el nmero de vocales.
Pseudocdigo:
SubProceso cantVocales <- cuentaVocales ( frase )
Definir cantVocales, i, j como Entero;
Definir vocales como Caracter;
// pasamos toda la frase a minsculas para no tener que preguntar 2
//veces por cada vocal
frase<-Minusculas(frase);
// lista de letras que vamos a buscar
vocales<-"aeiou";
cantvocales<-0;
// compara todas las letras de frase con las de vocales y contar
//coincidencias
Para i<-0 hasta Longitud(frase)-1 Hacer
Para j<-0 hasta Longitud(vocales)-1 Hacer
Si Subcadena(frase,i,i)=Subcadena(vocales,j,j) Entonces
cantVocales<-cantVocales+1;
FinSi
FinPara
FinPara
FinSubProceso
Proceso Algoritmo26
Definir frase,vocales Como Caracter;
Definir i,j,cantVocales Como Entero;

Jfferson Beltrn Morales

101

Escribir "Ingrese una frase";


Leer frase;
cantVocales<-cuentaVocales(frase);
Escribir "La frase contiene ",cantVocales," vocales.";
FinProceso
En este ejercicio se usa las funciones propias de PSeInt para el manejo de
cadenas de caracteres, adems se crea una funcin para contar el nmero de
vocales de una frase.
Diagrama de flujo:

Algoritmos en PSeInt

102

2.6 RECURSIVIDAD.
Recursividad, es el proceso de resolver un problema reducindolo a uno o ms
sub problemas que son idnticos en su estructura al problema original y ms
simples de resolver.
Una vez que se ha subdividido el problema original, se utiliza la misma tcnica
de descomposicin para subdividir cada uno de estos sub problemas en otros
que son menos complejos, hasta que los sub problemas llegan a ser tan simples
que se pueden resolver sin realizar ms subdivisiones, y la solucin general del
problema se obtiene juntando todos los componentes resueltos.
Se dice que un proceso es recursivo si forma parte de s mismo, es decir, que se
define en funcin de s mismo. En otras palabras, un mtodo es recursivo si
contiene invocaciones a s mismo.
La recursin aparece en la vida diaria, en problemas matemticos, en estructuras
de datos y en muchos otros problemas. Es un proceso extremadamente potente,
por lo que hay que saber cundo y cmo aplicarla.
Es una poderosa herramienta de programacin como alternativa a algoritmos
iterativos (cuando es casi imposible resolver con estructuras iterativas).

Jfferson Beltrn Morales

103

En resumen, la recursividad consiste en:

En el cuerpo de sentencias del SubPrograma (funcin) se invoca al propio


SubPrograma (funcin) para resolver una versin ms pequea del
problema original.
Habr un caso (o varios) tan simple que pueda resolverse directamente
sin necesidad de hacer otra llamada recursiva.

En general el pseudocdigo de un algoritmo recursivo es el siguiente:


SubProceso variable_de_retorno <- nombre_funcion_recursiva(argumento_1,
argumento_2, ... )
accin 1;
accin 2;
.
accin n;
variable_de_retorno
argumento_2, ... )

<-

nombre_funcion_recursiva(argumento_1,

FinSubproceso

Las condiciones que debe cumplir un algoritmo recursivo son:


Asegurar que existe una condicin de salida, en la que no se producen
llamadas recursivas (caso base).
Asegurar que se cubren todos los posibles casos entre el caso base y los
casos no base.
Cada llamada, en el caso no base, conduce a problemas cada vez ms
pequeos que terminarn en el caso base.
Ejemplo 27. Calcular el factorial de un nmero entero usando un algoritmo
recursivo.
Solucin.
Recordemos la definicin recursiva del factorial:
n! = n * (n-1)! , si n > 1
1! = 1
Por lo tanto, tenemos los casos:
Si n = 1 (caso base) Retornar 1

Algoritmos en PSeInt

Si n > 1 Retornar n * factorial(n 1)


Sea factorial(n) la funcin que calcula el factorial de un nmero entero n, sea
n=4, entonces:
factorial (4) = 4 * factorial (3) = 4 * 6 = 24
factorial (3) = 3 * factorial (2) = 3 *2 = 6
factorial (2) = 2 * factorial (1) = 2 * 1 = 2
factorial (1) = 1
Pseudocdigo:
//Ejemplo de recursividad
Subproceso fact <- factorial (n)
Definir fact como Entero;
Si n>1 Entonces
fact <- n*factorial(n-1);
Sino
fact <- 1;
FinSi
FinSubproceso
Proceso Algortimo27
Definir n como Entero;
n<-0;
Escribir "Factorial de un nmero entero";
Escribir "Ingrese en valor de n: ";
Leer n;
Escribir "El factorial de ",n," es ", factorial(n);
FinProceso

Diagrama de flujo:

104

105

Jfferson Beltrn Morales

A veces, podemos encontrar una solucin iterativa simple, que haga que el
algoritmo sea ms eficiente.

Algoritmos en PSeInt

106

Ejemplo 28. Calcular el factorial de un nmero entero usando un algoritmo


iterativo.
Solucin.
Se define el factorial como:
n! = n * (n-1)! , si n > 1
1! = 1
De acuerdo con esta definicin, se tiene que:
n! = n * (n-1)!, si n>1
(n-1)! = (n-1) * (n-2)!
(n-2)! = (n-2) * (n-3)!
.
(2)! = (2) * (1)!
De donde:
n!=n*(n-1)*(n-2)**1, que es la definicin iterativa de factorial.
Sea factorial(n) la funcin que calcula el factorial de un nmero entero n, sea
n=4, entonces:
factorial (4) = 4*3*2*1 = 24
Pseudocdigo:
Subproceso fact <- factorial (n)
Definir fact, i como Entero;
fact<-1;
Para i <- 1 Hasta n Con Paso 1 Hacer
fact<-fact*i;
FinPara
FinSubProceso
Proceso Algortimo28
Definir n como Entero;
n<-0;
Escribir "Factorial de un nmero entero";

Jfferson Beltrn Morales

107

Escribir "Ingrese en valor de n: ";


Leer n;
Escribir "El factorial de ",n," es ", factorial(n);
FinProceso

Diagrama de flujo:

Algoritmos en PSeInt

108

Ventajas.
La principal ventaja es la simplicidad de comprensin y su gran potencia,
favoreciendo la resolucin de problemas complejos de manera natural,
sencilla y elegante; y facilidad para comprobar y convencerse de que la
solucin del problema es correcta. El valor de la recursividad reside en el
hecho de que se puede usar para resolver problemas sin fcil solucin
iterativa.

Desventajas.
El principal inconveniente es la ineficiencia tanto en tiempo como en memoria,
dado que para permitir su uso es necesario transformar el programa recursivo
en otro iterativo, que utiliza bucles y pilas para almacenar las variables. Una
simple llamada puede generar un gran nmero de llamadas recursivas.
(factorial(n) genera n llamadas recursivas).

Observacin. La recursividad se debe usar cuando sea realmente necesaria, es


decir, cuando no exista una solucin iterativa simple.
2.7 ESTILO DE PROGRAMACIN.

109

Jfferson Beltrn Morales

El buen estilo de programacin es, sin lugar a dudas, una de las caractersticas
ms importantes que debe tener un buen programador. Un programa con buen
estilo es ms fcil de leer, de corregir y de mantener. Aunque la experiencia
proporciona el estilo, existen una serie de reglas que se recomiendan seguir
desde el principio del aprendizaje de la programacin.

Comentarios. La legibilidad de los programas aumenta considerablemente


utilizando comentarios. Un comentario es un texto explicativo ms o menos
largo, situado en el programa e ignorado por el compilador. Los comentarios
son considerados parte del cdigo fuente por ms que sean ignorados en las
etapas de compilacin y ejecucin, y tienen importancia primordial en las
fases de anlisis, puesta a punto y mantenimiento. Los comentarios son una
parte fundamental de la documentacin de un programa, ya que ayudan al
programador y a otras personas a la comprensin del mismo. No es raro
encontrar programas en los cuales los comentarios ocupan ms lugar,
incluso, que las propias instrucciones.
Eleccin de nombres significativos para variables, funciones y
procedimientos. Las variables, constantes, nombres de subprogramas y
nombres de programas deben ser significativos para orientar al usuario o a
otros programadores sobre lo que representan: X, Y, JJ no son identificadores
significativos.
Identacin. Aunque no suele ser requerido por los compiladores de los
lenguajes de alto nivel, es una prctica habitual realizar una identacin (o
tabulacin) en cada uno de los bloques y unidades de programas
fundamentales para mejorar la legibilidad del cdigo fuente.
Espacios y Lneas en Blanco. Con el mismo fin de mejorar le legibilidad y
comprensibilidad del programa es recomendado utilizar espacios en blanco
antes y despus de un operador, as como tambin dejar una lnea en blanco
entre partes importantes o que estn lgicamente separadas.
Validacin. Los programas no pueden considerarse correctos hasta que han
sido validados utilizando un rango amplio de datos de prueba para contemplar
todas las posibles direcciones que el flujo de control puede tomar en tiempo
de ejecucin.

Algoritmos en PSeInt

110

BIBLIOGRAFA.
1 Fundamentos de Informtica. Luis A. Urea y otros. Editorial Alfaomega rama, 1999.
2 Fundamentos de Programacin. Libro de Problemas. Luis Joyanes Aguilar,
Rodrguez Baena y Fernndez Azuela. 1996.
3 Pascal y Turbo Pascal enfoque prctico. Luis Joyanes Aguilar. Editorial Mc
Graw Hill, 1996.
4 Lgica Simblica. Luis Joyanes Aguilar y Angel Hermoso. Editorial Mc Graw
Hill.
5 Programacin en Pascal. Irving M. Copi. Editorial C.E.C.S.A., 4 Edicin.
6 Cmo programar en C/C++. Sanford Leestma y Larry Nyhoff. Editorial
Prentice Hall, 1999.
7 Introduccin a la Ciencia de las Computadoras. Deitel/Deitel. Editorial
Prentice Hall.
8 Aprenda Visual C++ Ya. Mark Andrews. Editorial Mc Graw Hill.
9 Visual C++ 6.0 Manual de Referencia. Chris Pappas y William H. Murray.
Editorial Mc Graw Hill.
10 Computacin. Metodologa, Lgica Computacional y Programacin. Ma. del
Rosario Bores Rangel y Romn Rosales Becerril. 1 Edicin, Editorial Mc
Graw Hill, 1993.
11 Programacin
en
C.
Byron
S.
Gottfried.
1
Edicin,
Editorial Mc Graw Hill, 1991.
12 Metodologa de la Programacin. Algoritmos, Diagramas de Flujo y
programas
Tomos
I
y
II.
Osvaldo
Cair
Battistutti.
1a
Edicin
Editorial Alfaomega, 1995.
13 Enciclopedia del Lenguaje C. Francisco Javier Ceballos .1 Edicin, Editorial
Alfaomega ra-ma, 1999.
14 http://pseint.sourceforge.net/