Professional Documents
Culture Documents
Algoritmos en PSeInt
Algoritmos
en
PSeInt
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
1.2
PSEINT. .............................................................................................. 14
PROGRAMACIN ESTRUCTURADA....................................................... 16
2.1
2.2
2.2.1.2
ESTRUCTURAS ANIDADAS........................................................ 35
2.3.1.1
CONTADOR. ................................................................................ 47
2.3.1.2
CENTINELAS. .............................................................................. 53
2.3.2.2
BANDERAS. ................................................................................. 55
2.4.2.1.1
2.4.2.1.2
MODULARIDAD. .................................................................................... 82
2.6
2.7
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.
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:
Algoritmos en PSeInt
10
11
Algoritmos en PSeInt
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.
Algoritmos en PSeInt
14
15
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
16
17
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.
18
19
Entradas.
Salidas.
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
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
<=
'a'<='b'
>=
4>=5
&
Conjuncin (y / and).
Disyuncin (o / or).
~(2<5) //falso
Suma
Multiplicacin
Resta
Divisin
Potenciacin
Lgicos
Algebraicos
Algoritmos en PSeInt
22
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.
23
CONVERTIRANUMERO(X)
CONVERTIRATEXTO(S)
Algoritmos en PSeInt
Diagrama de Flujo:
24
25
Algoritmos en PSeInt
26
27
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
28
29
Algoritmos en PSeInt
Escribir "Reprobado";
FinSi
FinProceso
Diagrama de flujo:
30
31
2.2.1.1
EXPRESIONES LGICAS.
Algoritmos en PSeInt
32
33
Algoritmos en PSeInt
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
35
2.2.1.2
ESTRUCTURAS ANIDADAS.
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
37
pt <- ph * ht;
FinSi
Escribir "El valor a pagar es: ", pt;
FinProceso
Diagrama de flujo:
Algoritmos en PSeInt
38
39
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:
40
41
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
42
43
Sino
resp <- num1/num2;
FinSi
De Otro Modo:
resp <- 0;
FinSegun
Escribir "El resultado es : ",resp;
FinProceso
Diagrama de Flujo:
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
45
inc<- 0;
FinSegun
nuevoSueldo <- sueldo + inc;
Escribir "Categora: ",cat,", nuevo sueldo: ",nuevoSueldo;
FinProceso
Diagrama de Flujo:
Algoritmos en PSeInt
Estructura Para.
Estructura Mientras.
Estructura Repetir.
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
47
CONTADOR.
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:
48
49
Algoritmos en PSeInt
50
51
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
53
CENTINELAS.
Algoritmos en PSeInt
54
55
2.3.2.2
BANDERAS.
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
57
i <- i+1;
FinMientras
Escribir "La suma de la serie es: ",serie;
FinProceso
Diagrama de flujo:
Algoritmos en PSeInt
58
59
Algoritmos en PSeInt
60
61
Algoritmos en PSeInt
62
63
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.
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:
64
65
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.
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.
66
67
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.
Algoritmos en PSeInt
2.4.2.1
ARREGLO UNIDIMENSIONAL.
68
69
valoro
valor1
valor2
...
valor97
valor98
valor99
Componentes
Definicin y Dimensionamiento.
Algoritmos en PSeInt
70
71
Algoritmos en PSeInt
72
73
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
75
Algoritmos en PSeInt
76
77
Algoritmos en PSeInt
78
79
Algoritmos en PSeInt
80
81
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.
82
83
Algoritmos en PSeInt
2.5.1.1
<-
nombre_de_la_funcion(argumento_1,
84
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
86
87
Algoritmos en PSeInt
88
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
90
91
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
Algoritmos en PSeInt
94
95
";
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
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
Algoritmos en PSeInt
100
101
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).
103
<-
nombre_funcion_recursiva(argumento_1,
FinSubproceso
Algoritmos en PSeInt
Diagrama de flujo:
104
105
A veces, podemos encontrar una solucin iterativa simple, que haga que el
algoritmo sea ms eficiente.
Algoritmos en PSeInt
106
107
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).
109
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.
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/