Algoritmos en PSeInt.pdf

Algoritmos en PSeInt

Jéfferson Beltrán Morales




2

3


Algoritmos en PSeInt. Todos los derechos reservados. No está permitida la reproducción total o parcial de este libro, ni su tratamiento informático, ni la transmisión de ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia u otros métodos, sin el permiso previo y por escrito del titular del Copyright. Copyright © 2015. Jéfferson Beltrán Morales. ISBN- 978-9942-21-557-4 Septiembre 2015 Quito – Ecuador


CONTENIDO INTRODUCCIÓN. .............................................................................................. 6 OBJETIVO.......................................................................................................... 6 EL LIBRO COMO HERRAMIENTA DOCENTE.................................................. 6 ORGANIZACIÓN DEL LIBRO. ........................................................................... 6 ACERCA DEL AUTOR. ...................................................................................... 7 PARTE I: ALGORITMOS.................................................................................... 8 1

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

CARACTERÍSTICAS 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 REPRESENTACIÓN GRÁFICA DE LOS ALGORITMOS. ..................... 12

1.4.1 DESCRIPCIÓN NARRADA. ................................................................ 12 1.4.2 DIAGRAMAS DE FLUJO O FLUJOGRAMAS. .................................... 12 1.4.3 PSEUDOCÓDIGO............................................................................... 14 1.5

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

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

PROGRAMACIÓN 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 LÓGICAS. .......................................................... 31

2.2.1.2

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

2.2.2 ESTRUCTURA DE SELECCIÓN MÚLTIPLE “SEGÚN”...................... 40 2.3

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

2.3.1 ESTRUCTURA REPETITIVA “PARA”. ................................................ 46

4


5

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

IMPLEMENTACIÓN DE PROCEDIMIENTOS Y FUNCIONES..... 84

2.6

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

2.7

ESTILO DE PROGRAMACIÓN. ........................................................... 108

BIBLIOGRAFÍA. ............................................................................................. 110


ALGORITMOS EN PSeInt INTRODUCCIÓN. Este libro muestra al estudiante y futuro programador, los conceptos básicos y fundamentos de los algoritmos computacionales, mediante el diseño y elaboración de algoritmos básicos y sencillos que se presentan comúnmente en el proceso de aprendizaje, utilizando técnicas algorítmicas estructuradas y modulares, como pseudocódigo y diagramas de flujo y herramientas especializadas, y de esta manera entender de manera más sencilla el fascinante mundo de la algoritmia y programación. Ya que un programador, es decir, la persona que diseña y construye sistemas computacionales o aplicaciones de software, antes de comenzar a interactuar con la computadora, tiene que aprender a pensar diferente a las demás personas, para poder analizar y resolver problemas mediante aplicaciones de software, los cuales primero debe plasmarlos en papel o en alguna herramienta de software específica para ello como PSeInt, para luego implementarlos en un lenguaje de programación.

OBJETIVO. El objetivo del libro es servir como material de lectura y estudio en un curso introductorio a la programación, mostrando los fundamentos de los algoritmos computacionales mediante técnicas de programación estructurada y modular, usando PSeInt como herramienta para el diseño de algoritmos en pseudocódigo y/o diagramas de flujos.

EL LIBRO COMO HERRAMIENTA DOCENTE. El libro es una guía y aporte sobre los fundamentos de algoritmos computacionales para los docentes de Programación I, de las carreras de Ingeniería Informática, Ingeniería Matemática, Ingeniería en Computación Gráfica e Ingeniería en Diseño Industrial de la Universidad Central del Ecuador. Puede ser extendido su uso en otras materias introductorias a la programación 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 programación, no pretende ser un manual de PSeInt, sino una guía práctica para el diseño de algoritmos mediante ejemplos, usando pseudocódigo y diagramas de flujo en PSeInt, mediante técnicas de programación estructurada y modular. La bibliografía principal se tomó del sitio web del desarrollador de PSeInt [14].

ORGANIZACIÓN DEL LIBRO. El libro se dividió en dos partes para efecto de un estudio gradual y de fácil lectura. Se inicia enunciando conceptos básicos sobre algoritmos

6

7


computacionales, para luego ponerlos en práctica en la segunda parte, con el diseño de algoritmos usando técnicas de programación estructurada y modular. Se incluyen ejemplos en pseudocódigo y diagramas de flujo escritos en PSeInt.

ACERCA DEL AUTOR. El autor tiene 15 años de experiencia como docente universitario en materias relacionadas a la matemática aplicada y al desarrollo de software. En el mismo número de años, es responsable del Desarrollo de Software y de la Gestión de Tecnología de Información y Comunicaciones en empresas privadas.


PARTE I: ALGORITMOS.

1 ALGORITMOS. Un algoritmo es un método 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 lógica su solución. Cada una de las acciones de que consta un algoritmo computacional se denomina sentencia (instrucciones o acciones) y éstas deben ser escritas en términos de cierto lenguaje comprensible para el computador, que es el lenguaje de programación. 1.1 CARACTERÍSTICAS DE LOS ALGORITMOS. Las características que debe satisfacer un algoritmo computacional son:     



Entrada. Son cero o más parámetros (datos) que ingresan al algoritmo para ser usados dentro de él. Salida. Al menos un dato es producido como salida del algoritmo. Exactitud/precisión. Cada instrucción debe ser clara y sin ambigüedad (hacen lo que deben hacer). Finito. Terminará después de un número finito de pasos. Eficiente. Cada instrucción 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 atención en los conceptos de la algoritmia computacional, antes que en la dificultad propia de un lenguaje de programación. Entre ellos se tienen: 1.2.1 DATOS Y TIPOS DE DATOS. Las diferencias piezas de información 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 carácter, tal como ‘B’, un valor entero como 36, un número real como 5.75, una cadena de caracteres como “Hola Mundo”, un valor de verdad como Verdadero o Falso, entre otros.

8


9

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 ejecución de un programa se lo denomina Constante. Las constantes deben ser declaradas y asignadas un valor antes de su utilización. En cambio, los datos de un programa cuyo valor puede cambiar durante la ejecución del mismo se conocen como Variables. Una variable es, en realidad, una posición o localidad de memoria donde se puede almacenar información, 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 algorítmicas que pueden ser ejecutadas. En general, las sentencias se clasifican en ejecutables (especifican, por ejemplo, operaciones de cálculos aritméticos y entradas/salidas de datos) y no ejecutables (no realizan acciones concretas ni afectan a la ejecución del programa, sino que ayudan a su legibilidad) como la declaración de variables. Las sentencias se clasifican, según su tipo y número, en: 

Sentencias simples: Son sentencias que no contiene ninguna otra sentencia. El ejemplo más típico de sentencia simple, es la sentencia de asignación, la cual se utiliza para almacenar un valor en una variable. La operación de asignación suele representarse en pseudocódigo con el símbolo ‘’, para denotar que el valor situado a su derecha se almacena en la variable situada a la izquierda: o variable  Valor o Ejemplo: suma0 (la asignación sólo será válida si el valor es válido 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.


Las variables y constantes se pueden procesar utilizando operaciones y funciones adecuadas para sus tipos. Se denomina expresión a un conjunto de variables y/o constantes unidas por operadores. Un operador es un símbolo o palabra que sirve para indicar la realización de una acción entre uno o dos valores que son llamados operandos. Si en una expresión existe más de una operación, debe tenerse en cuenta que existen una serie de reglas para definir la prioridad en la que éstas se ejecutarán. Por este motivo, se suele utilizar paréntesis para establecer la prioridad de aplicación de los operandos. Existen diversos tipos de operadores, por ejemplo: 



Aritméticos: Son apropiados únicamente para tipos de datos numéricos. Ejemplos de operadores aritméticos son: “ + ”, “ - ”, “ * ” y “ / ”, etc., los cuales permiten obtener el resultado de la suma, la resta, la multiplicación y la división de dos datos respectivamente. Su resultado es un número. De relación: Los operadores de relación (o relacionales), se utilizan para expresar condiciones y describen una relación 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 aritméticos y los relacionales se utilizan de la siguiente forma: variable o constante operador variable o constante. Por ejemplo: a + b, c/d, ad, etc.



Lógicos: Estos operadores se utilizan con valores lógicos, de forma similar al modo en que los operadores aritméticos se utilizan con los valores numéricos. Estos operadores trabajan con operandos que son expresiones lógicas. La operación and (y) combina dos condiciones simples y produce un resultado verdadero sólo si los dos operandos son verdaderos. La operación or (o) es verdadera si uno de los dos operandos es verdadero. La operación not (no) actúa sobre una sola condición simple u operando y simplemente, niega (o invierte) su valor. Su resultado es un valor de verdad. Existen otros operadores lógicos además de los mencionados.

Ejemplo de expresión: Cos (2*pi * X) + 75.69 * X

10

11


1.2.5 ESTRUCTURAS DE CONTROL. El concepto de flujo de control a través 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 métodos que permiten salir del flujo lineal, a través del uso de las llamadas estructuras de control. Las estructuras de control son fundamentales en el diseño de un algoritmo computacional, pues son métodos para especificar el orden en que las instrucciones de un algoritmo se ejecutarán. Las estructuras de control son:   

Secuenciales: Sucesión simple de dos o más instrucciones o sentencias (una tras otra). De Selección o Condicionales: Bifurcación condicional de una o más instrucciones. De Repetición o Iteración: Repetición de una instrucción mientras se cumple una condición.

1.3 PASOS PARA CREAR UN ALGORITMO. Para diseñar un algoritmo se debe comenzar por identificar las tareas más importantes para resolver el problema y disponerlas en el orden en que han de ser ejecutadas. Los pasos para crear un algoritmo son: 





Análisis del problema. Para resolver cualquier problema, se debe comprenderlo completamente, es una actividad que debe realizarse con mucha responsabilidad, nunca se debe diseñar un algoritmo sin haberse hecho un análisis completo del problema. Diseño del algoritmo. Se describen los pasos para resolver el problema. Es mejor solucionar problemas pequeños. Los pasos generales son: o Lectura de datos. o Validación de datos. o Lógica de negocio: Cálculos, lógica / comparación, 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.


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

El proceso se refiere a los cálculos 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 pseudocódigo. 1.4 REPRESENTACIÓN GRÁFICA DE LOS ALGORITMOS. 1.4.1 DESCRIPCIÓN NARRADA. Este algoritmo se caracteriza porque sigue un proceso de ejecución común y lógico, se describe textualmente paso a paso cada una de las actividades a realizarse. Ejemplo: Algoritmo para asistir a clases: 1. Levantarse 2. Bañarse 3. Vestirse 4. Desayunar 5. Cepillarse los dientes 6. Salir de casa 7. Tomar el autobús 8. Llegar a la Universidad 9. Buscar el aula 10. Ubicarse en un asiento 1.4.2 DIAGRAMAS DE FLUJO O FLUJOGRAMAS. Son la representación gráfica de la solución algorítmica de un problema. Para diseñarlos se utilizan determinados símbolos o figuras, que representan una acción dentro de la solución. Se utiliza unos símbolos normalizados, con los pasos del algoritmo escritos en el símbolo adecuado, los símbolos se unen con flechas, denominadas líneas de flujo, que indican el orden en que los pasos deben ser ejecutados. Para su elaboración se sigue las siguientes reglas:

12

13

1. 2. 3. 4.


Se escribe de arriba hacia abajo y de izquierda a derecha. Siempre se usan flechas verticales u horizontales, jamás curvas. Evitar cruce de flujos. En cada paso expresar una acción concreta.

La secuencia de un flujo normal en una solución de un problema es: 1. Un inicio. 2. Una lectura o entrada de datos. 3. El proceso de datos. 4. Una salida de información. 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 Rápida comprensión de las relaciones. o Análisis efectivo de las diferentes secciones del algoritmo. o Pueden usarse como modelos de trabajo en el diseño de nuevos algoritmos. o Comunicación con el usuario. o Documentación adecuada de los algoritmos. o Codificación eficaz de los algoritmos. o Depuración y pruebas ordenadas de los algoritmos. Entre las desventajas podemos anotar: o Diagramas complejos y detallados suelen ser laboriosos en su planteamiento y diseño. o Acciones a seguir tras la salida de un símbolo de decisión, pueden ser difíciles de seguir si existen diferentes caminos. o No existen normas fijas para la elaboración de los diagramas de flujo que permitan incluir todos los detalles que el usuario desee introducir.


o Diagramas de flujo muy grandes son difíciles de leer y seguir su secuencia. 1.4.3 PSEUDOCÓDIGO. Pseudo = falso. El pseudocódigo no es realmente un código, sino una imitación y una versión abreviada de instrucciones reales de los lenguajes de programación. Es una técnica para diseño de algoritmos, que permite definir las estructuras de datos, las operaciones que se aplicarán a los datos y la lógica 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 programación. Se concibió para superar las dos principales desventajas de los diagramas de flujo: lento de crear y difícil de modificar sin un nuevo dibujo. La principal ventaja es que, como se parece a un lenguaje de programación, la evolución de pseudocódigo hacia un lenguaje de programación es más fácil, 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 programación. Mediante un simple e intuitivo pseudolenguaje en español (complementado con un editor de diagramas de flujo), le permite centrar su atención 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 didácticos [14]. PSeInt, es un pseudoentorno de desarrollo integrado (pseudo IDE) en español, cuyas principales características son:  

 

Un editor, que proporciona el medio para introducir el texto y los símbolos que constituyen el pseudocódigo fuente. Un compilador que convierte el pseudocódigo en código de un lenguaje de programación 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 ejecución. Ayuda (manuales, tutoriales, ejemplos, etc.) integrada.

14


15

 

Convierte diagramas de flujo en pseudocódigo y viceversa. Convierte pseudocódigo a código de varios lenguajes de programación, 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 guía de cómo crear algoritmos con la ayuda de PSeInt. La configuración 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 pseudocódigo en PSeInt se parezca a un lenguaje de programación, se trata de que la transición a un lenguaje de programación sea más fácil.


PARTE II: ALGORITMOS EN PSeInt. 2 PROGRAMACIÓN ESTRUCTURADA. Programación Estructurada es una técnica 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: Sucesión simple de dos o más instrucciones, sentencias o acciones (una tras otra). Selectivas o Condicionales: Bifurcación condicional de una o más instrucciones. Repetitivas o Iterativas: Repetición de una instrucción mientras se cumple una condición.

Escribiremos los algoritmos bajo el paradigma de la programación estructurada, para ello usaremos un pseudolenguaje cuyas características son:  Sintaxis sencilla (sin la complejidad de los lenguajes de programación).  Manejo de las estructuras básicas de control.  Sólo 3 tipos de datos básicos: o Numérico: Números, tanto enteros como reales. Para separar decimales se utiliza el punto. Ejemplos: 12 23 0 -2.3 3.14 o Lógico: Sólo 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 carácter y dobles para cadena de caracteres o texto) 

Estructuras de datos: Arreglos.

Todo algoritmo en pseudocógido tiene la siguiente estructura general: Proceso ; ; . . . ; FinProceso

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 más 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 selección múltiple y/o lazos mientras, repetir o para. Se pueden introducir comentarios luego de una instrucción, o en líneas separadas, mediante el uso de la doble barra ( // ). Todo lo que precede a //, hasta el fin de la línea, no será tomado en cuenta al interpretar el algoritmo. 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 sólo de letras y números, comenzando siempre con una letra. o Las constantes de tipo carácter se escriben entre comillas ( " ). o En las constantes numéricas, el punto ( . ) es el separador decimal. o Las constates lógicas son Verdadero y Falso.



Definición de variables. La instrucción Definir permite explicitar el tipo de una o más variables. Esta definición puede ser opcional u obligatoria, aunque la asignación de tipos a los datos tiene dos objetivos principales: 1. Detectar errores de operaciones en los programas durante la fase de codificación. 2. Determinar cómo se ejecutarán las operaciones entre datos.


Una operación de suma no tiene sentido con caracteres de texto, sólo con números. Por consiguiente, si el compilador detecta una operación de suma de dos caracteres normalmente producirá un error. Incluso entre tipos numéricos la operación de suma se almacena de modo distinto, ya que los números 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 operación de suma. A los lenguajes que exigen que todos los datos utilizados deban tener sus tipos declarados explícitamente se los conoce como “fuertemente tipados”. El tipo de un dato puede ser convertido bajo ciertas condiciones a otro tipo. Este mecanismo explícito de conversión de tipos de datos se suele denominar “CAST”. La sintaxis es: Definir , , … , 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).



Asignación.

La instrucción de asignación permite almacenar un valor en una variable. <- ; Al ejecutarse la asignación, primero se evalúa la expresión de la derecha y luego se asigna el resultado a la variable de la izquierda. El tipo de la variable y el de la expresión deben coincidir. Ejemplo: var<-1.0; // asigna 1.0 a var acumulador<-acumulador +1; // incrementa en 1 el acumulador

18

19




Entradas.

La instrucción Leer permite ingresar información por teclado. Leer , , ... , ; Esta instrucción lee N valores desde el ambiente (en este caso el teclado) y los asigna a las N variables mencionadas. Pueden incluirse una o más variables, por lo tanto el comando leerá uno o más valores. Ejemplo: Leer cantidad; Leer valor1, valor2, valor3; 

Salidas.

Las instrucciones Escribir y Escribir Sin Saltar permiten mostrar valores al ambiente. Escribir , , ... , ; Escribir Sin Saltar , , ... , ; Estas instrucciones imprimen en pantalla los valores obtenidos de evaluar N expresiones. Dado que puede incluir una o más expresiones, mostrará uno o más valores. Con Escribir, el cursor luego de imprimir, avanzará a la siguiente línea, si se usa Escribir Sin Saltar, el cursor se mantendrá en la misma línea. Ejemplo: Escribir “Ingrese el nombre: ”; Escribir “El Resultado es: ” , resp*2 ; 

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


Borrar Pantalla; La instrucción "Esperar Tecla" detiene su algoritmo hasta que el usuario presione una tecla cualquiera de su teclado. Ejemplo: Esperar Tecla; La instrucción "Esperar" también puede utilizarse para pausar el algoritmo durante un intervalo de tiempo predefinido, indicando a continuación de la palabra clave la longitud y unidad de dicho intervalo. Las unidades válidas son Segundos y Milisegundos. Ejemplo: Esperar 3 Segundos; 

Arreglos. Los arreglos son estructuras de datos homogéneas (todos sus datos son del mismo tipo) que permiten almacenar un determinado número de datos bajo un mismo identificador, para luego referirse a los mismos utilizando uno o más subíndices. Para utilizar un arreglo, primero es obligatorio su dimensionamiento, es decir, definirlo declarando los rangos de sus subíndices, lo cual determina cuantos elementos se almacenarán y como se accederá a los mismos. Con mayor detalle se estudiará los arreglos más adelante.



Dimensionamiento. Pseudocódigo: La instrucción Dimension permite definir un arreglo, indicando sus dimensiones. Dimension (,...,); Esta instrucción define un arreglo con el nombre indicado en y N dimensiones. Los N parámetros indican la cantidad de dimensiones y el valor máximo de cada una de ellas. La cantidad de dimensiones puede ser una o más, y la máxima cantidad de elementos debe ser una expresión numérica positiva. Se pueden definir más de un arreglo en una misma instrucción, separándolos con una coma (,).

20


21

Dimension (,..,),..,(,..,); 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 gráfico que se usa en diagrama de flujo para la definición de variables y dimensionamiento de arreglos es el mismo que se utiliza para la asignación. 

Operadores y Funciones. PSeInt dispone de un conjunto básico de operadores y funciones que pueden ser utilizados para la construcción de expresiones más o menos complejas. Las siguientes tablas exhiben la totalidad de los operadores de este lenguaje reducido: Operador

Significado

Ejemplo

Relacionales >

Mayor que

3>2

<

Menor que

'ABC'<'abc'

=

Igual que

4=3

<>

Diferente que

4<>3

<=

Menor o igual que

'a'<='b'

>=

Mayor o igual que

4>=5

&

Conjunción (y / and).

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

|

Disyunción (o / or).

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

~

Negación (no / not).

~(2<5) //falso

+

Suma

suma <- suma+1

*

Multiplicación

area <- base * altura

-

Resta

stock <- disponible - venta

/

División

porc <- 100 * parte / total

^

Potenciación

sup <- 3.41 * radio ^ 2

%

Módulo (resto de la división resto <- num % 2 entera)

Lógicos

Algebraicos


22

La jerarquía de los operadores matemáticos es igual a la del álgebra, aunque puede alterarse mediante el uso de paréntesis. Para el caso de los operadores & y |, la evaluación se realiza en cortocircuito, es decir, que si dos expresiones están unidas por el operador & y la primera se evalúa como Falso, o están unidas por el operador | y la primera se evalúa como Verdadero, la segunda no se evalúa ya que no altera el resultado. A continuación se listan las funciones integradas disponibles: Función 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 Raíz Cuadrada de X Valor Absoluto de X Logaritmo Natural de X Función 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 más 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 mayúsculas Retorna una copia de la cadena S con todos sus caracteres en minúsculas Retorna una nueva cadena que consiste en la parte de la cadena S que va desde la posición X hasta la posición 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)

Recibe una cadena de caracteres que contiene un número y devuelve una variable numérica con el mismo. Recibe un real y devuelve una variable numérica con la representación como cadena de caracteres de dicho real.

Como habíamos mencionado anteriormente, un problema se puede dividir en acciones elementales o instrucciones, usando un número limitado de estructuras de control (básicas) y sus combinaciones que pueden servir para resolver dicho problema. 2.1 ESTRUCTURA SECUENCIAL. Se caracteriza porque una acción se ejecuta detrás de otra. El flujo del programa coincide con el orden físico en el que se han ido poniendo las instrucciones. Dentro de este tipo podemos encontrar operaciones de inicio/fin, inicialización de variables, operaciones de asignación, cálculo, sumarización, etc. Este tipo de estructura se basa en las 5 fases de que consta todo algoritmo o programa: 1. 2. 3. 4. 5.

Definición de variables (Declaración) Inicialización de variables. Lectura de datos. Cálculo. Salida.

Ejemplo 1: Se desea encontrar la longitud y el área de un círculo de radio ingresado por teclado. Solución. El objetivo del ejercicio es encontrar la longitud y el área de un círculo con un radio ingresado por teclado. Las salidas serán entonces la longitud y el área. (Fase 5 del algoritmo) Sabemos que la longitud de un círculo viene dada por la fórmula 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: Pseudocódigo: Proceso Algoritmo1


//este algoritmo calcula el área y la longitud de un círculo de radio //ingresado por teclado Definir Radio, Area, Long Como Real; //definición de variables Escribir "Ingrese el radio: "; //despliega en pantalla Leer Radio; //Ingresa por teclado el radio Area <- PI * Radio ^ 2; //asignación del valor del área Long <- 2 * PI * Radio ; //asignación del valor de la longitud Escribir "Area: ", Area, " Longitud: ", Long; //salida del algoritmo FinProceso

Diagrama de Flujo:

24


25

Ejemplo 2. Leer el sueldo de tres empleados y aplicarles un aumento del 10%, 12% y 15% respectivamente. Desplegar el resultado. Solución. Salidas: Sueldos finales. Entradas: Salarios de los empleados. Datos adicionales: aumentos del 10%, 12% y 15% Cálculos: Sueldo final = sueldo inicial * (1+porcentaje/100) Definición de variables: sueldoFinal1, sueldoFinal2, sueldoFinal3 = los sueldos finales sueldo1, sueldo2, sueldo3 = salarios de los empleados Pseudocódigo: Proceso Algoritmo2 //Leer el sueldo de tres empleados y aplica un aumento del 10, 12 y //15% respectivamente Definir sueldo1, sueldo2, sueldo3 Como Real; //definición 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


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


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 condición. La realización de acciones alternativas o decisiones se especifican utilizando condiciones que son verdaderas o falsas. Estas condiciones se llaman expresiones lógicas, o booleanas. Dado que las expresiones lógicas toman el valor verdadero o falso, se necesita una sentencia de control que dirija a la computadora a ejecutar una sentencia si la expresión 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 pseudocódigo es: Si Entonces Sino FinSi La estructura “Si” funciona de la siguiente manera: 1. Se evalúa la expresión lógica. 2. Si la expresión toma el valor verdadero, se ejecutará la sentencia A y el control pasará a la sentencia inmediatamente siguiente. 3. Si la expresión toma el valor falso, entonces sólo se ejecutará la sentencia B y el control pasa de nuevo inmediatamente a la siguiente sentencia del programa. La cláusula sino es optativa, en ese caso, si la condición es falsa no se ejecuta ninguna instrucción y la ejecución del programa continúa con la instrucción siguiente. .


Ejemplo 3. Construir un algoritmo que lea la calificación de un alumno en un examen, escriba "Aprobado" en caso que esa calificación fuese mayor o igual que 7. Solución. Salidas: Mensaje de aprobado si se cumple la condición. Entradas: Calificación. Datos adicionales: Un alumno aprueba si la calificación es mayor o igual que 7. Variables: Cal = calificación Pseudocódigo: Proceso Algoritmo3 //lee la calificación de un alumno y escribe "Aprobado" si es mayor o //igual que 7 Definir cal Como Real; //declaro la variable Escribir "Ingrese la calificación del alumno: "; Leer cal; Si cal>=7 Entonces Escribir "Aprobado"; FinSi FinProceso. Diagrama de flujo:

28


29

Ejemplo 4. Dada la calificación de un alumno en un examen, escriba "Aprobado" si su calificación es mayor o igual que 7 y "Reprobado" en caso contrario. Pseudocódigo: 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 calificación del alumno: "; Leer cal; Si cal>=7 Entonces Escribir "Aprobado"; Sino


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. Pseudocódigo: Proceso Algoritmo5 //aumento el 15% si su sueldo es inferior a $1000 y 12% en caso //contrario

30


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 LÓGICAS.


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 condición. Se pueden clasificar en simples y complejas. Las simples son las que usan operadores relacionales y las complejas las que usan operadores lógicos. Ejemplo 6: Operador lógico Y (“&”): Una escuela aplica dos exámenes 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 exámenes es aceptado; en caso contrario es rechazado. Pseudocódigo: 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


33

En este ejemplo, nótese que también se usa operadores relacionales. Por lo general cuando hay operadores lógicos, éstos van acompañados de operadores relacionales. Ejemplo 7: Operador lógico O (“|”): Una escuela aplica dos exámenes a sus aspirantes, por lo que cada uno de ellos obtiene dos calificaciones denotadas como calif1 y calif2. El aspirante que obtenga una calificación mayor o igual que 9 en cualquiera de los exámenes es aceptado; en caso contrario es rechazado. Pseudocódigo: 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


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

La instrucción del ejemplo 7 equivale a OR ya que nos dice que puede ser en cualquiera de los exámenes no necesariamente en los dos. En ejemplo 6 la palabra ambos equivale a seleccionar la instrucción AND. Si la instrucción nos dijera que obtenga una nota en cualquiera de los exámenes pero no en ambos, nos estaría indicando una instrucción 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 exámenes, solo en uno de los dos.

34


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 solución de problemas encontramos numerosos casos en los que luego de tomar una decisión y marcar el camino correspondiente a seguir, es necesario tomar otra decisión. 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. Solución. 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 (sólo 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: número de horas trabajadas y pago por hora normal. Definición 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


Pseudocódigo: 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 más 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:


Ejemplo 9. Dados los datos A, B y C que representan números enteros diferentes, construir un algoritmo para escribir estos números en forma descendente. Este es un ejemplo de los algoritmos conocidos como de Lógica Pura, ya que poseen muchas decisiones y muchas bifurcaciones.

38


39

Observación: Para ordenar números no es un algoritmo eficiente, pero nos sirve para ejemplarizar estructuras anidadas. Solución: Salida: A, B y C ordenados descendentemente. Entradas: A, B y C. La dinámica del problema es comparar dos números a la vez para conocer cuál es el mayor. Pseudocódigo: Proceso Algoritmo9 //ordenar 3 números de mayor a menor Definir a,b,c Como Entero; Escribir "Ingrese 3 números: "; Leer a,b,c; Escribir "Los números 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


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 SELECCIÓN MÚLTIPLE “SEGÚN”. Con frecuencia es necesario que existan más de dos elecciones posibles. Este problema se podría resolver por estructuras selectivas anidadas o en cascada, pero si el número de alternativas es grande puede plantear serios problemas de escritura y de legibilidad.

40


41

Usando la estructura de decisión múltiple se evaluará una expresión que podrá tomar n valores distintos, 1, 2, 3,…,n y según que elija uno de estos valores en la condición, se realizará una de las n acciones o lo que es igual, el flujo del algoritmo seguirá sólo un determinado camino entre los n posibles. Esta estructura se representa por un selector el cual si toma el valor 1 ejecutará la acción A, si toma el valor 2 ejecutará la acción B, si toma el valor N realizará la acción N. La estructura de selección múltiple se implementa con la sentencia Según, cuyo diagrama de flujo y pseudocódigo son: Diagrama de flujo:

Pseudocódigo: Segun Hacer : ,: <...> De Otro Modo: FinSegun Reglas: o Esta instrucción permite ejecutar opcionalmente varias acciones posibles (distintas entre si), dependiendo del valor almacenado en una variable de tipo numérico. o Al ejecutarse, se evalúa el contenido de la variable y se ejecuta la secuencia de instrucciones asociada con dicho valor. o Cada opción está formada por uno o más números separados por comas, dos puntos y una secuencia de instrucciones.


o Si una opción incluye varios números, la secuencia de instrucciones asociada se debe ejecutar cuando el valor de la variable es uno de esos números. o Opcionalmente, se puede agregar una opción final, denominada De Otro Modo, cuya secuencia de instrucciones asociada se ejecutará sólo si el valor almacenado en la variable no coincide con ninguna de las opciones anteriores. Ejemplo 10: Escribir un algoritmo tal que si opc=1 realice la suma, si opc=2, el producto, si opc=3, la división y 0 en cualquier otro caso, despliegue el resultado: Pseudocódigo: //Ejemplo de estructura Segun Proceso Algoritmo10 Definir num1, num2, opc Como Entero; Definir resp Como Real; resp <-0; Escribir "Ingrese una opción: 1 (Suma), 2 (Producto), 3 (División) :"; Leer opc; Escribir "Ingrese los dos números 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


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 categoría y el sueldo de un trabajador, calcule el aumento correspondiente teniendo en cuenta la siguiente tabla. Imprimir la categoría del trabajador y el nuevo sueldo.


Incrementos Categoría Aumento 1 15% 2 10% 3 8% 4 7% Pseudocódigo: Proceso Algoritmo11 //ejemplo de estructura Segun Definir cat Como Entero; Definir sueldo, inc, nuevoSueldo Como Real; Escribir "Ingrese la categoría: "; 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 "Categoría: ",cat,", nuevo sueldo: ",nuevoSueldo; FinProceso Diagrama de Flujo:

2.3 ESTRUCTURAS REPETITIVAS O ITERATIVAS. Las computadoras están especialmente preparadas para ejecutar tareas repetidamente. Los cálculos simples o la manipulación de pequeños conjuntos de datos se pueden realizar fácilmente 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 repetición del cuerpo del bucle se denomina iteración.


Las estructuras repetitivas básicas 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 número determinado de veces, y cuyo número se conozca por anticipado. Para aplicaciones de este tipo se utiliza la sentencia Para. Esta sentencia requiere que conozcamos por anticipado el número de veces que se ejecutarán las sentencias del interior del bucle. En la siguiente figura se muestra el diagrama de flujo de la estructura Para:

El pseudocódigo es: Para <- Hasta (Con Paso ) Hacer FinPara Al ejecutarse la sentencia Para la primera vez, el valor se asigna a la variable , denominada variable de control, y a continuación se ejecuta las sentencias de instrucciones que forman el cuerpo del bucle. Al llegar al final del bucle (FinPara), se incrementa la variable en unidades y se verifica si el valor almacenado en es mayor que el valor ; en caso negativo se vuelve a ejecutar todas las sentencias del interior del bucle hasta que la variable de control sea mayor que el valor 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 iteración. Si se omite la cláusula Con Paso , la variable se incrementará en uno.

46


47

Es común usar en las estructuras repetitivas los contadores y acumuladores que los describimos a continuación: 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 acción. Los contadores se utilizan con la finalidad de contar sucesos o acciones internas de un bucle; deben realizar una operación de inicialización y posteriormente las sucesivas de incremento o decremento del mismo. La inicialización consiste en asignarle al contador un valor. Se situará antes y fuera del bucle. Representación: <- + ; Si en vez de incremento es decremento se coloca un menos en lugar del más. 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. Representación: <- + ; 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. Pseudocódigo: Proceso Algoritmo12 //Ejemplo estructura Para Definir i,suma Como Entero; //inicializo el acumulador


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 números enteros y escribir el resultado. Pseudocódigo: // Calcula el promedio de una lista de N datos Proceso Algoritmo13 Definir i, numDatos Como Entero;

48


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:


2.3.2 ESTRUCTURA ITERATIVA “MIENTRAS”. La estructura iterativa Mientras es aquella en la que el número de iteraciones no se conoce por anticipado y el cuerpo del bucle se repite mientras se cumple una determinada condición. Por esta razón, se lo conoce como bucle condicional. El diagrama de flujo y pseudocódigo de la estructura iterativa mientras son:

50

51


Diagrama de flujo:

Pseudocódigo: Mientras Hacer FinMientras Cuando la sentencia mientras se ejecuta, lo primero que sucede es la evaluación de la expresión lógica . Si se evalúa como falsa, ninguna acción se realiza y el programa sigue en la siguiente sentencia después del bucle. Si la expresión lógica se evalúa como verdadera, entonces se ejecuta el cuerpo del bucle y se evalúa de nuevo la expresión lógica , es decir, se puede ejecutar el bucle, cero o más veces. Este proceso se repite mientras la expresión lógica sea verdadera. Después de cada iteración la expresión lógica se evalúa y se verifica de nuevo; si cambia de verdadera a falsa la sentencia mientras finaliza. Mientras que la condición 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 condición haciendo que su valor pase a falso. Si la expresión nunca cambia de valor, entonces el bucle no termina nunca y se denomina bucle o loop infinito (en general, esta situación no es deseable), a fin de evitarlo, las instrucciones del cuerpo del bucle deben contener alguna instrucción que modifique la o las variables involucradas en la expresión lógica , de modo que sea falsa en algún momento y así finalice la ejecución del ciclo. Ejemplo 14. Calcular la suma de los cuadrados de los primeros 100 números enteros y escribir el resultado. Solución. Como recordarás, resolvimos este ejercicio en la lección anterior pero utilizando la estructura Para. Ahora lo haremos con la estructura Mientras.


En este caso, se necesita un contador (un índice), para llevar la cuenta de las veces que entramos al cuerpo del bucle. También 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 además nos sirve para compararla con el valor dado en la condición, cuando no se cumple la condición, se sale del ciclo. Pseudocódigo: //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

En las estructuras cíclicas condicionales es común controlar los ciclos con centinelas y banderas. 2.3.2.1

CENTINELAS.

En un bucle mientras controlado por tarea, la condición mientras especifica que el cuerpo del bucle debe continuar ejecutándose 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


calificación válida y cuando aparezca este valor se terminará de ejecutar el bucle. Si la lista de datos son números positivos, un valor centinela puede ser un número negativo. Ejemplo 15. Suponga que debemos obtener la suma de los gastos que hicimos en nuestro último viaje, pero no sabemos exactamente cuántos fueron. Solución: Si definimos gasto1, gasto2, gasto3, ...., -1 donde gastoi es el gasto número i y sumaGasto es el acumulador de gastos efectuados. -1 es el centinela de fin de datos. Pseudocódigo: //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


55

2.3.2.2

BANDERAS.

Conocidas también como interruptores, switch, flags o conmutadores, son variables que pueden tomar solamente dos valores durante la ejecución del


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 están simulando un interruptor abierto/cerrado o encendido/apagado. Ejemplo 16: Leer un número entero N y calcular el resultado de la siguiente serie: 1 - 1/2+ 1/3 - 1/4+.... +/- 1/N. Pseudocódigo: //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:


2.3.3 ESTRUCTURA ITERATIVA “REPETIR”.

58

59


La estructura iterativa Repetir es una bucle condicional como lo es también la estructura Mientras. Se usa cuando el número de iteraciones no se conoce por anticipado (lo cual si se conoce en la estructura Para). La diferencia entre ambas es que la condición se sitúa al inicio (Mientras) o al final (Repetir) de la secuencia de instrucciones. Entonces, en el primero, el bucle continúa mientras la condición es verdadera (la cual se comprueba antes de ejecutar la acción, es decir se ejecuta cero o más veces) y en el segundo, el bucle continúa hasta que la condición se hace verdadera (la condición se comprueba después de ejecutar la acción, es decir, se ejecutará al menos una vez). El diagrama de flujo de la estructura Repetir es el siguiente:

El pseudocódigo de la estructura Repetir es: Repetir Hasta Que Al ejecutarse esta instrucción, la secuencia de instrucciones que forma el cuerpo del ciclo se ejecuta una vez y luego se evalúa la condición . Si la condición es falsa, el cuerpo del ciclo se ejecuta nuevamente y se vuelve a evaluar la condición. Esto se repite hasta que la condición sea verdadera. Note que, dado que la condición se evalúa al final, las instrucciones del cuerpo del ciclo serán ejecutadas al menos una vez. Además, a fin de evitar ciclos infinitos, el cuerpo del ciclo debe contener alguna instrucción que modifique la o las variables involucradas en la condición de modo que en algún momento la condición sea verdadera y se finalice la ejecución del ciclo. 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


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 números enteros y escribir el resultado. Solución. 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 número de veces que se ingresará al mismo. A diferencia de la estructura Mientras, la condición ahora estará colocada al final del bucle para que primero se ejecute la instrucción y luego se verifique si la condición se cumple. Esto quiere decir, que en esta estructura el bucle se realizará por lo menos una vez. También podrás observar que la condición está al revés, porque el bucle se repite hasta que la condición se cumpla. En el bucle Mientras, la condición se evaluaba mientras era verdadera. Pseudocódigo: //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


61

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

Ejemplo 18. Se desea calcular la suma de N números ingresados por el usuario, hasta que él decida no ingresar más números. Pseudocódigo: //Ejemplo estructura Repetir con centinelas Proceso Algoritmo18 Definir suma, num Como Real;;


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

62

63


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 sólo puede contener un valor a la vez. Una variable de tipo estructurado consiste en toda una colección de casillas de memoria. Los tipos de datos estudiados: entero, real, carácter, lógico son considerados como datos de tipo simple, puesto que una variable que se define con alguno de estos tipos sólo puede almacenar


un valor a la vez, es decir, existe una relación de uno a uno entre la variable y el número de elementos (valores) que es capaz de almacenar. En cambio un dato de tipo estructurado, puede almacenar más de un elemento (valor) a la vez, con la condición 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 colección de datos que se caracterizan por su organización y las operaciones que se definen en ella. Las estructuras de datos tienen en común que un identificador o nombre, puede representar a múltiples datos individuales. Los datos de tipo estándar pueden ser organizados en diferentes estructuras de datos: estáticas y dinámicas. 

Estructura de Datos Estáticas. Son aquellas en las que se asigna una cantidad fija de memoria cuando se declara la variable y no puede ser modificada durante la ejecución del programa. Corresponden a este tipo los arreglos y registros.



Estructuras de Datos Dinámicas. Son aquellas en las que el espacio ocupado en memoria puede ser modificado en tiempo de ejecución. Corresponden a este tipo las listas, árboles y grafos. Estas estructuras no son soportadas en todos los lenguajes. La elección de la estructura de datos idónea 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 colección 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 número 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 posición relativa en el arreglo.

En resumen, un arreglo es una colección finita, homogénea y ordenada de elementos.

64

65

  


Finita. Todo arreglo tiene un límite, es decir, debe determinarse cuál será el número máximo de elementos que podrán formar parte del arreglo. Homogénea. Todos los elementos del arreglo deben ser del mismo tipo. Ordenada: Se puede determinar cuál es el primer elemento, el segundo, el tercero,...., y el n-ésimo elemento.

Los arreglos se clasifican de acuerdo con el número de dimensiones que tienen. Así se tienen los arreglos:   

Unidimensionales (vectores). Bidimensionales (tablas o matrices). Multidimensionales (tres o más dimensiones).


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 también que hay 100 calificaciones. Con lo estudiado hasta el momento, deberíamos 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, ¿cuántas instrucciones involucra? Definir nota1, nota2, nota3,.........nota100 Como Entero; (En la declaración real de un algoritmo en pseudocódigo no pueden usarse puntos suspensivos, por lo tanto serán 100 veces). En la fase de lectura de datos, serán también 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á también 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 después de muchísimas líneas de código..... ¡Todavía falta ordenar la lista de calificaciones en orden ascendente!

66

67


Los arreglos nos permiten ahorrar instrucciones, porque es fácil recorrer toda la lista de notas con unas pocas instrucciones. En el caso anterior, cuando el acceso a la información es secuencial, sólo 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 posición en la estructura, de esa manera se requerirá el mismo tiempo para acceder al elemento de la posición 100 que el de la posición 5. Queremos también que esta estructura se almacene en memoria principal para que su almacenaje y recuperación sea más rápida. Es por ello que existen los arreglos, que están organizados en una secuencia de elementos, todos del mismo tipo y se puede acceder a cada elemento directamente especificando su posición 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 almacenarán y como se accederá a los mismos. Al declarar un arreglo, se debe inicializar sus elementos antes de utilizarlos 

Definición y Dimensionamiento.

La instrucción Dimension permite declarar un arreglo, indicando sus dimensiones. Dimesion (,...,); Esta instrucción define un arreglo con el nombre indicado en y N dimensiones. Los N parámetros indican la cantidad de dimensiones y el valor máximo de cada una de ellas. La cantidad de dimensiones puede ser una o más, y la máxima cantidad de elementos debe ser una expresión numérica positiva. Se pueden definir más de un arreglo en una misma instrucción, separándolos con una coma (,). Dimension (,..,),..,(,..,); Es importante notar que es necesario definir un arreglo antes de utilizarlo. Ejemplo: Definir vector, matriz Como Entero; Dimension vector[100], matriz[10,20];


2.4.2.1

ARREGLO UNIDIMENSIONAL.

Un arreglo de una dimensión (también conocido como vector) es un tipo de datos estructurado compuesto de un número de elementos finitos, tamaño fijo y elementos homogéneos que se almacenan bajo un mismo nombre, y se diferencian por la posición que tiene cada elemento dentro del arreglo de datos. Finitos indica que hay un último elemento, tamaño fijo significa que el tamaño del arreglo debe ser conocido en tiempo de compilación y homogéneo 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 número entero denominado índice del arreglo, que identifica la posición 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 válidos 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 cuántos elementos tendrá el arreglo y además, de qué modo podrán accederse esos componentes.

68


69

valoro valor1 valor2 ………... valor97 valor98 valor99



Componentes

Definición 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 resolución de un problema son: o Lectura/ Escritura, o Asignación. o Actualización (inserción, eliminación, modificación). o Recorrido (acceso secuencial). o Ordenación. o Búsqueda. 

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, sólo que en lugar de leer el componente del arreglo, lo escribimos. Ejemplo:


Para i <- 0 Hasta 99 Con Paso 1 Hacer Escribir vector[i]; FinPara 

Asignación. 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 posición 1 del arreglo vector vector[10] <- vector[1] / 2; //asigna una operación 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



Inicialización. Siempre es importante inicializar las variables y por lo tanto también 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 acción de efectuar una acción general sobre todos los elementos de ese vector.



Actualización. Incluye añadir (insertar), borrar o modificar algunos de los ya existentes. Se debe tener en cuenta si el arreglo está o no ordenado. Añadir datos a un vector consiste en agregar un nuevo elemento al final del vector, siempre que haya espacio en memoria (recordemos que el tamaño de un arreglo es fijo).

70


71

Observación. 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 sólo de una. Ejemplo19. Se desea ingresar una lista de n valores numéricos y calcular la suma, el promedio, los números mayor y menor de dicha lista Pseudocódigo: //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 tamaño 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


//inicializo los números 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 números 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]
72

73



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. Pseudocódigo: //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

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


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



2.4.3 ARREGLO BIDIMENSIONAL. Hasta ahora hemos visto cómo se puede manipular información con una sola columna o lista de entrada con los llamados vectores, o arreglos de una dimensión. Sin embargo, en numerosas ocasiones es necesario trabajar con datos que tengan más de una dimensión (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 subíndices), uno para la fila y otro para la columna. Internamente en memoria se reservan MxN posiciones consecutivas para almacenar todos los elementos del arreglo. 

Declaración de una matriz.

Ejemplo: Definir una arreglo bidimensional de 10 filas y 20 columnas de números enteros llamado matriz. Definir matriz Como Entero; Dimension matriz[10,20]; Una matriz se representa como una tabla, donde: 1≤I≤M y 1≤J≤N (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. Pseudocódigo: //Ejemplo de matrices Proceso Algoritmo21 Definir i, j, m, n, matriz1, matriz2, matriz3 Como Entero;

78


79

Escribir "Ingrese el número de filas: "; Leer m; Escribir "Ingrese el número de columnas: "; Leer n; //defino la dimensión 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


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



2.5 MODULARIDAD. Una estrategia para la resolución de problemas complejos con computadoras es la división o descomposición del problema en otros problemas más pequeños y fáciles de resolver. Estos sub problemas se implementan mediante módulos o subprogramas. Los subprogramas son una herramienta importante para el desarrollo de algoritmos y programas, de modo que normalmente un proyecto de programación 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, debería ser independiente de otros subprogramas. El descomponer un programa en módulos independientes más simples se conoce también como el método de "Divide y vencerás". ¿Cuándo es útil la modularización? Este enfoque de segmentación o modularización es útil en dos casos: 1. Cuando existe un grupo de instrucciones o una tarea específica que deba ejecutarse en más de una ocasión. 2. Cuando un problema es complejo o extenso, la solución se divide o segmenta en módulos que ejecutan partes o tareas específicas. 

Ventajas de la Programación Modular.

Las ventajas más sobresalientes de utilizar subprogramas o módulos son: o El uso de subprogramas facilita el diseño descendente y modular, que permite descomponer un problema complejo en sub problemas hasta que éstos sean concretos y fáciles de resolver. o Los procedimientos se pueden ejecutar más de una vez en un programa y en diferentes programas, ahorrando en consecuencia tiempo de programación. 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 módulo se ha escrito y comprobado, se puede utilizar en otros programas eliminando la duplicación innecesaria de código (reutilización de código). o Aumenta la facilidad de depuración y búsqueda de errores en un programa ya que éstos se pueden aislar fácilmente depurándose sus errores individualmente antes de su inclusión en bibliotecas independientes y de ser llamados en el programa principal.

82

83


o El uso de subprogramas facilita la división de tareas de programación entre un equipo de programadores. o El uso de módulos facilita la proyección y la comprensión de la lógica subyacente para el programador y el usuario. 2.5.1 PROCEDIMIENTOS Y FUNCIONES. Los subprogramas en programación estructurada se clasifican en procedimientos y funciones, que son unidades de programas diseñados para ejecutar una tarea específica. Las funciones normalmente devuelven un sólo 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 estándares y definidas por el usuario.  

Estándar. Son funciones proporcionadas por lenguaje de programación. Definidas por el usuario. Son funciones definidas el programador con el propósito de ejecutar alguna función específica, y que por lo general se usan cuando se trata de hacer algún cálculo que será requerido en varias ocasiones en la parte principal del algoritmo.

Las funciones y procedimientos están 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 función o procedimiento. Una de las características importantes y diferenciadoras de los subprogramas es la posibilidad de comunicación entre el programa principal y los subprogramas (o entre dos subprogramas). Esta comunicación se realiza a través de una lista de parámetros. Un parámetro es un medio para pasar información – valores a variables – del programa principal a un subprograma y viceversa. No es obligatorio que un subprograma utilice parámetros, ya que éstos no siempre son necesarios. Un parámetro es, prácticamente, 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 parámetros: parámetros de entrada y parámetros 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 calcularán en el


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 sólo 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 estén 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 sólo dentro del subprograma en el que están declaradas, las variables globales pueden ser utilizadas en el programa principal y en todos los subprogramas, permanecen activas durante toda la ejecución del programa. Hay que tener especial precaución al trabajar con variables globales, ya que al ser recursos compartidos todos los subprogramas pueden tener acceso simultáneo a ellas y se pueden producir errores lógicos debidos a la concurrencia. Por lo general, es una buena práctica evitar el uso de variables globales desde subprogramas a menos que sea estrictamente necesario. Las variables también pueden ser declaradas dentro de un bloque o estructura de control, y se comportarán 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 módulo en que ha sido declarada.

2.5.1.1

IMPLEMENTACIÓN DE PROCEDIMIENTOS Y FUNCIONES.

En PSeInt el pseudocódigo para la implementación de procedimientos y funciones se realiza de la siguiente manera: SubProceso variable_de_retorno argumento_2, ... ) acción 1;

<-

nombre_de_la_funcion(argumento_1,

84


85

acción 1; . . . acción n; FinSubproceso Comienza con la palabra clave SubProceso (o Función, son equivalentes) seguida de la variable de retorno, el signo de asignación, el nombre del subproceso, y finalmente, la lista de argumentos entre paréntesis, en este caso el SubProceso se denomina una función. Si el SubProceso no retorna ningún valor, se denomina procedimiento, entonces pueden omitirse el identificador variable_de_retorno y el signo de asignación, es decir, colocar directamente el nombre y los argumentos a continuación de la palabra clave SubProceso. Si el subproceso no recibe ningún valor pueden colocarse los paréntesis vacíos u omitirse, finalizando la primer línea 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 pseudocódigo. Además, 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 demás 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 expresión) que se utilizó en la llamada, por lo que las modificaciones que aplique el SubProceso no se verán reflejadas fuera de la misma. Para invocar o llamar a un SubProceso (función o procedimiento) se debe utilizar su nombre y entre paréntesis los parámetros, que podrán ser expresiones sólo si el tipo de pasaje es por referencia. Una llamada puede ser en sí una instrucción, pero si la función retorna algún valor, también puede utilizarse como operando dentro de una expresión. Ejemplo 22. Realizar una función que acepte dos números como parámetros y devuelva la suma de dichos números.


Solución. Crearemos una función llamada sumarNumeros que será llamada en el programa principal. Pseudocódigo: 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 número"; Leer num1; Escribir "Ingrese el segundo número"; Leer num2; suma<-sumarNumeros(num1,num2); Escribir "La suma es: ", suma; FinProceso En este ejemplo, vemos la definición (declaración) de una función en pseudocódigo para calcular la suma de dos números reales, los cuales son pasados al subprograma como parámetros de entrada Por Valor. La función “sumarNumeros” calcula la suma y la devuelve como un parámetro de salida y se asigna en la variable suma. Esta función la podemos invocar desde el programa principal u otra función o procedimiento. Nótese que los nombres de los parámetros en la definición

86

87


(parametro1 y parametro2) no necesariamente tienen que ser los mismos que los utilizados en la invocación (num1 y num2). Nótese también que el compilador chequeará previamente que el tipo de dato del parámetro de salida de la función (en este caso un número real) pueda ser asignado a la variable suma según su tipo. Al nombre de la función junto con la lista ordenada de sus parámetros de entrada se lo conoce como firma de la función. 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 sólo no es así, sino que la organización de un programa en funciones y/o procedimientos lo hace más fácil de escribir y depurar, además que se reutiliza código en cada llamada a una función o procedimiento. Diagrama de flujo:

Observe como dentro del programa principal se llama o invoca a la función “sumarNumeros”, se le pasa num1 y num2 como parámetros por valor y el resultado se asigna en la variable suma.


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


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 parámetros 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 sólo no es así, sino que la organización de un programa en funciones y/o procedimientos lo hace más fácil de escribir y depurar, además que se reutiliza código al llamar a las funciones o procedimientos haciendo más eficiente la escritura de un programa y el mantenimiento del mismo. Diagrama de flujo:


Note como en el programa principal se llama o invoca al procedimiento llamado “bienvenida”. Ejemplo 24. Realizar un algoritmo que calcule las operaciones matemáticas básicas (suma, resta, multiplicación y división) de dos números. Use funciones y procedimientos. Pseudocódigo: 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


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 división es: ", dividir(num1,num2); Sino Escribir "El resultado de la división es: Denominador igual a 0"; FinSi FinSubProceso Proceso Algoritmo24 Definir num1,num2 como Real; num1<-0; num2<-0; Escribir "CALCULADORA"; Escribir "Ingrese el primer número: ";


Leer num1; Escribir "Ingrese el segundo número: "; 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 matemáticas básicas calculadas con funciones dentro del procedimiento. Note que en el programa principal no existe lógica de negocio, solamente debe haber escritura, lectura, validación de datos de entrada y llamadas a funciones y/o procedimientos. Diagrama de flujo:

92

93



Ejemplo 25. Realice la suma de dos matrices usando funciones y/o procedimientos, ingresar las dimensiones por teclado. Pseudocódigo: //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


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


FinPara FinSubProceso Proceso Algoritmo25 Definir i,j,m,n,matriz1,matriz2,matriz3 Como Entero; Escribir "Ingrese el número de filas: "; Leer m; Escribir "Ingrese el número de columnas: "; Leer n; //defino la dimensión 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, habíamos realizado el mismo ejercicio, note como ahora al usar funciones y/o procedimientos se hace más fácil de leer el programa, además de ser eficiente la escritura del mismo al no reescribir por ejemplo el mismo código 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:


98

99



100

Ejemplo 26. Realizar un algoritmo que ingrese una cadena de caracteres y cuente el número de vocales. Pseudocódigo: SubProceso cantVocales <- cuentaVocales ( frase ) Definir cantVocales, i, j como Entero; Definir vocales como Caracter; // pasamos toda la frase a minúsculas 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;


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, además se crea una función para contar el número de vocales de una frase. Diagrama de flujo:


102

2.6 RECURSIVIDAD. Recursividad, es el proceso de resolver un problema reduciéndolo a uno o más sub problemas que son idénticos en su estructura al problema original y más simples de resolver. Una vez que se ha subdividido el problema original, se utiliza la misma técnica de descomposición 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 más subdivisiones, y la solución 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 función de sí mismo. En otras palabras, un método es recursivo si contiene invocaciones a sí mismo. La recursión aparece en la vida diaria, en problemas matemáticos, en estructuras de datos y en muchos otros problemas. Es un proceso extremadamente potente, por lo que hay que saber cuándo y cómo aplicarla. Es una poderosa herramienta de programación como alternativa a algoritmos iterativos (cuando es “casi” imposible resolver con estructuras iterativas).


103

En resumen, la recursividad consiste en:  

En el cuerpo de sentencias del SubPrograma (función) se invoca al propio SubPrograma (función) para resolver “una versión más pequeña” del problema original. Habrá un caso (o varios) tan simple que pueda resolverse directamente sin necesidad de hacer otra llamada recursiva.

En general el pseudocódigo de un algoritmo recursivo es el siguiente: SubProceso variable_de_retorno <- nombre_funcion_recursiva(argumento_1, argumento_2, ... ) acción 1; acción 2; . acción 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 condición 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 más pequeños que terminarán en el caso base. Ejemplo 27. Calcular el factorial de un número entero usando un algoritmo recursivo. Solución. Recordemos la definición 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


Si n > 1 Retornar n * factorial(n – 1) Sea factorial(n) la función que calcula el factorial de un número 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 Pseudocódigo: //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 número entero"; Escribir "Ingrese en valor de n: "; Leer n; Escribir "El factorial de ",n," es ", factorial(n); FinProceso

Diagrama de flujo:

104

105


A veces, podemos encontrar una solución iterativa simple, que haga que el algoritmo sea más eficiente.


106

Ejemplo 28. Calcular el factorial de un número entero usando un algoritmo iterativo. Solución. Se define el factorial como: n! = n * (n-1)! , si n > 1 1! = 1 De acuerdo con esta definición, 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 definición iterativa de factorial. Sea factorial(n) la función que calcula el factorial de un número entero n, sea n=4, entonces: factorial (4) = 4*3*2*1 = 24 Pseudocódigo: 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 número entero";


107

Escribir "Ingrese en valor de n: "; Leer n; Escribir "El factorial de ",n," es ", factorial(n); FinProceso

Diagrama de flujo:




108

Ventajas. La principal ventaja es la simplicidad de comprensión y su gran potencia, favoreciendo la resolución de problemas complejos de manera natural, sencilla y elegante; y facilidad para comprobar y convencerse de que la solución del problema es correcta. El valor de la recursividad reside en el hecho de que se puede usar para resolver problemas sin fácil solución 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 número de llamadas recursivas. (factorial(n) genera n llamadas recursivas).

Observación. La recursividad se debe usar cuando sea realmente necesaria, es decir, cuando no exista una solución iterativa simple. 2.7 ESTILO DE PROGRAMACIÓN.

109


El buen estilo de programación es, sin lugar a dudas, una de las características más importantes que debe tener un buen programador. Un programa con buen estilo es más fácil 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 programación. 









Comentarios. La legibilidad de los programas aumenta considerablemente utilizando comentarios. Un comentario es un texto explicativo más o menos largo, situado en el programa e ignorado por el compilador. Los comentarios son considerados parte del código fuente por más que sean ignorados en las etapas de compilación y ejecución, y tienen importancia primordial en las fases de análisis, puesta a punto y mantenimiento. Los comentarios son una parte fundamental de la documentación de un programa, ya que ayudan al programador y a otras personas a la comprensión del mismo. No es raro encontrar programas en los cuales los comentarios ocupan más lugar, incluso, que las propias instrucciones. Elección 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. Identación. Aunque no suele ser requerido por los compiladores de los lenguajes de alto nivel, es una práctica habitual realizar una identación (o tabulación) en cada uno de los bloques y unidades de programas fundamentales para mejorar la legibilidad del código fuente. Espacios y Líneas en Blanco. Con el mismo fin de mejorar le legibilidad y comprensibilidad del programa es recomendado utilizar espacios en blanco antes y después de un operador, así como también dejar una línea en blanco entre partes importantes o que estén lógicamente separadas. Validación. 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 ejecución.


110

BIBLIOGRAFÍA. 1 “Fundamentos de Informática”. Luis A. Ureña y otros. Editorial Alfaomega rama, 1999. 2 “Fundamentos de Programación”. Libro de Problemas. Luis Joyanes Aguilar, Rodríguez Baena y Fernández Azuela. 1996. 3 “Pascal y Turbo Pascal enfoque práctico”. Luis Joyanes Aguilar. Editorial Mc Graw Hill, 1996. 4 “Lógica Simbólica”. Luis Joyanes Aguilar y Angel Hermoso. Editorial Mc Graw Hill. 5 “Programación en Pascal”. Irving M. Copi. Editorial C.E.C.S.A., 4ª Edición. 6 “Cómo programar en C/C++”. Sanford Leestma y Larry Nyhoff. Editorial Prentice Hall, 1999. 7 “Introducción 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 “Computación. Metodología, Lógica Computacional y Programación”. Ma. del Rosario Bores Rangel y Román Rosales Becerril. 1ª Edición, Editorial Mc Graw Hill, 1993. 11 “Programación en C”. Byron S. Gottfried. 1ª Edición, Editorial Mc Graw Hill, 1991. 12 “Metodología de la Programación. Algoritmos, Diagramas de Flujo y programas” Tomos I y II. Osvaldo Cairó Battistutti. 1a Edición Editorial Alfaomega, 1995. 13 “Enciclopedia del Lenguaje C”. Francisco Javier Ceballos .1ª Edición, Editorial Alfaomega ra-ma, 1999. 14 http://pseint.sourceforge.net/

Algoritmos en PSeInt.pdf

Recommend Documents