¡Descarga Manual de Programación Lógica: Trabajo con Archivos y más Apuntes en PDF de Informática solo en Docsity!
Introducción a la programación con
la ayuda de PSeInt
Manual de Programación
Lógica Introducción a la Programación
con la ayuda de PseInt
Lic. Ricardo Saucedo 30 de julio de 2015 Documento en proceso de elaboración.
C nba
Esta obra está licenciada bajo la Licencia Creative Commons Atribución NoComercial-CompartirIgual 4.0 Internacional. Para ver una copia de esta licencia, visita http://creativecommons.org/licenses/by-nc-sa/4.0/deed.es. Índice de contenido
Presentación..........................................................................................................................
..............5 Instalación del
programa..............................................................................................................................
Introducción a la
Programación........................................................................................................
Comprensión del Problema.......................................................................................................................... Encontrar una solución................................................................................................................................ Enunciar un Algoritmo................................................................................................................................ Algoritmo............................................................................................................................................ ...............8 Características de un Algoritmo computacional................................................................................................ Diagrama........................................................................................................................................... ...............10 DFD - Diagramas de Flujo de Datos............................................................................................................... Pseudocódigo.................................................................................................................................... ...............
Estructura de un
programa.............................................................................................................12 El
código................................................................................................................................................... 12 Sintaxis........................................................................................................................................................ ..... Instrucciones................................................................................................................................................ .... Sentencias................................................................................................................................................... ......14 Estructura de datos..................................................................................................................................... Expresiones.......................................................................................................................................... ..... Operadores.................................................................................................................................................. .....15 Reglas de precedencia...................................................................................................................................... Operadores Lógicos......................................................................................................................................... Delimitadores....................................................................................................................................... .....
Comenzando a
programar...............................................................................................................
Algoritmo de suma.................................................................................................................................... Algoritmo del triangulo.............................................................................................................................
Comenzando con la programación
estructurada..........................................................................24 Estructura de
Decisión............................................................................................................................... Estructura Repetitiva................................................................................................................................. Algoritmo de la Tabla de Multiplicar.........................................................................................................28 Estructura Iterativa.................................................................................................................................... Variables especiales................................................................................................................................... Variable contadora............................................................................................................................................ Variable acumuladora....................................................................................................................................... Variable flag, bandera o
guiarlos en la tarea de diagramar y codificar los algoritmos mediante pseudocódigo. Se utilizará como herramienta de estudio el programa PseInt versión de fecha 07/04/2015. El programa está disponible en forma gratuita en el sitio http://pseint.sourceforge.net/ cuyo autor, Pablo Novara ([email protected]) lo publica bajo licencia GPL. En el sitio web se indica que esta herramienta está diseñada 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,
Ilustración 1:
logotipo del
programa
PSeInt
minimizando las dificultades propias de un lenguaje y proporcionando un entorno de trabajo con numerosas ayudas y recursos didácticos. Instalación del programa. Debemos hacer una descarga del programa en su versión más actualizada a partir de la página del autor, se deberá elegir la descarga correspondiente a nuestro sistema operativo, GNU Linux / Windows / Mac OS. Al finalizar la descarga nos encontraremos con un archivo para instalar en el caso de windows, y para descomprimir en el caso de utilizar linux. De todas formas en la misma página de la descarga hay una explicación muy completa que nos ayudará a la instalación.
Ilustración 2: Ventana del programa PSeInt
[Rev.20/04/15] -5-
Manual de Programación Lógica
Introducción a la Programación Se define como programación al proceso de dotar a la computadora de un método para
resolver un problema tipo y entregar un resultado. Se dice también que un programa está compuesto de dos partes: • El código, que consiste en el conjunto de acciones a ejecutar, en programación a cada acción básica se la denomina genéricamente como instrucción. Cada instrucción podrá estar compuesta de un conjunto de elementos los cuales estudiaremos más adelante.
- La estructura de datos que consiste en la disposición de memoria elegida para almacenar los datos necesarios para resolver el problema, ya sea los parámetros o datos de entrada , los resultados intermedios o datos de proceso y la información resultante o datos de salida. A estos datos en programación se los denomina genéricamente como variables. El computador es una máquina que por sí sola no puede hacer nada, necesita ser programada, es decir, introducir a su memoria instrucciones que la guíen en lo que tiene que hacer. Esta es una tarea que para un neófito puede resultar muy compleja ya que la computadora solamente es capaz de realizar tareas muy básicas, por lo tanto hay que definir claramente cual será al proceso a ejecutar para hacer tareas complejas mediante pasos elementales. Para comprenderlo más organizadamente, podemos decir que este proceso de programación se divide en las siguientes tareas:
- Comprensión del problema.
- Idear una solución que sea lo más general posible.
- Enunciar un algoritmo de resolución.
- Codificarlo en un lenguaje de programación.
- Implementarlo, o dicho de otra manera, hacer que la máquina pueda traducirlo a su propio código binario.
- En forma paralela a los pasos anteriores, preparar un lote de prueba. 7. Ejecutar el programa y validarlo mediante el lote de prueba, si se encuentran errores lógicos, corregirlos, o sea, volver al punto 3 o 4 según el nivel de error. Comprensión del Problema. En esta etapa, se debe confeccionar el enunciado del problema, el cual requiere una definición clara y precisa. Es importante que se conozca exactamente cual es el objetivo que debe resolverse o dicho de otra manera, lo que se desea que realice la computadora. Quizás quién enuncie el problema no sepa definir claramente los objetivos, así que el analista deberá interrogarlo hasta que el objetivo a resolver quede perfectamente claro, mientras esto no se logre completamente, no tiene mucho sentido continuar con la siguiente etapa.
[Rev. 30/07/15] -6-
Manual de Programación Lógica
Encontrar una solución Normalmente esta etapa comienza en paralelo a la lectura del enunciado, cuando se va comprendiendo el enunciado y por experiencia o analogía se van ideando las acciones que se deben aplicar para arribar al resultado esperado. La solución debe ser lo más amplia o general posible, se debe realizar una abstracción del problema, por ejemplo si el enunciado dice: Se necesita un programa para calcular el área ocupada por una viga de madera
Un algoritmo (del griego y latín, dixit algorithmus y este a su vez en honor del matemático persa Al-Juarismi ) se define como un método aplicable con el fin de obtener la solución a un problema genérico. Debe presentarse como una secuencia ordenada de pasos que siempre se ejecutan en tiempo finito y con una cantidad de esfuerzo también finito o al menos que pueda detectar cuando el método se hace inviable e informarlo. Los algoritmos tienen un inicio y un final, son únicos y deben ser fácilmente identificables. Para su mejor claridad y aprovechamiento en la etapa de codificación, es conveniente que los algoritmos tengan ciertas características: • Debe tener un único comienzo y un sólo final perfectamente definidos. • Debe ser secuencial , cada paso se debe ejecutar en una forma ordenada y no debe comenzar a ejecutarse un paso sin haber concluido de ejecutar el paso anterior. Cuando se hace el diagrama del algoritmo, a esta secuencialidad se la denomina flujo de proceso.
- Deben ser Finitos , con lo cual se entiende que deben finalizar en algún momento determinado.
- Deben ser Eficientes , entendiéndose por esto que ocupen la cantidad mínima y necesaria de variables para que al codificar genere un programa que utilice la mínima cantidad de memoria y además minimizar el tiempo de ejecución evitando procesos redundantes o innecesarios.
- Deben ser Legibles , se busca que el texto que lo describe debe ser claro, de forma que permita entenderlo y leerlo fácilmente, eligiendo nombres de variables y de procesos que hagan referencia clara a su función dentro del código.
- Deben ser Modificables , o sea que deben enunciarse de modo que sus posteriores modificaciones u ampliaciones sean fáciles de realizar, incluso por programadores diferentes a sus propios autores.
- Deben ser Modulares , la filosofía utilizada para su diseño debe favorecer la división del problema en módulos pequeños. haciendo que procesos y cálculos complejos se descompongan en cálculos más simples. Si bien esto puede sonar contrario al enunciado sobre la eficiencia, lo
[Rev. 30/07/15] -8-
Manual de Programación Lógica
óptimo sería poder llegar a un compromiso entre simplicidad y eficiencia.
Ilustración 3: Elementos del Diagrama de Flujo de Datos en PSeInt
Características de un Algoritmo computacional
Para poder enunciar un algoritmo que se pueda codificar en un lenguaje de programación, debemos asumir que quién interpretará el algoritmo (la CPU) podrá realizar solamente acciones muy básicas. Si bien en los lenguajes de programación nos encontramos en que podemos utilizar multitud de acciones
Manual de Programación Lógica
predefinidas, la mayoría están asociadas al contexto de ejecución o dicho de otro modo, la mayoría de acciones que se pueden realizar mediante un lenguaje de programación son de
La idea es que se pueda ver el programa desde el punto de vista del programador el cual está acostumbrado a leer código fuente.
Manual de Programación Lógica
Estructura de un programa Habíamos mencionado previamente que en un programa encontramos dos partes, el código y la estructura de datos. El código El código podemos verlo como un texto que describe la receta que se debe aplicar para realizar una tarea compleja de procesamiento de datos. Pero... ¿Con qué objetivo se define este texto? La idea es que la computadora puede ejecutar programas que traducen texto generado por el usuario (denominado código fuente ) a operaciones en código máquina
(denominado código objeto ) y puede ejecutar cada acción descripta en la cada oración. Estos programas traductores a código máquina se denominan genéricamente como programas intérpretes. El único problema es que los lenguajes naturales son poco precisos al momento de definir tareas, ya que nos encontramos con que podemos utilizar un conjunto de sinónimos para representar lo mismo o incluso una misma palabra presenta ambivalencias, es decir en un contexto significa una cosa y en otro contexto otra cosa. Para no hacer demasiado complejo al programa intérprete, estos reconocen un lenguaje muy acotado (que se basa en su amplia mayoría en el idioma inglés) resumiendo el vocabulario normal a unas pocas palabras con un significado preciso, incluso muchas de esas palabras son inexistentes en el lenguaje natural y solo tienen sentido en la programación. El objetivo es hacer que el texto que podamos armar no sea difícil de entender y traducir por no tener ninguna ambivalencia en su significado. Como todo texto, un programa no es más que un conjunto de oraciones, en este caso un programa se compone de oraciones de tipo declarativas e imperativas. Retomando la idea entonces, cuando programamos no hacemos más que describir paso por paso y con oraciones muy simples que debe hacer o tener en consideración la computadora para aplicar un algoritmo. En nuestra jerga vamos a denominar a la oraciones declarativas como sentencias y a las oraciones imperativas como instrucción. Como todo lenguaje, la oración está sujeta a leyes sintácticas que en este caso son muy estrictas. Por eso la primer tarea que el programa traductor hace, luego de que nosotros codifiquemos el programa es realizar un análisis sintáctico de todo el texto o de cada oración indicando todos los errores sintácticos detectados para que los corrijamos. Solo cuando el programa se haya libre de errores sintácticos se puede comenzar con la traducción a código máquina y posterior ejecución.
Sintaxis
Las reglas sintácticas son mas bien pocas, pero muy restrictivas. Cada lenguaje tiene sus propias restricciones. En el caso del pseudocódigo podemos mencionar las siguientes reglas: Se define un conjunto de palabras reservadas que en algunos lenguajes son [Rev.
30/07/15] -12-
Manual de Programación Lógica
denominadas tokens. Estas palabras solo pueden utilizarse en un único sentido, el que se asigne como definición en el lenguaje. Las palabras reservadas y su significado son:
Palabra reservada Significado
Leer
Ingresar un conjunto de datos desde el teclado hacia variables de
memoria, se menciona al teclado como
generalización de cualquier periférico de entrada.
Escribir
Exhibir por la pantalla de video un conjunto de datos, se indica al
video como una generalización
de dispositivo de salida.
<-
Asignación de un dato a una variable de memoria
verbos tienen un solo modo, el infinitivo. En los lenguajes de programación hay multitud de comandos pero en el pseudocódigo vamos a enfocarnos solamente en tres ya mencionados: • Leer
Sentencias
Son oraciones declarativas que sirven para dividir la secuencia de ejecución en bloques que incluyan instrucciones u otras sentencias (a estas se las denomina sentencias anidadas) que se ejecutaran en forma grupal, delimitando donde comienza y donde termina este bloque. Por comodidad denominaremos a este conjunto como estructura. En este caso, la existencia de estas sentencias definen a la metodología de programación como programación estructurada. Las sentencias son
- Proceso … / finProceso
- Si … Entonces / Sino /finSi
- Mientras ... Hacer / finMientras
- Repetir / Hasta que ...
- Para … <- … Hasta ... Hacer / finPara
- Según … Hacer / deOtroModo: / finSegún Estructura de datos La estructura de datos está formada por el conjunto de datos variables que requiere el programa. Los datos constantes no forman parte de la estructura de datos ya que estos, por el mismo hecho de ser constantes, se almacenan como parte del código. Los lenguajes de programación definen su propias reglas para la definición de las estructuras de datos, pero en el caso del pseudocódigo resumiremos esas reglas en la siguientes: Las variables se definen por un nombre y un tipo primitivo. Respecto al nombre, cada variable debe poseer un nombre único, éste debe comenzar por una letra (vocal o consonante) y luego puede continuar con un conjunto de letras o números. Queda prohibido como parte del nombre cualquier símbolo y tampoco se admiten espacios. Respecto a los tipos primitivos de datos, existen tan solo tres: • El tipo lógico o booleano , el cual representa un dato que puede tener sólo dos posibles valores: verdadero o falso.
- El tipo numérico , el cual representa un dato que puede operarse matemáticamente, por ejemplo una medida, el resultado de un cálculo, etc. este valor debe pertenece al conjunto de números reales.
- El tipo alfanumérico , el cual representa un dato que no es matemático, por ejemplo un nombre, una denominación, un código, etc. a los
[Rev. 30/07/15] -14-
Manual de Programación Lógica
alfanuméricos también se los conoce como strings o cadenas de texto. Hay otras características que definen a ciertos tipos de variables como por ejemplo la dimensión, pero eso será objetivo de otro capítulo. Expresiones
Ya habíamos mencionado que una expresión consiste en el resultado de un cálculo, pero debemos ser un poco más extensos en su definición ya que involucra otros elementos de la programación que no hemos mencionado y también por su importancia ya que es una de la construcciones más utilizadas en los programas. Una expresión esta compuesta por datos afectados por operadores y/o funciones. Un operador es un símbolo que representa una operación entre datos. Algunos son muy conocidos como por ejemplo + y - (la suma y la resta), pero hay muchos más. Una función es un proceso definido que se hace con uno o varios datos y del cual se obtiene un único resultado. Por ejemplo las funciones trigonométricas seno(), coseno(), etc.
Operadores
Los operadores pueden ser de los siguientes tipos: matemáticos, relacionales, lógicos y por último un operador llamado concatenación. • Operadores matemáticos son la suma (
- ), la resta ( - ), la división ( / ), la multiplicación ( * ), la potenciación ( ^ ) y el módulo o resto de la división ( % ). El resultado de una operación matemática es un tipo numérico.
- Operadores relacionales son: el mayor ( > ), menor ( < ) e igual ( = ) y sus operaciones complementarias: menor o igual ( <= ), mayor o igual ( >= ) y distinto ( <> ) respectivamente. El resultado es un tipo lógico ya que nos dice si la relación es verdadera o falsa.
- Operadores lógicos : se utilizan para unir subexpresiones de tipo lógico, ellas son la conjunción AND ( & ) la disyunción OR ( | ) y el complemento NOT ( ~ ), el resultado es un tipo lógico siguiendo las reglas de las tablas de verdad del álgebra de boole.
- Operador de concatenación : es el único operador que permite operar entre si dos datos de tipo alfanumérico, el resultado es una cadena de texto que contiene las dos cadenas unidas una continuación de la otra. Casi todas las operaciones requieren que existan dos operandos, uno a derecha y otro a izquierda, por eso es que a la mayoría se los clasifica cómo de tipo binario. Con las siguientes excepciones : El operador NOT ( ~ ) solo admite un operando, por lo tanto se lo clasifica cómo operador monario. El operador menos ( - ) se puede utilizar para realizar una sustracción, con lo cual es del tipo binario, pero también se lo puede utilizar como operador de
Manual de Programación Lógica
cambio de signo, actuando en este caso como monario. Ejemplos:
A ← b – 4 (utilizado en forma binaria) A ← -b (utilizado en forma monaria) Una
expresión cuando es muy compleja puede analizarse dividiéndola en varias subexpresiones más simples, ya que en realidad la computadora va a operar con pares de datos o a veces con datos individuales. La lógica indicaría que la computadora irá ejecutando las subexpresiones de izquierda a derecha, pero no es así, ya que algunas operaciones tiene mayor prioridad que otras, se establecen entonces reglas de precedencia que indican que operador va a tener mayor prioridad de resolución sobre otro, y si ambos tuvieran la misma prioridad, se resuelven de izquierda a derecha.
Reglas de precedencia
- Potenciación (^).
NOT).
Estos operadores funcionan según los criterios establecidos en las tablas de verdad del álgebra de Boole. Analicemos el resultado r de las expresiones para los 3 operadores, suponiendo que operan sobre dos variables lógicas v1 y v2 (en el caso del ~ es solo una por ser monario). r ← v1 & v2 r ← v1 | v2 r ← ~v
v1 v2 r
F F F
F V F
V F F
V V V
Delimitadores
v1 v2 r
F F F
F V V
V F V
V V V
v1 r
F V
V F
Son elementos del lenguaje que cumplen la función de separar o delimitar (de ahí su nombre) datos. Los delimitadores más importantes son:
delimitador nombre función
" comillas Delimita una constante alfanumérica (literal).
' apóstrofo Similar a las comillas, delimita una constante alfanumérica.
( ) paréntesis Delimita una sub expresión
, coma Separa un conjunto de datos
espacio Separa palabras
Salto de línea Separa instrucciones
[ ] corchetes Delimita un sub índice de un arreglo
Manual de Programación Lógica
Comenzando a programar Vamos a comenzar con algoritmos muy simples y luego los iremos haciendo más complejos para añadir más conceptos. Comenzaremos con algunos algoritmos lineales y de paso vamos probando la herramienta. Algoritmo de suma El enunciado de este problema sería algo como: Se necesita confeccionar un programa que sume dos números y nos muestre el resultado. Analicemos los datos que se requieren para resolver el algoritmo. Por un lado necesitamos dos variables para almacenar los dos operandos que proporcionará el usuario, a estos los denominaremos A y B. Necesitaremos además una variable para almacenar el resultado de la suma, a esta la llamaremos C.
Obviamente la expresión a utilizar es A + B. entonces el algoritmo planteado que da de la siguiente manera:
Proceso Suma
Leer A, B
C <- A + B
Escribir "El resultado es: ", C
FinProceso
Vamos a comprobar si el algoritmo está bien. Ejecutamos el programa PseInt y nos encontraremos con la siguiente ventana: Observemos que nos aparece parte de un pseudocódigo, entre las sentencias Proceso y FinProceso deberemos escribir nuestro código, pero mejor será
[Rev. 30/07/15] -18-
Manual de Programación Lógica
utilizar los botones que se ven al costado derecho en la barra cuyo nombre es Comandos. Lo primero que debemos poner es un ingreso de datos, por lo tanto debemos utilizar el botón Leer que tiene el diagrama:. al presionarlo obtenemos la siguiente línea de texto: Ahora debemos reemplazar el recuadro que dice “Lista de Variables” por nuestras variables separadas por comas, es lo que nos sugiere en el cuadro inferior que apareció al presionar el botón. Como vemos, está toda la línea grisada, para seleccionar solamente el cuadro que dice “Lista de Variables” nos movemos con las flechas de cursor hacia atrás y luego hacia adelante hasta que se seleccione solamente lo que queremos. Una vez seleccionado el cuadro de lista debemos tipear nuestras variables según el algoritmo diseñado. Repetimos las acciones con los botones de asignar y Escribir con lo que debemos obtener el pseudocódigo
botones y se nos abrirá una nueva ventana: La idea es que ingresemos ambas variable que deberán ser sumadas, por ejemplo [Rev.
30/07/15] -20-
Manual de Programación Lógica
tomaremos como lote de prueba los valores 5200 y -4500, si el algoritmo está correcto el resultado debería ser 700... veamos: Ingresamos primer o el valor 5200 y presionamos intro (o enter), luego el valor -4500 y de nuevo Intro. Inmediatamente nos muestra el resultado que efectivamente era lo que esperábamos: Digamos que este algoritmo fue diseñado solo con lo esencial para ver si funciona, pero como lo estamos ejecutando vemos que podría ser un poco más amigable, entonces
reformulemos un poquito las instrucciones del pseudocódigo: Eso ayudará a intuir para qué sirve el algoritmo si lo compartimos con algún usuario. Algoritmo del triangulo. Veamos como encarar un problema un poco más complejo. El enunciado sería: Calcular el área y el perímetro de un triángulo conociendo el largo de los 3 lados. Parece simple no? Bueno, si es simple, por lo menos para calcular perímetro = lado + lado + lado... Sí... pero hay un problema, seguramente recordamos que el área de un triangulo se calcula con la fórmula: área = (base x altura) / 2.
Manual de Programación Lógica
En el caso que los datos ingresados correspondan a un triángulo rectángulo, no habría problemas simplemente habría que identificar que lado corresponde a la base y cual a la altura, ¿pero si no es un triángulo rectángulo? Habría que calcular el valor altura... ¿y cómo se calcula? Bueno, podemos ir a un buscador de la web y consultar un sitio que nos diga “cómo se calcula el área de un triángulo escaleno”. El buscador nos llevaría a varios sitios donde encontraremos el “teorema de Herón de Alejandría” que dice: « En un triángulo de lados a, b, c, y semiperímetro s=(a+b+c)/2, su área es igual a la raíz cuadrada de s(s-a)(s-b)(s-c). » (sacado de la wikipedia). Bueno, el teorema habla de cualquier tipo de triángulo, justo es lo que necesitábamos. A esto nos referimos por comprensión del problema. Entonces ya podemos definir las variables:
- Variables de entrada: los 3 lados que llamaremos L1, L2 y L3 • Variables de salida: el área que la llamaremos A y el perímetro que lo llamaremos P.
- Variables de proceso: Según el teorema de Herón, necesitamos calcular el semiperímetro, al que llamaremos S. las fórmulas a aplicar serían: P = L1 + L2 + L S = P / 2 A =
√ S ×( S – L 1)×( S – L 2)×( S – L 3)
Diseñemos entonces el algoritmo utilizando pseudocódigo y el DFD. Pero primero haremos un par de observaciones: Para obtener la raíz cuadrada recurrimos a las matemáticas, la raíz cuadrada de un número es equivalente a elevar ese número a ½. Por otra parte, agregaremos comentarios al pseudocódigo para recordar en un futuro de donde sacamos la fórmula. El programa PseInt admite el añadido de comentarios al pseudocódigo utilizando una doble barra ( // ) al principio del texto. Esta forma de comentar es la que se utiliza en el lenguaje de programación “C++” y en muchos de los lenguajes basados en este, como Java, PHP, Javascript, etc.
