Manual de Programacin Instituto Profesional de Chile _3 abril 2013_

Texto completo

(1)2013 Manual de Programación versión 1. Autores: Andres Ponce Espinosa Jose Souza Órdenes.

(2) Manual de Programación. Contenido Generalidades ..................................................................................................................................... 3 Objetivo General ................................................................................................................................. 4 Objetivos Específicos ........................................................................................................................... 4 Lógica Proposicional ............................................................................................................................ 5 Proposición ...................................................................................................................................... 5 Clasificación de las proposiciones ................................................................................................... 6 Notación y conectivos lógicos ......................................................................................................... 6 Cálculo de proposiciones ............................................................................................................ 8 Tablas de verdad ......................................................................................................................... 9 La negación (~): ........................................................................................................................... 9 La compuerta NOT, o inversora (NO lógico) ............................................................................ 10 La conjunción (^): ..................................................................................................................... 10 La compuerta OR (O lógica) ...................................................................................................... 11 Implicación o condicional .......................................................................................................... 11 Doble implicación o bicondicional ................................................................................................ 12 Diferencia simétrica .................................................................................................................. 12 Ejercicios: .......................................................................................................................................... 13 Tautología, Contradicción y Contingencia................................................................................. 17 Ejercicio 2 .................................................................................................................................. 18 Conceptos de Algoritmos .................................................................................................................. 19 Diseño del algoritmo ................................................................................................................. 19 Criterios que debe satisfacer un algoritmo (características): ................................................... 19 Partes en las que se estructura un algoritmo: .............................................................................. 20 ¿Cómo freír un huevo? (Referencia Profesor Sixto Alvarez Sisniegas) ........................................ 21 Representación de un algoritmo: .................................................................................................. 24 Ejemplo de flujo grama ............................................................................................................. 24. 1.

(3) Manual de Programación Simbología del flujo gramas ...................................................................................................... 24 Algunos ejemplos: ......................................................................................................................... 25 Pseudocódigo: ................................................................................................................................... 27 Estructura de un programa en pseudocódigo:.......................................................................... 27 Elementos de un programa: .......................................................................................................... 28 Elementos de Estructuras de Datos .......................................................................................... 28 Otros elementos de programación ................................................................................................... 29 Traza de un Algoritmo. ...................................................................................................................... 30 Estructuras de Selección ................................................................................................................... 32 Tipos de Datos ................................................................................................................................... 35 Operadores Aritméticos .................................................................................................................... 38 Operadores Lógicos ........................................................................................................................... 39 Operadores Lógicos ........................................................................................................................... 39 Práctica Compilador SLE .................................................................................................................... 40 Desarrollo de Algoritmos (Pseudocódigo) ........................................................................................ 53 Vectores ............................................................................................................................................ 65 Matrices............................................................................................................................................. 77 Práctica Java ...................................................................................................................................... 87 Programación Orientada a Objetos................................................................................................... 98 Introducción .................................................................................................................................. 98 Clases y objetos ........................................................................................................................... 102 Fundamentos de la P.O.O. .......................................................................................................... 103 Componentes de una clase en Java ............................................................................................ 105 Uso de clases y objetos ............................................................................................................... 105 Instanciación de objetos ............................................................................................................. 106 Ejercicios P.O.O. .............................................................................................................................. 107 Anexos: Ejercicios Pseudocódigo ................................................................................................ 11734 Ejercicios para realizar .................................................................................................................. 1433 Bibliografía, Web Grafía …………………………………………………………………………………………………………..145. 2.

(4) Manual de Programación. Generalidades Este documento pretende dar una visión general y acompañar al alumno en sus primeros pasos a través de lo que llamamos “mundo de la programación”. En este manual se estudiarán los fundamentos de la algoritmia: la ciencia y arte de diseñar algoritmos para la resolución sistemática de problemas de cualquier índole. Un algoritmo es la especificación detallada de los pasos necesarios para llevar a cabo una tarea específica. En clases, por ejemplo, hemos aprendimos una serie de pasos para realizar sumas, restas, multiplicaciones y divisiones, estos son algoritmos. El como freír un huevo es uno de los ejemplos más claros de algoritmo. La inscripción en IP de Chile, solicitar documentos, también son un algoritmo. En este manual, veremos algunos ejercicios básicos para crear programas.. La algoritmia consiste en la búsqueda de soluciones a un problema concreto. Pero, en aras de entender mejor lo que esto significa, hace falta una definición más extensa. Un algoritmo es la transcripción exacta de una serie de instrucciones concretas con las cuales se encuentra una solución. Por ejemplo Si se requiere encender una televisión, nadie se plantea que eso pueda ser un problema, puesto que el objetivo es verla. Sin embargo, si se plantea el encender la televisión como el problema a resolver, se entenderá que los pasos exactos e infalibles son:     . Buscar el control remoto. Comprobar que si tiene pilas. Comprobar si la televisión esta enchufada. Comprobar si los fusibles están encendidos. Pulsar el botón de encendido.. Este es un ejemplo, pero cada paso a su vez se podría plantear como un problema (¿Cómo compruebo si tiene pilas? ¿Cómo busco el control remoto si no sé dónde está?). Además. Puede haber caminos alternativos, más o menos seguros que este, para llegar a la misma solución: Puede ser una televisión sin control remoto o que simplemente se prefiera encender desde el botón de encendido, por ejemplo. Por lo tanto, hay infinidad de posibles algoritmos para el mismo problema. Si dos personas realizan un algoritmo, es más que probable que los algoritmos serán distintos puesto que cada uno tiene su punto de vista de la forma correcta de llegar a su objetivo.. 3.

(5) Manual de Programación. Objetivo General Aprender a desarrollar ejercicios de programación.. Objetivos Específicos Los objetivos específicos de este documento son los siguientes:      . Aprender sobre los conceptos básicos de programación. Aprender a desarrollar ejercicios de pseudocódigo. Aprender a utilizar un compilador de pseudocódigo (SLE, Study Language Environment). Aprender a utilizar un compilador para ambientes de desarrollo (JAVA). Aprender a desarrollar ejercicios en lenguaje JAVA Aprender sobre el paradigma de la programación orientada a objetos.. 4.

(6) Manual de Programación. Lógica Proposicional La lógica proposicional es la parte de la lógica que estudia la formación de proposiciones complejas a partir de proposiciones simples, y la inferencia de proposiciones a partir de proposiciones, pero sin tener en cuenta la estructura interna de las proposiciones más simples. Una lógica proposicional es un sistema formal cuyos elementos más simples representan proposiciones, y cuyas constantes lógicas, llamadas conectivas, representan operaciones sobre proposiciones, capaces de formar otras proposiciones de mayor complejidad.. Proposición La proposición es el significado de una idea, enunciado, conjunto de palabras o letras a las que se les puede asignar uno y sólo uno de los valores de verdad, que pueden ser: VERDADERO (V) o FALSO (F) Proposición, es una oración que declara algo. Generalmente se las representa por las letras del abecedario a partir de la p, así por ejemplo, son proposiciones: p: Santiago es la capital de Chile (V) q: el fútbol chileno es de primer nivel (F) r: 12*5=60 (V) s: Antofagasta está en la IV región (F) t: las piedras nadan (F) A todas ellas se les puede asignar un valor de verdad, sea éste Verdadero o Falso Expresiones no proposicionales: a ellas no se les puede asignar un valor de verdad: ¿Irá a llover mañana? Por favor, enciende el data Ingresa la lista en el sistema. 5.

(7) Manual de Programación Enunciado abierto: Es una proposición en la que uno de sus elementos es reemplazado sin perder su valor de verdad. Por ejemplo, si decimos 12 > 5, podemos reemplazar 12 por x, y la expresión quedaría x > 5, pues x no representa necesariamente al número 12. Entonces x > 5 es un enunciado abierto. Compuestas o moleculares. Clasificación de las proposiciones. Son las que constan de dos o más enunciados simples, por ejemplo. Simples o atómicas. Antofagasta es una ciudad y está en la II región. Son las que constan o se pueden representar por una sola variable, por ejemplo. En donde,. p: 12 * 5 =60 Aquí ‘p’ representa la proposición completa. p: Antofagasta es una ciudad q: está en la II región Están unidas por un operador o conectivo lógico, en este caso el operador Y. Notación y conectivos lógicos A partir de proposiciones simples es posible generar otras, simples o compuestas. Es decir que se puede operar con proposiciones, y para ello se utilizan ciertos símbolos llamados conectivos lógicos. La electrónica moderna usa electrónica El cálculo de proposiciones se debe al matemático inglés digital para realizar muchas funciones. George Boole (1815‐1864). Sus ideas sobre el cálculo de Aunque los circuitos electrónicos proposiciones dieron origen al “álgebra de Boole”, base pueden resultar muy complejos, en teórica fundamental en el aparecimiento y desarrollo de realidad se construyen de un número las máquinas de cálculo y las modernas computadoras. muy grande de circuitos muy simples. En un circuito digital se transmite Fue el matemático norteamericano Claude Shannon, información binaria (ceros y unos) quien aplicó el álgebra de Boole al diseño de circuitos de entre estos circuitos y se consigue un conmutación utilizados en las centrales telefónicas circuito complejo con la combinación automáticas. de bloques de circuitos simples. Al matemático húngaro John von Neumann, se debe la actual estructura de los ordenadores.. 6.

(8) Manual de Programación. Circuito lógico es aquel que maneja la información en forma de "1" y "0", dos niveles de voltaje fijos. "1" nivel alto o "high" y "0" nivel bajo o "low". Estos circuitos están compuestos por elementos digitales como la compuerta AND (Y), compuerta OR (O), compuerta NOT (NO) y combinaciones de los circuitos antes mencionados.. Ya hemos visto que la información binaria se puede representar: En la forma de "0" y "1“ Un interruptor "abierto" o "cerrado“ "On" y "Off“ "falso" o "verdadero", en donde "0" representa falso y "1" verdadero. Los posibles estados del interruptor o interruptores que afectan un circuito se pueden representar en una tabla de verdad. Las tablas de verdad pueden tener muchas columnas, pero todas las tablas funcionan de igual forma. Hay siempre una columna de salida que representa el resultado de todas las posibles combinaciones de las entradas. 7.

(9) Manual de Programación. Las tablas de verdad pueden tener muchas columnas, pero todas las tablas funcionan de igual forma. Hay siempre una columna de salida que representa el resultado de todas las posibles combinaciones de las entradas. Los circuitos lógicos pueden ser diseñados gracias a que las proposiciones lógicas se pueden operar en cálculos. La manera de calcular proposiciones es aplicando las operaciones lógicas, entre las cuales tenemos:. Los circuitos lógicos son básicamente un arreglo de interruptores, conocidos como "compuertas lógicas" (compuertas AND, NAND, OR, NOR, NOT, etc.) Cada compuerta lógica tiene su tabla de verdad. Y, si pudiéramos ver en más detalle la construcción de éstas, veríamos que es un circuito comprendido por transistores, resistencias, diodos, etc. conectados de manera que se obtienen salidas específicas para entradas específicas.. Cálculo de proposiciones. Recordemos que las variables proposicionales se representan con las letras desde la p, y que los valores lógicos se representan con una V o una F. Luego, p=V, no quiere decir que la ‘proposición p es igual a V’, sino que la proposición p es verdadera, como por ejemplo en. p: 16‐4 =12 , esto hace que p=V. 8.

(10) Manual de Programación Tablas de verdad. El cálculo de proposiciones nos ayuda a conocer el valor de verdad de una proposición compuesta, en función del valor de verdad de las proposiciones componentes. Las tablas se usan para asignar el valor a las funciones elementales (que son las que se obtienen simplemente aplicando las operaciones lógicas) Una tabla de verdad es el resultado de aplicar un procedimiento que utilizamos para calcular todos los posibles valores de verdad de un enunciado o proposición molecular.. La negación (~):. Sea p: yo estudio Ingeniería Su opuesto (o negación), es ~p: yo no estudio Ingeniería * Observe que al valor V de p, la negación le hace corresponder el valor F, y viceversa La misma tabla de verdad es aplicable a: p: todos los alumnos atienden en la clase ~p: no todos los alumnos atienden en la clase O también a: p: no es cierto que todos los alumnos atienden en la clase ~p: hay alumnos que no atienden en la clase. 9.

(11) Manual de Programación La compuerta NOT, o inversora (NO lógico). Esta compuerta entrega en su salida el inverso de la entrada. Su símbolo y tabla de verdad en circuitos lógicos son: La salida de una compuerta "NOT" tiene el valor inverso al de su entrada. Esto significa que si a la entrada tenemos un "1" lógico, a la salida hará un "0" lógico y si a la entrada tenemos un "0" a la salida habrá un "1".. La conjunción (^): Utiliza dos proposiciones p^q (leáse p y q). En esta declaración: ‘Antofagasta es capital de región y está en la II Región’ Tenemos que: p: Antofagasta es capital de región q: está en la II Región Por ser ambas verdaderas, la conjunción de ellas es verdadera, y la declaración también lo es. Pero en ‘Hoy es Jueves y mañana será Sábado’ donde p: Hoy es jueves q: mañana será sábado Esta conjunción es falsa porque no son verdaderas ambas proposiciones simultáneamente. La conjunción tiene la propiedad conmutativa. 10.

(12) Manual de Programación La compuerta OR (O lógica). La salida X de esta compuerta será "1" cuando la entrada "A" o la entrada "B" esté en "1".. En una compuerta OR, la salida será "1", cuando en cualquiera de sus entradas haya un "1".. Implicación o condicional. La proposición p se llama antecedente (o hipótesis), y la proposición q se llama consecuente (o conclusión) de la implicación o condicional. La tabla nos muestra que la implicación sólo es falsa si el antecedente es verdadero y el consecuente es falso. “Si logro ese trabajo, haré un asado para celebrar”, tenemos p: logro el trabajo q: hago un asado El enunciado puede pensarse como un compromiso (q), condicionado por p, y podemos asociar su verdad al cumplimiento del compromiso. Si p es V, es decir si logro el trabajo, y no hago el asado, el compromiso no se cumple y la proposición es falsa. Si p y q son verdaderas, entonces la proposición es verdadera pues el compromiso se cumple. Si p es F, es decir si no logro ese trabajo, quedo liberado del compromiso y haga o no haga el asado, la implicación es verdadera.. 11.

(13) Manual de Programación. Doble implicación o bicondicional (Se lee "p si y sólo si q“ o “p es equivalente a q”) La doble implicación o bicondicional sólo es verdadera si ambas proposiciones tienen el mismo valor de verdad (sea V o F) “Me eximiré en el examen de Programación I Si y solo si no tengo rojo en ninguna Solemne” Aquí un enunciado es condición necesaria y suficiente para otro, así: p: me eximiré en Programación I q: no tengo rojo en ninguna Solemne En consecuencia, el enunciado p Û q, queda definido por el enunciado (p  q) ^ (q  p). Por esta razón, el símbolo se llama bicondicional Diferencia simétrica Como ya se dijo, es una disyunción en sentido excluyente La verdad de p v q está caracterizada por la verdad de una y sólo una de las proposiciones componentes. “O vamos a clases, o vamos al carrete” Queda claro que sólo podremos ir a uno de los dos lugares, y sólo a uno. Es decir que el enunciado es V sólo si vamos a uno de los dos eventos. En caso de ir a ambos, o de no ir a ninguno, el enunciado es F.. 12.

(14) Manual de Programación. Ejercicios: TAUTOLOGÍA, CONTRADICCIÓN Y CONTINGENCIA Una proposición compuesta se dice que es una tautología si es VERDADERA independientemente de los valores de verdad de las proposiciones simples que la componen.‐ Por ejemplo la siguiente proposición: (p  q)  p v q Para resolver esta tabla de valores de verdad, se debe comenzar por el paréntesis de la izquierda de la doble implicación, teniendo en cuenta que es una conjunción, luego se sigue por su negación. Luego seguimos con la parte derecha de la doble implicación, o sea con la negación de p y de q, luego con estos valores se resuelve la disyunción. Por último se resuelve la doble implicación (operación principal) con el último resultado de la derecha (la negación del paréntesis) y el último de la izquierda (la disyunción) p V V F F. q V F V F. - (p  q)  -p v -q F V V F F F V F V F V V V F V V V F V F V V V V. Una proposición es una contradicción si es FALSA independientemente de los valores de verdad de las proposiciones simples que la componen.‐ Por ejemplo: p V V F F. q V F V F. pq V F F F. F F F F.  -p v -q F F F F V V V V F V V V. Una proposición es una contingencia si no es ni VERDADERA ni FALSA.‐ Por ejemplo: p V V F F. 13. q V F V F. pq V F F F.  -p v -q F F F F V F V V V V V F V V V V.

(15) Manual de Programación LEYES LOGICAS Se llaman leyes lógicas a todas aquellas proposiciones que son verdaderas. 1.. INVOLUCIÓN. La negación de la negación de una proposición es equivalente a la misma proposición. ‐(‐p)  p Demostramos esta ley usando la tabla de valores de verdad: p V F. 2.. V F. (-p)  F V V V. p V F. LA IDEMPOTENCIA. De la disyunción: La disyunción de una misma proposición, es equivalente a la misma proposición, es decir: pvpp. Demostramos con una tabla de valores de verdad: P V F. (p v p) V F.  V V. p V F. De la conjunción: La conjunción de una misma proposición, es equivalente a la misma proposición, o sea: ppp. Demostramos con una tabla de valores de verdad:. 14.

(16) Manual de Programación (p  p) V F. p V F.  V V. p V F. 3. ASOCIATIVIDAD La disyunción y la conjunción son asociativas. O sea que: (p v q) v r  p v (q v r) Para armar esta tabla se debe tener en cuenta que las proposiciones simples son tres, por lo tanto tendrán 8 valores por cada proposición dispuestas de la siguiente forma: p V V V V F F F F. q V V F F V V F F. r V F V F V F V F. (p v q) v r  V V V V V V V V V V V V V V V V V V V V V V V V F V V V F F V F. p v (q v r) V V V F V V V F. (p  q)  r  p  (q  r) Para armar esta tabla se debe tener en cuenta que las proposiciones simples son tres, por lo tanto tendrán 8 valores por cada proposición dispuestas de la siguiente forma: p V V V V F F F F. 15. q V V F F V V F F. r V F V F V F V F. (p  q)  r  p  V V V V V F V F F F V F F F V F F F V F F F V F F F V F F F V F. (q  r) V F F F V F F F.

(17) Manual de Programación 4.. CONMUTATIVIDAD. La disyunción y la conjunción son conmutativas pvqqvp Se demuestra con una tabla de valores de verdad: p V V F F. q V F V F. pvq V V V F.  V V V V. qvp V V V F.  V V V V. qp V F F F. pqqp. Se demuestra con una tabla de valores de verdad: p V V F F. 5.. q V F V F. pq V F F F. DISTRIBUTIVIDAD. De la conjunción con respecto a la disyunción: la conjunción es distributiva con respecto a la disyunción. (p  q)  r  (p  r) v (q  r). p V V V V F F F F. 16. q V V F F V V F F. r V F V F V F V F. (p  q) V V V V V V F F. r  (p  r) v (q  r) V V V V V F V F F F V V V V F F V F F F V V F V V F V F F F F V F F F F V F F F.

(18) Manual de Programación. De la disyunción con respecto a la conjunción: la disyunción es distributiva con respecto a la conjunción. (p  q) v r  (p v r)  (q v r) p V V V V F F F F. q V V F F V V F F. r V F V F V F V F. (p  q) v r  (p v r)  V V V V V V V V V V F V V V V F F V V F F V V V V F F V F F F V V V V F F V F F. (q v r) V V V F V V V F. Ejercicio 1 TAUTOLOGÍA. Si la Luna es mayor que la Tierra, la Tierra es mayor que el Sol. Júpiter es mayor que Plutón, si la Tierra es mayor que el Sol. Por tanto, si la Luna es mayor que la Tierra, Júpiter es mayor que Plutón. Luna mayor: p Tierra mayor: q Júpiter mayor: r (p ‐> q) & (q ‐> r) ‐> (p ‐> r). ( p V V V V F F F F. 17. -> V V F F V V V V. q ) & ( q -> V V V V V F V F F F F V F F F V V V V V V F V F F V F V V V F V. r ) -> ( p -> V V V V F V F V V V V V F V F V V F V V F F V V V F V V F F V V. r ) V F V F V F V F.

(19) Manual de Programación. Ejercicio 2. Ejemplo: Si estudio entonces aprendo. Si aprendo entonces apruebo. Aprobé. Por lo tanto estudie y aprobé Por lo tanto estudie o aprendí, estudie y no aprendí. Validando: estudie entonces aprendí. p: yo estudio q: yo aprendo r: yo aprobé H1: p→q hipótesis 1 H2: q→r hipótesis 2 H3: r hipótesis 3 C: pΛq Argumento lógico o conclusión. El argumento es lógico cuando la hipótesis implica la conclusión. (H1ΛH2ΛH3)→C (p→q) Λ (q→r)Λ(r)→ pΛq (Estructura del argumento). El resultado final de esta operación es una TAUTOLOGIA o debe de ser una TAUTOLOGIA. p V F V F V F V F. q V V F F V V F F. 18. r V V V V F F F F. (p q) V V F V V V F V. (q r) V V V V F F V V. Λ V V F V F F F F. →(p q) V V V V V V V V.

(20) Manual de Programación. Conceptos de Algoritmos 1) Es una serie de operaciones detalladas, organizadas para ejecutarse paso a paso, que conducen a la resolución de problemas. 2) 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 es denominada sentencia y éstas deben ser escritas en términos de cierto lenguaje comprensible para el computador, que es el lenguaje de programación. Diseño del 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. Criterios que debe satisfacer un algoritmo (características):. 1. Entrada. Debe existir una información de inicio o de partida. 2. Salida. Al menos una cantidad o acción o información de salida es producida. 3. Exactitud/precisión. Cada instrucción debe ser clara y sin ambigüedad. 4. Finito. Debe terminar después de un número finito de pasos. 5. Eficiente. Cada instrucción puede ser verificada con una prueba manual que satisfaga los requerimientos planteados por el problema.. 19.

(21) Manual de Programación. Partes en las que se estructura un algoritmo:. Pasos a seguir:. 1. Análisis del problema. 2. Diseño del algoritmo para resolverlo. 3. Verificación del algoritmo. 4. Implementación del algoritmo.. Entrada: información de partida. Procesos: operaciones y cálculos a realizar. Salida: resultados obtenidos.. Entrada. Proceso. Salida. Problema: preparar una taza de té. Ejemplo de algoritmo cotidiano. Advierta que se sigue un proceso de ejecución común y lógico, describiendo textualmente paso a paso cada una de las acciones a realizar dentro de una actividad determinada.. Algoritmo para asistir a clases: 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.. 20. Entrada: tetera, taza, bolsa de té. Salida: taza de té. Proceso: Inicio Tomar la tetera Llenarla de agua Encender el fuego Poner la tetera en el fuego Esperar a que hierva el agua Tomar la bolsa de té Introducirla en la tetera Esperar a que esté hecho el té Echar el té en la taza Fin. Levantarse Bañarse Vestirse Desayunar Cepillarse los dientes Salir de casa Tomar locomoción Llegar a IP de Chile Buscar el aula en el pantalla de informaciones Ingresar al aula Ubicarse en un asiento.

(22) Manual de Programación. ¿Cómo freír un huevo? (Referencia Profesor Sixto Alvarez Sisniegas) El algoritmo es la secuencia de instrucciones precisas que deben seguirse para realizar una tarea. Este concepto puede aplicarse a cualquier tipo de actividad: una receta de cocina es una secuencia de instrucciones que deben ejecutarse en un orden determinado. ¿Cuál sería el algoritmo para freír un huevo? Antes de escribir un programa hay que estudiar detenidamente el problema que se quiereresolver con él. Una vez definido el problema, es necesario establecer con toda exactitudla secuencia de pasos lógicos para desarrollar su resolución. Sin olvidar ninguno. Estasecuencia de pasos lógicos es lo que llamamos el algoritmo del programa. El algoritmo es, pues. La secuencia de instrucciones precisas que deben seguirse pararealizar una tarea. Este concepto se puede aplicar a cualquier tipo de actividad. Desde lasmatemáticas hasta la cocina. Los pasos necesarios Si tuviéramos que indicarle a otra persona cómo debe freír un huevo, le daríamos lasiguiente secuencia de instrucciones. 1. Sacar un huevo de la nevera. 2. Poner aceite en una sartén. 3 Encender el fuego. 4. Poner la sartén en el fuego. 5. Esperar a que se caliente el aceite. 6. Romper el huevo y echar la clara y la yema dentro de la sartén. 7. Si no hay que observar una dieta, echar sal en el huevo. 8. Esperar hasta que el huevo esté cocido. 9. Sacar el huevo de la sartén y ponerlo en un plato.. 21.

(23) Manual de Programación. En un algoritmo de este tipo advertimos varias cosas importantes: En primer lugar, cada instrucción es imprescindible: por ejemplo, si no encendemos elfuego, no podremos freír el huevo. Vemos, por tanto, que si una de las instrucciones nopuede ejecutarse el proceso se interrumpe. De no haber huevos en la nevera, la primerainstrucción no será posible y. naturalmente, no podremos freír el huevo. Puede que en la nevera no haya huevos por dos razones: porque se hayan terminado oporque estén en otro lugar. Así, si queremos evitar que el algoritmo falle porque no hayhuevos en la nevera, deberemos hacerlo algo más complejo para cubrir más posibilidades. Por ejemplo, podemos sustituir la primera instrucción del algoritmo por las siguientes: 1.1 Si hay huevos en la nevera, sacar uno. 1.2 Si no hay huevos en la nevera pero sí sobre la mesa, agarrar uno. 2.4 Si no hay huevos en la nevera ni sobre la mesa, ir a comprarlos y extraer uno de la caja Otra cosa que vemos es que las instrucciones deben ser precisas, si no, podemos tenerproblemas. Imaginemos que no se indica que la clara y la yema hay que echarlas en lasartén; alguien muy poco experto podría ser que rompiera el huevo sobre la mesa y laclara y la yema se desparramaran por el suelo. Para escribir un algoritmo usamos instrucciones de diferentes clases. Algunas describenuna acción (por ejemplo, poner aceite en la sartén), otras sólo se ejecutan si se cumpledeterminada condición, como el caso de la instrucción 7: sólo se echará sal en el huevosi no hay que cumplir una dieta, Las instrucciones de espera, como la 5 (esperar a que secaliente el aceite) y la 8 (esperar hasta que el huevo esté cocido) también dependen deuna condición: no podemos pasar a la siguiente instrucción hasta que se cumpla lo queesperamos. Ahora bien, podríamos aprovechar el tiempo de espera para ejecutar algunaotra instrucción, por ejemplo, asegurarnos de que el huevo quede bien cocido por encima. Entonces sustituiríamos la instrucción 8 por esta otra: 2.4 Echar aceite caliente por encima del huevo hasta que esté cocido. 22.

(24) Manual de Programación. Lenguajes de alto y bajo El lenguaje con que formulamos las instrucciones es muy importante. Hay que describirlas acciones de tal manera que puedan realizarse, si no, no podrá ejecutarse el algoritmo. Si la persona encarga el huevo no sabe cómo echar aceite en la sartén, debemos detallarmás esa instrucción ordenándole acciones que sepa realizar. En este caso la instrucción 2(poner aceite en una sartén) la describiríamos así: 2.1 Agarrar una sartén. 2.2 Agarrar una botella de aceite 2.3 Abrir la botella de aceite 2.4 Echar aceite de la botella dentro de la sartén hasta cubrir el fondo a la altura de 1 cm. 2.5 Cerrar la botella de aceite. 2.6 Guardar la botella de aceite La persona encargada de freír el huevo puede que sólo comprenda instrucciones muy básicas (agarrar; echar, encender, mirar, etc.) o que, al contrario, sea capaz de entenderinstrucciones complejas. En el primer caso necesitamos detallar mucho, mientras que en elsegundo caso puede bastar un algoritmo como este: 1. Romper un huevo en una sartén con aceite caliente 2. Sacar el huevo cuando esté cocido. Lo mismo sucede con la computadora. El nivel de detalle y la descripción de unalgoritmo, es decir, el lenguaje con que se expresa, depende del tipo de instrucciones quela maquina esté preparada para entender. Hablamos entonces de lenguajes de alto o bajonivel. Un lenguaje de bajo nivel describe acciones muy básicas, mientras que un lenguajede alto nivel parte de Instrucciones más complejas par a expresar el algoritmo. Cuandohemos explicado cómo echar aceite en una sartén hemos empleado un lenguaje de bajonivel, mientras que el algoritmo para freír el huevo en dos pasos está escrito en lenguajede alto nivel. Si lo pensamos un poco, veremos que cualquier receta de cocina no es más que un algoritmo, puesto que describe las instrucciones y el orden en que deben realizarse para preparar elguiso. Según lo detalladas que estén las acciones en la receta podremos decir que está escritaen lenguaje de alto o de bajo nivel.. 23.

(25) Manual de Programación. Representación de un algoritmo: Diagramas de flujo o flujo gramas. 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 del procedimiento. .  . Pseudocódigo. 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 flujo gramas: lentos de crear y difícil de modificar sin un nuevo redibujo. Diagramas N‐ S (Nassi‐Schneiderman o de Chapin). Son una herramienta que favorece la programación estructurada y reúne características gráficas propias de diagramas de flujo y lingüísticas propias de pseudocódigos.. Ejemplo de flujo grama Secuencia de flujo normal tiene un inicio una lectura o entrada de datos, el proceso de datos, una salida de información y un final.. Características: 1) Representación gráfica de la secuencia de pasos a realizar. 2) Las operaciones se escriben en símbolos normalizados. 3) Las líneas de flujo indican el orden de ejecución.. Simbología del flujo gramas. 24.

(26) Manual de Programación. VENTAJAS DE USAR FLUJOGRAMAS       . Rápida comprensión de las relaciones Análisis efectivo de las diferentes secciones del programa Pueden usarse como modelos de trabajo en el diseño de nuevos programas o sistemas Comunicación con el usuario Documentación adecuada de los programas Codificación eficaz de los programas Depuración y pruebas ordenadas de programas. DESVENTAJAS DE LOS FLUJOGRAMAS   . Diagramas complejos y detallados suelen ser laboriosos en su planteamiento y diseño Acciones a seguir tras la salida de un símbolo de decisión, pueden ser difíciles de seguir si existen diferentes caminos No existen normas fijas para la elaboración de los diagramas de flujo que permitan incluir todos los detalles que el usuario desee introducir.. Algunos ejemplos:. 25.

(27) Manual de Programación. 26.

(28) Manual de Programación. Pseudocódigo: Características: 1) Lenguaje de especificación de programas. 2) Utiliza palabras reservadas. 3) Exige una correcta indentación. 4) Se implementa con facilidad. Estructura de un programa en pseudocódigo: Cabecera:   . nombre del programa, declaración de constantes definición de variables.. Cuerpo del programa: . instrucciones a ejecutar.. Ejemplo comparativo: Diseñar un algoritmo que lea cuatro variables y calcule e imprima su producto, suma y media aritmética. Programa: cálculos varios Constantes: 4 Variables: a,b,c,d,producto,suma,media Inicio programa leer (a, b, c, d) producto <‐‐ (a * b * c * d) suma <‐‐ (a + b + c + d) media <‐‐ (a + b + c + d) / 4 escribir (producto, suma, media) fin programa. 27. Ejemplo: Programa: preparar taza de té Constantes: tetera, taza de té Variables: bolsa de té Inicio programa Tomar la tetera Llenarla de agua Encender el fuego Poner la tetera en el fuego Esperar a que hierva el agua Tomar la bolsa de té Introducirla en la tetera Esperar a que esté hecho el té Echar el té en la taza Fin programa.

(29) Manual de Programación. Un programa es = Algoritmo + Estructuras de Datos Elementos de un programa:      . Constantes: datos cuyo valor no cambia durante la ejecución del programa. Variables: datos cuyo valor puede cambiar durante la ejecución del programa. Expresiones: Combinación de operadores y operandos. Operandos: constantes, variables u otras expresiones. Operadores: aritméticos, relacionales, lógicos y de tipo de dato. Funciones: aceptan unos argumentos y producen un resultado.. Elementos de Estructuras de Datos.         . 28. Datos: objetos con los cuales opera un algoritmo. Tipo de un dato: determina qué operaciones se pueden efectuar con ese dato. Tipos de datos básicos: Entero: preciso y limitado en tamaño. Real: impreciso y limitado en tamaño. Lógico: valor de verdad. Cadena: secuencia finita de caracteres. Lista: secuencia finita de datos enumerados. Diccionario: secuencia finita de datos indexados..

(30) Manual de Programación. Otros elementos de programación Identificadores Nombres dados a las constantes simbólicas, variables, funciones y otros objetos manipulados por el programa. Características: 1) Debe resultar significativo. 2) No puede coincidir con ninguna palabra reservada. 3) Comenzará siempre por un carácter alfabético. 4) Generalmente solo se permite el uso de caracteres alfanuméricos y el símbolo _ (guión bajo). El Operador Asignación <nombre_de_variable><expresión> Características: 1) Se utiliza para dar valor a una variable. 2) Cualquier valor previo que tuviera se pierde. 3) La variable puede intervenir en la expresión que le da valor.. Tipos de Variables Contador: en determinados puntos del flujo del programa su valor se actualiza por una cantidad fija. Acumulador: en determinados puntos del flujo del programa su valor se actualiza para reflejar el estado actualde una serie de operaciones parciales. Interruptor: toma valores lógicos para reflejar el estado actual de una determinada propiedad.. 29.

(31) Manual de Programación. Palabras reservadas       . programa<nombre del programa> constantes variables inicio programa fin programa leer <expresión> escribir<expresión>. Traza de un Algoritmo. La traza de un Algoritmo se puede definir como la ejecución manual de forma secuencial de las sentencias que lo componen. Así, la traza del siguiente algoritmo es el valor que van adoptando las variables a medida que se va ejecutando un programa. +‐Algoritmo Suma | | Variable entera a, b | | Escribir "Indique el primer sumando" | Leer a | Escribir "Indique el segundo sumando" | Leer b | c=a+b | Escribir "El resultado es: ";c |. 30.

(32) Manual de Programación +‐Final. +‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ |TRAZA| +‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ | Comentario | Valores | +‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ | Leemos a: | a <‐ 4 | | Leemos b: | b <‐ 5 | | Calcula c: | c <‐ a + b <‐ 9 | | Escribe c: | c <‐ 9 | +‐‐‐‐‐‐‐‐‐‐‐‐+‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐+ La función principal que posee realizar la traza de un algoritmo es la de comprobar que éste funciona correctamente o para realizar la etapa de depuración en la que se intenta corregir errores, simplificar el algoritmo al máximo e incrementar su eficacia y velocidad.. 31.

(33) Manual de Programación. Estructuras de Selección Las estructuras condicionales comparan una variable contra otro(s) valor (es), para que en base al resultado de esta comparación, se siga un curso de acción dentro del programa. Cabe mencionar que la comparación se puede hacer contra otra variable o contra una constante, según se necesite. Existen tres tipos básicos, las simples, las dobles y las múltiples.. Simples: Las estructuras condicionales simples se les conocen como “Tomas de decisión. Estas tomas de decisión tienen la siguiente forma:. Dobles: Las estructuras condicionales dobles permiten elegir entre dos opciones o alternativas posibles en función del cumplimiento o no de una determinada condición. Se representa de la siguiente forma:. 32.

(34) Manual de Programación. Dónde: Si: Indica el comando de comparación Condición: Indica la condición a evaluar Entonces: Precede a las acciones a realizar cuando se cumple la condición Instrucción(es): Son las acciones a realizar cuando se cumple o no la condición si no: Precede a las acciones a realizar cuando no se cumple la condición Dependiendo de si la comparación es cierta o falsa, se pueden realizar una o más acciones.. Múltiples: Las estructuras de comparación múltiples, son tomas de decisión especializadas que permiten comparar una variable contra distintos posibles resultados, ejecutando para cada caso una serie de instrucciones específicas. La forma común es la siguiente:. 33.

(35) Manual de Programación. Múltiples (En caso de): Las estructuras de comparación múltiples, es una toma de decisión especializada que permiten evaluar una variable con distintos posibles resultados, ejecutando para cada caso una serie de instrucciones específicas. La forma es la siguiente:. 34.

(36) Manual de Programación. Tipos de Datos Un tipo de dato es un atributo de una parte de los datos que indica al ordenador (y/o al programador) algo sobre la clase de datos sobre los que se va a procesar. Esto incluye imponer restricciones en los datos, como qué valores pueden tomar y qué operaciones se pueden realizar. Tipos de datos comunes son: enteros, números de coma flotante (decimales), cadenas alfanuméricas, fechas, horas, colores, coches o cualquier cosa que se nos ocurra. Por ejemplo, en el tipo "int" representa un conjunto de enteros de 32 bits cuyo rango va desde el ‐2.147.483.648 al 2.147.483.647, así como las operaciones que se pueden realizar con los enteros, como la suma, resta y multiplicación. Los colores, por otra parte, se representan como tres bytes denotando la cantidad de rojo, verde y azul, y una cadena de caracteres representando el nombre del color; las operaciones permitidas incluyen la adición y sustracción, pero no la multiplicación. Éste es un concepto propio de la informática, más específicamente de los lenguajes de programación, aunque también se encuentra relacionado con nociones similares de las matemáticas y la lógica. En un sentido amplio, un tipo de datos define un conjunto de valores y las operaciones sobre estos valores. Casi todos los lenguajes de programación explícitamente incluyen la notación del tipo de datos, aunque lenguajes diferentes pueden usar terminología diferente. La mayor parte de los lenguajes de programación permiten al programador definir tipos de datos adicionales, normalmente combinando múltiples elementos de otros tipos y definiendo las operaciones del nuevo tipo de dato. Por ejemplo, un programador puede crear un nuevo tipo de dato llamado "Persona" que especifica que el dato interpretado como Persona incluirá un nombre y una fecha de nacimiento. Un tipo de dato puede ser también visto como una limitación impuesta en la interpretación de los datos en un sistema de tipificación, describiendo la representación, interpretación y la estructura de los valores u objetos almacenados en la memoria del ordenador. El sistema de tipificación usa información de los tipos de datos para comprobar la verificación de los programas que acceden o manipulan los datos.. 35.

(37) Manual de Programación. Todos los datos que utilizan los programas son simples o compuestos.. Dato simple Es indivisible (atómico), es decir, no se puede descomponer. EJEMPLOS: Año.....: 2006 Letra...: t. Dato compuesto Está formado por otros datos. EJEMPLOS: Nombre de persona: Nombre...: Ana (compuesto por tres caracteres) Fecha: Día...: 30 Mes...: 11 Año...: 2006 Ficha: Nombre...: Maite Ciudad...: Santiago Fecha de nacimiento: Día...: 22 Mes...: 4 Año...: 1984 Coordenadas de un punto en un plano: x...: 34 y...: 21. 36.

(38) Manual de Programación. Datos estándares Simples: (primitivos, básicos o fundamentales) Entero, Real, Lógico, Carácter y Compuestos: (estructurados). Dato de tipo numérico: es aquel que puede tomar por valor un número (entero o real). Dato de tipo entero: es aquel que puede tomar por valor un número perteneciente al conjunto de los números enteros (Z). EJEMPLOS: Edad...: 29 Año....: 1976 En pseudocódigo, utilizamos la palabra reservada: entero o numérico en SLE. Dato de tipo real: es aquel que puede tomar por valor un número perteneciente al conjunto de los números reales (R). EJEMPLOS: Peso.....: 75,3 Altura...: 172,7 En pseudocódigo, utilizamos la palabra reservada: real. Dato de tipo lógico (booleano): es aquel que puede tomar por valor sólo uno de los dos siguientes: {verdadero, falso} Un dato de tipo lógico siempre está asociado a que algo se cumpla o no se cumpla. EJEMPLO: El estado de una barrera de paso de trenes (asociando verdadero a que esté subida y falso a que esté bajada). Estado...: falso (indica que la barrera está bajada) En pseudocódigo, utilizamos la palabra reservada: lógico. Dato de tipo carácter: es aquel que puede tomar por valor un carácter perteneciente al conjunto de los caracteres que puede representar el ordenador. EJEMPLO: en un examen con preguntas en las que hay que seleccionar la respuesta correcta entre varias opciones dadas (a, b, c, d, e), la respuesta correcta de cada una de las preguntas es un dato de tipo carácter. Respuesta correcta a la pregunta 3...: ‘c’ En pseudocódigo, utilizamos la palabra reservada: carácter.. 37.

(39) Manual de Programación. Dato de tipo cadena: es aquel que puede tomar por valor una secuencia de caracteres. EJEMPLO: el título de un libro y el nombre de su autor, son datos de tipo cadena. Título...: “La Odisea” (cadena de 9 caracteres) Autor....: “Homero” (cadena de 6 caracteres) En pseudocódigo, utilizamos la palabra reservada: cadena Todos los datos simples son ordinales, excepto el tipo de dato real. Dato ordinal: es aquel que puede tomar por valor un elemento perteneciente a un conjunto en el que todo elemento tiene un predecesor y un sucesor, excepto el primero y el último.. Operadores Aritméticos Los operadores aritméticos se usan para realizar cálculos de aritmética de números reales y de aritmética de punteros. C++ dispone de los siguientes:. Operador + * / %. 38. Nombre Ejemplo Suma 3+4 Diferencia 3-4 Producto 3*4 Cociente 20/7 Módulo 20%7.

(40) Manual de Programación. Operadores Lógicos Los operadores relacionales, también denominados operadores binarios lógicos y de comparación, se utilizan para comprobar la veracidad o falsedad de determinadas propuestas de relación (en realidad se trata respuestas a preguntas). Las expresiones que los contienen se denominan expresiones relacionales. Aceptan diversos tipos de argumentos, y el resultado, que es la respuesta a la pregunta, es siempre del tipo cierto/falso, es decir, producen un resultado booleano. < > <= >= == ¡=. Menor que Mayor que Menor o igual que Mayor o igual que Igual que (identidad) Desigual que (desigualdad). Operadores Lógicos Los operadores lógicos producen un resultado booleano, y sus operandos son también valores lógicos o asimilables a ellos (los valores numéricos son asimilados a cierto o falso según su valor sea cero o distinto de cero). Por contra, recuerde que las operaciones entre bits producen valores arbitrarios. Los operadores lógicos son tres; dos de ellos son binarios, el último (negación) es unario. Tienen una doble posibilidad de representación en el Estándar C++ actual: la representación tradicional que se indica a continuación, y la natural introducida recientemente que se detalla más adelante.. Y lógico O lógico Negación lógica. 39. && || !. AND OR NOT.

(41) Manual de Programación. Práctica Compilador SLE Desde este punto realizaremos nuestra práctica de los puntos antes mencionados, utilizando el compilador SLE (*) desarrollado por el Centro Nacional de Computación CNC de la Universidad Nacional de Asunción. Este compilador nos da la posibilidad de desarrollar aplicaciones en ambiente de estudio (*), basándonos en pseudo código y sus instrucciones en español. Podemos realizar numerosas tareas como si de un compilador de producción (*) se tratase.. *Ambiente de estudio: software desarrollado únicamente para aprendizaje. *Compilador de producción: software para desarrollar aplicaciones profesionales. * SLE: Study Language Environment. Extracto SL es un lenguaje diseñado para apoyar la formación profesional de estudiantes de Informática. Las construcciones del lenguaje fueron cuidadosamente seleccionadas para que el alumno se concentre en la búsqueda de las soluciones algorítmica apropiadas, obviando detalles de implementación que seguramente tendrá ocasión de estudiar en otras etapas de su aprendizaje. El lenguaje presenta características que lo hacen apropiado para expresar algoritmos de las etapas iniciales del aprendizaje, pero simultáneamente reúne un rico conjunto de construcciones que posibilitan el tratamiento de tópicos más avanzados de estructuras de datos y programación modular. El entorno de desarrollo se llama SLE. La versión más reciente de SLE está disponible para Windows (Windows 95/98, 2000, NT, XP) y Linux.. 40.

(42) Manual de Programación. Principales características de SLE Posee un conjunto simplificado de tipos de básicos: numéricos (enteros y reales, sin distinción), cadenas y booleanos. Se acepta la ñ (mayúscula y minúscula) como carácter constituyente de un identificador. Pueden definirse registros y arreglos uni‐ y multidimensionales de cualquier tipo. Los arreglos pueden tener un tamaño fijo o se declarados “abiertos”, en cuyo caso pueden ser “dimensionados” durante la ejecución. Las cadenas son dinámicas, es decir, su longitud se ajusta automáticamente para contener la secuencia de caracteres que se requiera, sin obligar a la definición explícita de una longitud máxima. Los subprogramas comprenden funciones y subrutinas, los que pueden recibir parámetros por valor o por referencia. Las funciones pueden retornar valores de cualquier tipo de datos, incluyendo registros y arreglos. Los subprogramas no necesitan “prototipos” y pueden aparecer en cualquier orden dentro del cuerpo del programa fuente. Para descarga de Software e instrucciones de uso: Disponibilidad: http://www.cnc.una.py/sl/. 41.

(43) Manual de Programación. Esta es nuestra primera aplicación en SLE, podemos desprender elementos básicos importantes:. /* */ : Esta simbología representan un comentario, quiere decir que podemos escribir cualquier cosa dentro de él y no afectará el funcionamiento de nuestra aplicación, los desarrolladores los utilizan para escribir breves reseñas del trabajo que están realizando en determinadas secciones de sus programas. Var: Apartado para la declaración de variables, en SLE podemos definir algunos tipos de datos.. Inicio: Inicio del programa, todo lo que programemos debe estar dentro del apartado inicio – fin.. Fin: Marca el fin de nuestro programa.. 42.

(44) Manual de Programación. Desarrollaremos una aplicación que simplemente muestre en pantalla un número contenido en una variable.. Declaramos la variable de nombre “a” y definimos que va a contener datos de tipo número.. a = 2: Utilizamos el operador de asignación “=” para así poder asignar un valor a la variable “a”, siempre que queremos cambiar el valor de una variable utilizaremos el operador de asignación “=”. Imprimir(): La instrucción (función desde aquí en adelante) imprimir nos permite mostrar un mensaje en la pantalla del PC, esta función tiene la particularidad de poder mostrar mensajes y valores de variables incluyendo una coma (,). Imprimir debe siempre escribirse con paréntesis imprimir() y el texto que deseamos mostrar en pantalla debe ir siempre en comillas (“texto”); por ejemplo si deseamos mostrar en pantalla “primer programa” deberíamos hacerlo de la siguiente forma: Imprimir(“primer programa”);. 43.

(45) Manual de Programación Es importante recalcar el uso de punto y coma “;” final, toda función debe terminar con punto y coma. Para mostrar el valor de una variable basta con llamarla con una coma después de un texto Si deseamos mostrar por ejemplo solamente lo que contiene la variable “a”: Imprimir(a); Si deseamos mostrar un texto más el valor contenido en la variable “a”: Imprimir(“texto”,a);. Menú de SLE. En este menú es importante destacar los botones de compilación y ejecución:. Botón de compilación : Compilar es la acción de preparar el código escrito en SLE y transformarlo a lenguaje de máquina, recordemos que los PC´s leen código binario, el código sin compilar se denomina “código fuente”. Entonces el botón compilar lee nuestro código fuente y lo transforma en un código en lenguaje de maquina o binario. Cada vez que presionamos el botón de compilación, si no hemos guardado nuestro archivo, SLE nos exige que lo hagamos.. 44.

(46) Manual de Programación. Si nuestra aplicación no presenta errores de compilación SLE nos muestra un mensaje de compilación exitosa. Es en este punto en el cual nos encontramos preparados para ejecutar nuestra aplicación.. 45.

(47) Manual de Programación. Botón de ejecución : Este botón una vez que nuestra aplicación se encuentra compilada nos permite ejecutarla y ver su comportamiento en la “ventana de ejecución”. Este es el resultado de nuestra aplicación, simplemente muestra en pantalla el valor contenido en la variable “a”.. 46.

(48) Manual de Programación Crearemos otro programa de ejemplo con las operaciones aritméticas básicas: Para ello declaramos ocho variables del mismo tipo (numérico) separándolas por coma (,). Asignamos un valor a las variables de la “a” a la “d”, luego a las variables suma, resta, mult y div, asignamos una operación. El resultado de la operación quedará contenido en ellas, por ejemplo: La variable suma = a + b, la variable “a” contiene dos y la variable “b” contiene dos, algo obvio es el resultado de la operación suma = 4, el resultado 4 quedará contenido dentro de la variable suma y sucederá lo mismo con las variables resta, mult y div.. Variable “a”. Variable “b”. 2. 2. 47. Variable “c” 3. Variable “d” 5. Variable “suma” 4. Variable Variable Variable “resta” “mult” “div” ‐2 10 0.6.

(49) Manual de Programación Mostramos el resultado de cada una de las operaciones utilizando la función imprimir, escribiendo un mensaje más el valor de las variables con las operaciones respectivas:. Un problema que se nos presenta es que a la hora de ejecutar, el código va quedando en la ventana de ejecución y no se va de esta, una buena forma de solucionar esto, es utilizando la función cls(); CLS es una función de MS‐DOS y significa Clear Screen, con lo cual cada vez que ejecutemos nuestra aplicación la pantalla se encontrará limpia.. Función CLS:. Agregamos la función a nuestro código, puede ser justo luego del inicio del programa o donde el programador la desee.. 48.

(50) Manual de Programación. Aquí se puede apreciar la ventana de ejecución sin el código de ejecuciones anteriores, pero aún nos presenta un problema. Al mostrar más de un mensaje con imprimir(), estos salen hacia el lado.. La solución es agregar “\n” al principio del mensaje, siempre dentro de las comillas, también puede ir al medio o al final de este como el desarrollador así lo estime conveniente. “\n” en entornos de desarrollo significa new line o línea nueva.. 49.

(51) Manual de Programación Agregamos el operador “\n” a cada uno de los mensajes de la función imprimir(). Aquí tenemos el resultado correctamente escrito, pero con un último detalle; nótese que los resultados están inmediatamente “pegados” al mensaje.. Para formatear esto de mejor manera podemos un incluir dos puntos seguido de un espacio “: “ de la siguiente : forma imprimir(“texto: “, variable); esto último corresponde solamente a un tema visual y no funcional.. 50.

(52) Manual de Programación Hay que destacar que el espacio debe ir antes del cierre de la última comilla (“). Repetimos lo mismo en el resto de nuestras líneas. Ahora podemos apreciar el correcto despliegue de información:. Programa que ingresa la edad obtenida desde el teclado.. 51.

(53) Manual de Programación Este programa muy similar al anterior solamente integra la utilización de la función leer() La función leer habilita la entrada de datos desde teclado, con esto el usuario puede escribir algún dato y este ingresará directamente a una variable que selecciones para su almacenamiento. Leer(variable); Es necesario para el correcto entendimiento por parte de los usuarios que usen nuestro aplicativo el mostrar un mensaje en pantalla para requerir el ingreso de información, es común ver la utilización de funciones imprimir() en conjunto con funciones leer(), como lo muestra la siguiente imagen.. Entonces:      . Declaramos una variable llamada “a” de tipo numérico Iniciamos nuestra aplicación (inicio) Mostramos un mensaje en pantalla para que el usuario se entere de que debe escribir algo (imprimir(“\n Ingrese edad”);) Leemos la edad y la almacenamos en la variable “a” (leer(a);) . Mostramos la edad ingresada por el usuario en pantalla (imprimir(\n La edad ingresada es: “, a)); Para finalizar llamamos a la instrucción “fin”. 52.

(54) Manual de Programación. Desarrollo de Algoritmos (Pseudocódigo) En este apartado desarrollaremos algunos algoritmos y su correspondiente explicación.. Ejercicio nº 1 Escribir un algoritmo que lea un valor entero, lo doble, se multiplique por 25 y visualice el resultado.. 53.

(55) Manual de Programación. Analizando el ejercicio: Las líneas 1 y 2 contienen los comentarios, la línea 4 contiene la declaración de variables, se ha declarado una sola variable llamada “num” y es de tipo numérico, es decir solo puede contener dentro de sí, números.. Línea 6 marca el inicio del programa, línea 8 limpia la pantalla del compilador SLE, línea diez llama a la función “imprimir()” se muestra un mensaje en pantalla para pedir al usuario el ingreso de información, en este caso un número, cualquier número. La línea 11 contiene la función “leer()”, esta línea en particular permite a nuestro programa el aceptar ingreso desde el teclado. Todo lo que el usuario escriba quedara almacenado dentro de la variable que le indiquemos a la función leer(), en este caso, estamos indicando a nuestro programa mediante la función leer() que lo que se escriba se guarde en la variable “num”, “leer(num)”. En la línea 13, la variable “num” que en ese momento está cargada con el dato que el usuario a ingresado (en este caso el usuario ingresó el número “2”), se va a cargar nuevamente mediante el operador de asignación “=” con lo que tiene num (2) multiplicado por 2, con esto el primer objetivo que es “doblar el número ingresado” se cumple quedando almacenado dentro de la variable num, el número 4. La siguiente línea (14) vuelve a multiplicar lo que contiene la variable “num” por 25, es decir multiplica 4 (valor contenido en “num” hasta el momento) + 25. Este último valor queda nuevamente almacenado en la variable “num”. La línea 16 simplemente muestra el resultado final de la operación y lo que contiene al momento del término del programa la variable “num”.. 54.

(56) Manual de Programación. Ejercicio nº 2 Diseñar un algoritmo que lea 4 variables y calcule e imprima su producto, su suma y su promedio.. 55.

(57) Manual de Programación. Analizando el ejercicio:             . .  . Línea 1 y 2: comentarios sobre el ejercicio (no afecta a la aplicación). Línea 4: declaración de variables tipo numéricas. Línea 7: marca el inicio de la aplicación. Línea 9: limpia la ventana de ejecución SLE. Línea 11: la función imprimir le indica al usuario que ingrese un numero mediante teclado. Línea 12: la función leer está capturando lo que ingresa el usuario por teclado y lo almacena en la variable “num1”. Línea 14: pedimos al usuario el ingreso nuevamente por teclado. Línea 15: guardamos lo ingresado por el usuario, esta vez en la variable “num2”. Línea 17: pedimos al usuario el ingreso nuevamente por teclado. Línea 18: guardamos lo ingresado en la variable “num3”. Línea 20: pedimos al usuario que ingrese por última vez un número. Línea 21: guardamos lo que ingresa el usuario en la variable “num4”. Línea 23: la variable “suma” es cargada con la suma de la variable num1, num2, num3 y num4, en este caso la variable se carga con el valor 12. El resultado de la suma queda contenido en la variable “suma”. Línea 25: esta línea contiene el resultado de la operación “producto”, lo que resulte de la operación num1 * num2 * num3 * num4 quedará contenido en la variable producto, mediante el uso del operador “=” al igual que lo que ocurre en la operación “suma”. Línea 27: contiene el resultado de la división de lo contenido en la variable suma divido en 4, es decir suma que contiene 12 se divide en 4, como resultado obtenemos: 3. Línea 35: marca el fin de nuestro aplicativo.. 56.

(58) Manual de Programación. Ejercicio nº 3 Diseñar un algoritmo que lea el peso de un hombre en libras y nos devuelva su peso en kilogramos (ayuda: 1 libra equivale a 0.453592 kilogramos).. Analizando el ejercicio:  .       .  . Líneas 1,2 y 3: comentarios de la aplicación Línea 5: se declara la variable “kilo_por_libra” sin definir su tipo de dato, de esta forma SLE asume que se puede guardar cualquier información en la variable, para este caso vamos a utilizar números reales (números con decimal). Línea 6 definimos la variable “peso_en_libra ” y la iniciamos en 0 Línea 7: declaramos la variable peso_final que va a contener el resultado de la operación. Línea 9: iniciamos nuestra aplicación. Línea 10: limpiamos la ventana de ejecución de SLE. Línea 12: imprimimos al usuario un mensaje en pantalla que pida el ingreso de datos. Línea 13: leemos y guardamos lo que el usuario introdujo mediante teclado utilizando la función leer(), lo que se introduce queda almacenado en la variable “peso_en_libra”. Línea 16: En la variable “peso_final” estará contenido el resultado de la operación aritmética de multiplicación de lo que contiene la variable “peso_en_libra” *(por) la variable “kilo_por_libra”. Línea 17: imprimimos el resultado de nuestra operación en pantalla. Línea 20, indica el final de nuestra aplicación.. 57.

(59) Manual de Programación. Ejercicio nº 4 Ingresar un número y comprobar si es mayor a 77, utilizando Estructuras condicionales.. Ejecutamos nuevamente…. Analizando el ejercicio:       . Línea 1 y 2: comentarios. Línea 4: se declara una variable numérica. Línea 6: inicio de la aplicación. Línea 7: limpieza de pantalla de ventana de ejecución. Línea 9: pedimos al usuario el ingreso de datos de un número cualquiera. Línea 10: almacenamos lo que ingresa el usuario mediante la función leer(), lo que ingrese el usuario se almacena en la variable “num”, ”leer(num)”. Línea 12: preguntamos y evaluamos la condición “¿si num > 7?” de la siguiente manera si(variable condición){ instrucciones… } Con esto preguntamos a la aplicación si la variable. 58.

(60) .  . Manual de Programación a evaluar (en este caso “num”) cumple con la condición de ser mayor que 77, de ser así se entra en el apartado de la condición cuando se cumple esta, mostrando como resultado “El numero ingresado ES mayor a 77!!”. Línea 14: esta expresión (sino) se utiliza para ejecutar alguna instrucción “solamente” en el caso de que la evaluación del apartado si() no se cumpliese, de ser este el caso, la instrucción del apartado si() no se ejecuta llevándonos inmediatamente a la ejecución de las instrucciones que se encuentren en el apartado “sino”, para este caso si no se cumple la condición, es decir, si nuestro número ingresado no es mayor a 77, mostramos en pantalla el mensaje “El numero ingresado NO es mayor a 77!!”. Línea 16: indica el término de la instrucción “si()”. Línea 18: indica el término de la aplicación.. Ejercicio Nº 5 (si anidado) Realizar un algoritmo que permita ingresar 3 números e imprima el mayor de ellos.. 59.

(61) Manual de Programación. Analizando el ejercicio:           . .  . Línea 1 y 2: comentarios Línea 5: declaración de variables. Línea 7: inicio de la aplicación. Línea 9: limpieza ventana ejecución. Línea 11: se pide el ingreso del primer número. Línea 12: se almacena utilizando leer, el numero en variable “num1” línea 14: se pide ingreso de segundo número. Línea 15: se almacena el número en variable “num2”. Línea 17: se pide el ingreso del tercer número. Línea 18: se almacena tercer número en variable “num3”. Línea 20: comprobamos si el primer número es mayor que el segundo número, si esa condición se cumple inmediatamente entramos en otra condición si() (línea 21) en la cual preguntamos si num1 es mayor a num3, aquí ya podemos mostrar nuestro mensaje el cual indica que el número mayor es num1 (en el caso de serlo) o bien mostramos que el número mayor es el num3 y cerramos nuestra condición si() quedándonos aún abierta la primer condición si(num1 > num2) (línea 20). Línea 26: en este punto estamos desde la primer comprobación si(num1 > num2), en el caso que num1 no sea mayor a num2 ,entraremos en este sino{ } el cual simplemente entra en otra condición si() pero esta vez comprueba que num2 sea mayor a num3, en síntesis lo que hace este ejercicio es comprobar un numero contra otro hasta establecer cuál de estos sea el mayor. línea 28: muestra en el caso de que el num2 sea mayor que num3. Línea 29: sino.. 60.

(62) Manual de Programación    . Línea 30: en el caso de que num 2 no sea mayor a num3 muestra el correspondiente mensaje de la línea 31. Línea 31: fin si(). Línea 32: fin si() nuevamente. Línea 34: fin del programa.. Ejercicio nº 6 Despliegue las tablas de multiplicar. 61.

(63) Manual de Programación. Traza del ejercicio Ciclo i Ciclo k R (i * k) 1 1 1 1 2 2 1 3 3 1 4 4 1 5 5 1 6 6 1 7 7 1 8 8 1 9 9 1 10 10 2 1 2 2 2 4 2 3 6 2 4 8  Nota: el algoritmo se continúa ejecutando de la misma forma hasta que el ciclo “i” llegue a 10.. 62.

(64) Manual de Programación. Ejercicio nº8 Pseudocódigo que pida la edad y el sexo y dependiendo si es hombre o mujer, indique si puede votar o no.. 63.

(65) Manual de Programación. Según el ejemplo la persona ingresa la edad de 18 años y su sexo es h (hombre), entonces puede votar, la traza se expresa la siguiente manera: Traza del ejercicio: Edad. Sexo. Sexo == h. Sexo == m. Edad > 17. 18. h. si. no. si. ¿Puede votar? si. Suponiendo que ingresamos una mujer de 15 años la traza se expresaría de la siguiente manera: Edad. Sexo. Sexo == h. Sexo == m. Edad > 17. 15. M. No. Si. No. 64. ¿Puede votar? no.