Programación I - Modulo II

Programación I/Módulo II 1

Unidad 2- Primeros Diagramas

INTRODUCCIÓN Y ORIENTACIONES PARA EL ESTUDIO 2

OBJETIVOS ................................................................................................................... 2

ACLARACIONES PREVIAS AL ESTUDIO ................................................................................. 2

INTRODUCCIÓN 3

ESTRATEGIA DE RESOLUCIÓN ............................................................................................ 3

EJEMPLO 1.................................................................................................................... 4

CONSTANTES Y VARIABLES............................................................................................... 5

INTRODUCCIÓN A LOS DIAGRAMAS DE NASSI-SHNEIDERMAN ................................................. 9

OPERADORES............................................................................................................... 11

OPERADORES ARITMÉTICOS ................................................................................................11

OPERADORES DE RELACIÓN.................................................................................................12

OPERADORES LÓGICOS......................................................................................................12

EJERCICIO – OPERADORES .................................................................................................14

DIAGRAMAS NASSI-SHNEIDERMAN. CONDICIONALES Y CICLOS 15

DECISIONES SIMPLES. SÍ CONDICIONAL O IF – ELSE...................................................................15

DECISIONES MÚLTIPLES. SENTENCIA SWITCH ...........................................................................17

ALGUNOS CONCEPTOS SOBRE CICLOS REPETITIVOS ....................................................................18

CICLO MIENTRAS. WHILE...................................................................................................19

CICLO HACER - MIENTRAS. DO – WHILE ................................................................................20

CICLOS REPETITIVOS EXACTOS. FOR......................................................................................22

AUTO EVALUACIÓN: COMPLETE VERDADERO O FALSO Y JUSTIFIQUE. ....................................... 26

SÍNTESIS.................................................................................................................... 27

GLOSARIO .................................................................................................................. 28

Elaboración Gabriel F. Stancanelli

Damián A. Asman

Este material pertenece a la materia Programación I, de la Carrera de Analista de Sistemas de Computación del INSTITUTO DE TECNOLOGÍA ORT.

Todos los derechos reservados. No esta permitida la reproducción total o parcial de este apunte, ni su tratamiento informático, ni la transmisión de ninguna forma o por cualquier medio, ya sea electrónico, mecánico, por fotocopia, por registro u otros métodos, sin el permiso previo de los titulares.

2da edición Octubre de 2007.


Introducción y orientaciones para el estudio

En el desarrollo de este módulo abordaremos:

• Estructuras simples de datos como constantes y variables. • Resolución de problemas utilizando pseudocódigo (lenguaje natural). • Uso de las estructuras aprendidas en el módulo I de la materia. • Armado de diagramas de Nassi-Shneiderman para modelar la solución hecha en pseudocódigo. • Tipos de datos básicos.

Objetivos

Pretendemos que al finalizar de estudiar esta unidad, el alumno logre:

• Utilizar correctamente los diagramas de Nassi-Shneiderman • Realizar el análisis de problemas de baja y mediana complejidad • Dar la información necesaria para completar la guía número 1 de trabajos prácticos. • Utilizar correctamente las estructuras de control de flujo de un programa. • Entender y usar variables y constantes.

Aclaraciones previas al estudio

En este módulo, el alumno encontrará:

• Contenidos

• Conceptualizaciones centrales

• Bibliografía

• Referencia de material bibliográfico recomendado

• Actividades

Usted debe tener presente que los contenidos presentados en el módulo no ahondan profundamente en el tema, sino que pretenden ser un recurso motivador para que, a través de la lectura del material, la bibliografía sugerida, y el desarrollo de las actividades propuestas alcance los objetivos planteados en el presente módulo.

Cada módulo constituye una guía cuya finalidad es facilitar su aprendizaje.


Introducción

En el módulo I, hemos descrito los pasos para resolver algún problema de la vida cotidiana en un lenguaje natural y ordenado. Esta clase de esquema la llamamos pseudocódigo y sirve para que cualquier persona que quiera resolver el mismo problema, lo entienda y pueda ejecutar tal solución.

Para resolver estos temas, hemos aprendido a utilizar algunas estructuras de control de flujo, como el Sí Condicional y el ciclo Mientras (condición)-Hacer – Fin-Mientras.

En este módulo, empezaremos a utilizar constantes y variables, es decir, estructuras de datos que nos permitan almacenar datos, cosa que nosotros hacemos naturalmente usando, o bien nuestra memoria, o bien un cuaderno, un libro como bibliografía, etc.

Abordaremos el concepto de “problemas” desde lo computacional, buscando sus soluciones a través de un programa de computación.

Por último, comenzaremos a utilizar diagramas para modelar estas soluciones. Esta clase de diagramas es conocida a nivel mundial y su lenguaje es más universal que un idioma como el inglés o español.

Estrategia de resolución

Como trabajamos en el módulo I, antes de escribir la resolución del problema en términos de un diagrama o en pseudocódigo, desarrollamos una pequeña explicación de la situación y planteamos qué es lo que hacemos para resolver el problema. A esto lo llamamos análisis y estrategia de solución.

Si se fijan bien, también identificamos los datos y agregamos las hipótesis, en caso de ser necesarias, para la resolución del problema.

Cuando transferimos los datos al plano de los programas, tenemos que diferenciarlos en dos tipos: Datos de Entrada y Datos de Salida o información.

Flujo de datos

Los datos de entrada ingresan a un proceso, generando información. Esta información podrá ser utilizada luego para utilizar en otro proceso, es decir, utilizándola como datos de entrada y así sucesivamente. Vamos a plantear un primer ejemplo para poder identificar qué es un dato de entrada y qué un dato de salida. Luego de ver este ejemplo, haremos una declaración formal con el concepto más claro.


Ejemplo 1

1º Consigna

Una consultora en sistemas, paga a sus programadores $20 la hora. Dado el nombre de un programador y la cantidad de horas trabajadas, informar el nombre y el importe total a abonarle.

Claramente, el problema para la persona que debe pagar los sueldos estaría planteado del siguiente modo:

Debo pagarle a mis empleados y no se cuánto abonarle a cada uno.

Sin embargo, el problema en el plano de los programas, el que estamos abordando en esta materia, estaría planteado así:

Dados el nombre de un programador y la cantidad de horas trabajadas, informar el nombre y el importe total a abonarle.

Como pueden observar, es similar al planteo de la primera consigna. Sin embargo, hay una parte enunciada que no se incluye en el planteo del problema: el valor de la hora nos es dado como un dato de entrada.

Otro dato de entrada será el nombre, el cual se debe ingresar al programa antes de calcular el total a abonar.

¿Cuáles son entonces los datos de salida?

Pensar en los datos de salida es fundamental a la hora de empezar a resolver la estrategia de resolución, ya que son justamente lo que el proceso debe poder conseguir.

En este ejemplo, los datos de salida son:

• Nombre, • importe total a abonar.

Antes de comenzar a diagramar una solución, es fundamental identificar los datos de entrada y los de salida, es decir, con qué datos voy a contar

para poder obtener la información que el problema plantea.


Ahora que identificamos los datos de entrada y de salida, debemos analizar si con esta información es suficiente. En caso de que no lo sea, debemos plantear las hipótesis necesarias hasta completar la descripción.

El siguiente paso es pensar el problema (análisis y estrategia de solución) y escribir el pseudocódigo.

Siguiendo con el sistema planteado en el Modulo I, la resolución en pseudocódigo del problema que debemos resolver en este caso será:

1. Solicitar Nombre del programador.

2. Solicitar cantidad de horas trabajadas.

3. Multiplicar cantidad de horas trabajadas por 20.

4. Mostar por pantalla el nombre ingresado.

5. Mostrar por pantalla el importe a abonar.

En algunos casos los procesos trabajan con los datos de entrada y obtienen resultados que pueden ser de entrada a nuevos procesos.

En el ejemplo el dato de entrada, “Nombre”, también será un dato de salida y el resultado (cantidad de horas trabajadas por 20) es el dato de salida, y este puede ser de entrada a otro proceso.

Un ejemplo de esto sería si en el planteo anterior, mencionamos que, en caso de tener que cobrar más de $2000, debemos informar por pantalla un cartel que indique “Cobrar retención de Impuesto a las ganancias”.

De esta forma, el dato de entrada para saber si hay que imprimir o no este cartel, está dado luego de realizar el primer proceso, con el cual se obtiene cuánto debemos pagarle.

En este módulo vamos a trabajar con los datos, los procesos y las salidas.

Definimos qué son las constantes y las variables, cómo resolver un problema a través de un tipo especial de diagramas, y qué son las sentencias y las operaciones que se incluyen en los programas.

Constantes y Variables

Ahora bien, para poder realizar el programa planteado en la consigna 1 y en la mayoría de los programas, debemos contar con ciertas herramientas que nos permitan guardar los datos para poder utilizarlos en los diferentes procesos, obteniendo así el resultado esperado.

Las constantes son, como su nombre lo indica, datos que no van a cambiar durante todo el programa. En nuestro ejemplo, encontramos un valor constante, que será el valor de la hora, que ya viene dado en el enunciado. Si releen la consigna verán que se trata del valor 20.

Podemos entonces declarar1 una constante llamada VALOR_HORA y asignarle el valor 20. Si hacemos esto, nuestra solución quedaría de este modo:

1 Declarar implica indicarle al programa la utilización en estos casos de una constante o una variable. Básicamente es necesario para poder compilar un programa, es decir, prepararlo para su ejecución (ver apunte de TI)


/*Declaración de constantes*/ 2

const int VALOR_HORA = 20;3

(Notemos que a la constante le asignamos y, mediante el símbolo “=” le asignamos un valor.)

1. Solicitar Nombre al usuario

2. Solicitar cantidad de horas trabajadas

3. Multiplicar cantidad de horas trabajadas por VALOR_HORA para calcular el importe a abonar.

4. Mostar por pantalla el nombre ingresado

5. Mostrar por pantalla el importe a abonar

Notamos que hemos cambiado el valor 20 por el nombre de la constante. De esta forma, si el valor hora cambia, sólo debemos modificar el valor de la constante.

La ventaja de utilizar una constante en lugar del valor, puede verificarse fácilmente cuando utilizamos este mismo valor en diferentes lugares del programa.

Si hubiéramos utilizado el valor en cada parte del programa, deberíamos cambiarlo todas las veces que apareciera. Al utilizar una constante, nos aseguramos que al cambiar ese valor, se utiliza el mismo en todo el programa y evitamos cometer errores de lógica.

Las variables, en cambio, deben su nombre a que, a lo largo del programa, es posible que tomen diferentes valores.

Una variable es físicamente una porción de la memoria de la máquina. Al declarar una variable en un programa, le estamos indicando a qué parte de la memoria debe ir a buscar o grabar el valor cada vez que la utilicemos.

En nuestro ejemplo tenemos como dato de entrada el nombre y la cantidad de horas trabajadas. Estos datos van a variar cada vez que se ejecute el programa, para cada uno de los empleados. Esto nos indica que deben ser variables y no constantes.

Si observan las instrucciones de las líneas 3 y 5, en la primera se realiza un cálculo y en la segunda se muestra el resultado del mismo. Entonces, existe también una variable que será el resultado del producto de las horas trabajadas por el valor de la hora, cuyo valor ya almacenamos en la constante VALOR_HORA.

Cuando definimos una variable en un programa, es decir, cuando la estamos declarando, debemos especificar, además del nombre, un indicador del tipo de dato que contiene. Algunos tipos de dato son:

• int: Números enteros cuyo rango es -32.768 a 32.767 • float: Números reales. • char: Carácter, es decir, valores alfanuméricos. • String: Es una cadena de cadena de caracteres (tipo char): No existe en C/C++ un formato creado para este tipo de datos, sin embargo, lo utilizaremos en esta materia y se explicará en la materia Taller I cómo hacer una declaración correcta de este tipo.

2 Los comentarios en C/C++ pueden escribirse luego de dos barras // o inicializando un párrafo de comentarios con /* (barra y asterisco) y cerrándolo con la inversa */. Para más datos, ver apunte de TI

3 Las instrucciones en C/C++ deben terminar en punto y coma (;)


• Bool: Corresponde al tipo de datos booleano, es decir, solo puede almacenar TRUE (Verdadero) o FALSE (Falso). Al igual que los strings, no existe un formato standard de este tipo en C/C++. Pueden incrementar sus conocimientos respecto de estos tipos de datos en los módulos de la materia Taller I.

La sintaxis de C/C++ para la declaración de una variable es:

Tipo_de_dato Nombre;

Donde el tipo de dato corresponde a uno de los ya comentados.

Conceptualmente, el uso de un nombre correcto para cada variable permitirá al programador conocer, no solo el objetivo de ésta, sino también que valores puede almacenar. De esta forma, utilizaremos como la primer parte del nombre, un identificador para indicar el tipo (Ejemplo: para el tipo de dato int, el identificador será una i latina en minúscula), y finalmente el nombre de la variable, empezando con mayúscula.

A continuación mostramos un ejemplo de cómo declarar variables en un programa:

/*Declaración de variables*/ 4

int iEdad;

float fPromedio;

char cSexo;

String sNombre;

Bool bTieneHijos;

Es importante que el nombre asignado a las variables sea representativo, o mnemotécnico5, es decir, que con sólo leer su declaración, podamos entender qué tipo de dato contiene. Para esto se debe utilizar identificadores y nombre claros.

Retomemos el ejemplo y utilicemos variables

/*Declaración de constantes*/ const int VALOR_HORA = 20; /*Declaración de variables */ string sNombre; //Para el nombre del programador. float fCantHoras; //Para la cantidad de horas trabajadas. float fImporteTotal; //Para almacenar el importe a abonarle.


2. Guardar nombre en sNombre


4 La declaración de variables debe hacerse debajo de la declaración de constantes. Para más información, ver el Apéndice de Estilos de la materia TI.

5 Mnemotécnico: Nombre claro que indique qué representa o para qué se utilizará una variable o constante, dentro del programa.


4. Guardar cantidad en fCantHoras

5. fImporteTotal = fCantHoras * VALOR_HORA

6. Mostar por pantalla: “El empleado ”, sNombre, “ debe cobrar: $”, fImporteTotal

Como vemos, a diferencia del ejemplo anterior, ahora estamos indicando a dónde almacenamos 6 los valores que nos ingresa el usuario y el resultado de la operación, y los utilizamos, por ejemplo, en la instrucción 5.

6 Almacenar se refiere a la utilización de la memoria o archivos para no perder información y poder utilizarla


Introducción a los diagramas de Nassi-Shneiderman 7

Como indicamos en la introducción de este módulo, a partir de ahora vamos a resolver los problemas utilizando los diagramas de Nassi-Shneiderman.

Se basa en un diagrama de bloques que marca:

• comunicaciones con el usuario, tanto de entrada como de salida; • la asignación de variables; • el flujo del programa, junto con sus estructuras de cotrol como los condicionales y los ciclos.

Básicamente, es una combinación del pseudocódigo y los diagramas de flujo8.

En los diagramas no debe incluirse la declaración de constantes y variables. Estas deben figurar previamente, para que la persona que lee el diagrama, comprenda cuando se usan: de qué tipo son y para qué sirven.

Utilizando el ejemplo anterior, realicemos nuestro primer diagrama.

Primer diagrama

/*Declaración de constantes*/ VALOR_HORA = 20; /*Declaración de variables */ string sNombre; float fCantHoras; float fImporteTotal;

Pseudocódigo


2. Guardar nombre en sNombre


4. Guardar cantidad en fCantHoras

5. fImporteTotal = fCantHoras * VALOR_HORA

6. Mostar por pantalla: “El empleado ”, sNombre, “ debe cobrar: $”, fImporteTotal

7 Nassi shneiderman. 8 Diagrama de flujo.


Diagrama

“Ingresar nombre de usuario”

sNombre

“Ingresar cantidad de horas trabajadas”

fCantHoras

fImporteTotal fCantHoras * VALOR_HORA

“El empleado”, sNombre, “ debe cobrar: $ “, fImporteTotal

E

S

E

S

S

Vamos ahora a descomponer el diagrama y analizarlo, de manera de poder empezar a incorporar los conocimientos sobre el cómo utilizarlo y en qué situaciones.

Representar mensajes por pantalla

Para representar una salida por pantalla, debe utilizarse un rectángulo, en cuyo ángulo superior izquierdo lleve un pequeño cuadrado marcando una S de Salida.

De esta forma, es simple interpretar que lo que está en el recuadro, es lo que debe imprimirse.

Leer datos desde el teclado

La E en lugar de la S nos marca una Entrada, es decir, que el programa espera que el usuario ingrese un dato.

En el rectángulo, debe ir el nombre de la variable en dónde se va a almacenar el dato.Asignación de valores a

variables.


fImporteTotal fCantHoras * VALOR_HORA

Para asignarle un dato a una variable, se debe poner a la izquierda de la sentencia el nombre de la variable que va a recibir un valor, una flechita apuntándole ( � ) y el valor a asignarle. Este valor puede ser:

• Un valor propiamente dicho. • Una constante (se le asigna el valor de la constante). • Una variable (se le asigna el valor de la variable). • El resultado de una operación aritmética o lógica.

Como sucede en este caso, en el que la variable fImporteTotal recibe el resultado del producto del valor de una constante por una variable, el valor puede darse por alguna operación aritmética o lógica.

Salidas compuestas. Texto + variables.

Esta última instrucción del diagrama, sigue siendo una salida, como la S lo indica, sin embargo, sirve para mostrar que es posible combinar datos variables con un texto fijo.

Como pueden observar, el texto siempre va entre comillas, y las variables se separan del texto con comas.

Operadores

Los operadores son la herramienta que tenemos para indicarle al programa que debe realizar cierta operación. Existen operadores aritméticos, de relación o lógicos.

A continuación, daremos una lista de los operadores básicos junto con una breve explicación de cada uno de ellos.

Operadores Aritméticos

Son los operadores que utilizaremos para realizar las operaciones matemáticas:


Operador Operación

+ Suma. Los operandos pueden ser enteros o reales

- Resta. Los operandos pueden ser enteros o reales.

* Multiplicación. Los operandos pueden ser enteros o reales.

/

División. Los operandos pueden ser enteros o reales. Si ambos operandos son enteros el resultado es entero. En el resto de los casos el resultado es real. Como en una calculadora, no es posible dividir por 0.

\

División entera. Sin importar que tipo de datos tengan los operandos, el resultado es la parte entera del resultado. Ej: 3 \ 2 = 1 ya que el resultado de la operación es 1,5 y tomamos el resultado sin los decimales. Como en una calculadora, no es posible dividir por 0.

% Módulo o resto de una división entera. Los operandos tienen que ser enteros.

Operadores de relación

Los operadores de relación o de comparación permiten evaluar la igualdad y la magnitud. El resultado de una operación de relación es un valor verdadero o falso (1 ó 0, también llamados valores booleanos9). Los operadores de relación son:

Operadores lógicos10

El resultado de una operación lógica (AND, OR, XOR y NOT) da como resultado un valor lógico, es decir, Verdadero o Falso.

9 Booleanos..

10 Para ampliar el concepto utilizado en esta sección del apunte, puede leerse con más detalle el apunte de Matemática.

Operador Operación Ejemplo

< ¿Primer operando menor que el segundo? Op1 < Op2

> ¿Primer operando mayor que el segundo? Op1 > Op2

<= ¿Primer operando menor igual que el segundo? Op1 <= Op2

>= ¿Primer operando mayor o igual que el segundo? Op1 >= Op2

!= ¿Primer operando distinto que el segundo? Op1 != Op2

== ¿Primer operando igual que el segundo? Op1 == Op2


Los operadores lógicos sirven para unir expresiones que devuelvan valores booleanos, como las que utilizan operadores de relación, y obtener resultados compuestos, según las tablas de verdad11, que seguramente verán con más profundidad en matemática.

Operador Operación Ejemplo

&&

AND. Da como resultado verdadero si al evaluar cada uno de los operandos el resultado es verdadero. Si uno de ellos es falso, el resultado es falso. Si el primer operando es falso, el segundo operando no es evaluado.

Op1 && Op2

||

OR. El resultado es falso si al evaluar cada uno de los operadores el resultado es falso. Si uno de ellos es verdadero, el resultado es verdadero. Si el primer operando es verdadero, el segundo operando no es evaluado.

Op1 || Op2

! NOT. El resultado de aplicar este operador es falso si al evaluar su operando el resultado es verdadero, y verdadero en caso contrario.

! Op1

^

XOR. Da como resultado verdadero si al evaluar cada uno de los operandos el resultado de uno es verdadero y el del otro falso; en otro caso el resultado es falso.

Op1 ^ Op2

11 Tablas de verdad.


Ejercicio – Operadores

Resuelva las expresiones indicando el valor del resultado. Envíe luego el ejercicio resuelto al tutor para su corrección.

Sean:

a = 5; b = 8; c = 5; d = TRUE; e = FALSE; f = TRUE;

Nota: Recuerde que los valores TRUE y FALSE son los valores booleanos. Los primeros ejemplos están resueltos.

Operadores aritméticos

Operadores de relación Operadores lógicos

expresión valor expresión valor expresión valor

a – b -3 a == 5 TRUE d || f TRUE

(a - b) * c a <= b ! (f && d)

b % c (a + b) != c ! (e || f)

c * b + a * c (( a+c ) == 2 * a) e ^ f

a - b * c a >= c !d ^ f

(c + a) % c (( b+c ) == a) !d || (!d ^ f)

(c + b) % a (( b+c ) == a) ! (!e || e) && !d

a + b % c c == (b % a) ! (!d || e) && f


Diagramas de Nassi-Shneiderman. Sentencias condicionales y ciclos

Vamos a continuar ahora con el resto de los diagramas de N-S que aún no conocemos.

Tengan en cuenta que con cada diagrama, es posible realizar nuevos ejercicios prácticos que se encuentran en la guía de trabajos prácticos de la materia.

Decisiones simples. Sí condicional o if – else.

Como ya hemos visto, es posible que en algún momento dentro del flujo del programa sea necesario tomar un decisión, es decir, que el flujo permita realizar algunas acciones si se cumple una condición lógica, y otras en caso contrario.

Por ejemplo, y considerando el ejercicio que venimos desarrollando, decimos que, en caso de que un empleado trabaje más de 40 horas, el valor hora aumentara en un 15%. De esta forma, luego de pedirle al usuario que ingrese la cantidad de horas trabajadas, debemos resolver cuánto es el sueldo real, antes de multiplicarlo por esta cantidad.

Veamos cómo queda el diagrama

/*Declaración de constantes*/ const int VALOR_HORA_CAT1 = 20; // valor de la hora para la categoría 1 const int VALOR_HORA_CAT2 = 30; // valor de la hora para la categoría 2 const int TOPE_HORAS = 40; // tope que marca la diferenta entre las categorías. /*Declaración de variables */ string sNombre; float fCantHoras; float fImporteTotal;

Pseudocódigo

1. Solicitar Nombre al usuario 2. Guardar nombre en sNombre 3. Solicitar cantidad de horas trabajadas 4. Guardar cantidad en fCantHoras 5. Si ( fCantHoras <= TOPE_HORAS ) 5.1. Entonces 5.1.1. fImporteTotal � fCantHoras * VALOR_HORA_CAT1 5.2. Si no (es decir que es mayor) 5.2.1. fImporteTotal � fCantHoras * VALOR_HORA_CAT2 6. fImporteTotal = fCantHoras * VALOR_HORA 7. Mostar por pantalla: “El empleado ”, sNombre, “ debe cobrar: $”, fImporteTotal

Y se diagrama de este modo:


Como se puede apreciar, la diferencia con el diagrama anterior pasa por el bloque de la condición.

La condición lógica fCantHoras <= (Menor o Igual) TOPE_HORAS sólo puede devolver dos valores, verdadero o falso. En caso de que sea verdadero, entonces se ejecutaran los bloques siguientes del Si. Sino, se ejecutarán los del No.

Este cuadro representa el si condicional.

Debajo del si esta el entonces.

Debajo del no aparecen las instrucciones del sino.


Decisiones múltiples. Sentencia switch

A diferencia de un si condicional, existen oportunidades en que se debe decidir entre más de dos posibilidades. Las decisiones múltiples también se basan en una comparación, pero que puede resolver múltiples resultados.

Hasta ahora, a los programadores del ejercicio se les pagaba según la cantidad de horas trabajadas. Vamos a cambiar esta estrategia de pago y utilizaremos algo más real con el mundo de los sistemas. Dependiendo del Rol que cumpla, podemos decir que un programador Junior está en la categoría 1, un semi-senior en la categoría 2 y un senior en la categoría 3.

Vamos a solicitarle entonces, un dato más al usuario. La categoría del programador. De esta forma, las constantes y variables quedarían de este modo:

/*Declaración de constantes*/ const int VALOR_HORA_CAT1 = 20; const int VALOR_HORA_CAT2 = 30; const int VALOR_HORA_CAT3 = 40; /*Declaración de variables */ string sNombre; float fCantHoras; float fImporteTotal; int iCategoria; El diagrama de decisión múltiple es el siguiente:

iCategoria nos indica qué es lo que estamos evaluando. Los números 1, 2 y 3 indican las opciones posibles. Por último, este diagrama incluye un valor default, el cual se ejecuta siempre y cuando la condición o variable evaluada no corresponda con ninguna opción. El diagrama final quedaría de este modo.


Para hacer las cosas de un modo correcto, utilizaremos un Si condicional para evaluar si, en efecto, pudo calcularse correctamente el importe o no.

Para tener en cuenta respecto de la sentencia switch:

1. El valor que se está evaluando debe ser de tipo entero (int) o carácter (char). 2. Si el valor que se está comparando no está comprendido en ninguna de las opciones citadas y no

existe la cláusula default, no ocurre nada y sigue el flujo del programa. 3. La cláusula default es opcional. 4. cuando se implemente una solución con switch en C/C++, cada opción debe terminar con una

instrucción que indica el fin de la opción. La sintaxis de la instrucción en este lenguaje es: break. Algunos conceptos sobre ciclos repetitivos

Los ciclos repetitivos se utilizan en el momento en que es necesario repetir el mismo grupo de instrucciones una determinada cantidad de veces.

Existen dos tipos de ciclos: ciclos repetitivos condicionales, que dependen de una condición lógica para continuar repitiendo las instrucciones, o bien los ciclos repetitivos exactos, que repetirán las instrucciones una determinada cantidad de veces, previamente establecida.


Ciclo Mientras. While

El ciclo “Mientras”, que explicamos en el Módulo I de esta asignatura, permite que una cantidad finita de instrucciones se repita mientras una condición se cumpla. Existe la posibilidad de que nunca se ejecuten las instrucciones mencionadas. Hasta el momento, la secuencia de instrucciones que venimos manejando en el problema de los programadores, nos muestra que, con cada programador, debemos ejecutar el programa nuevamente. Vamos a hacer un cambio para que el programa sirva para calcular el sueldo de más de un programador, por lo tanto, la toma de los datos de entrada (nombre, cantidad de horas y categoría), se repita mientras el nombre del programador no sea “FIN”.

Veamos el diagrama final y analicémoslo a continuación.

fImporteToal != -1

Si No


sNombre


fCantHoras

“Por favor, ingrese los datos nuevamente”

E

S

E

S

S

“Ingresar categoría del empleado”

iCategoriaE

S


fImporteTotal

fCantHoras *

VALOR_HORA_CAT1

iCategoria

1 2 Default

fImporteTotal

fCantHoras *

VALOR_HORA_CAT2

fImporteTotal

fCantHoras *

VALOR_HORA_CAT3

fImporteToal

-1

“Categoría invalida”

3

S


sNombreE

S

sNombre != “FIN”

Hay ciertas cosas que marcar en este diagrama para que quede claro cómo es el funcionamiento de un ciclo de estas características:


• Lectura adelantada: Debemos solicitarle al usuario que escriba el nombre del programador previamente a ejecutar el ciclo.

• Condición lógica: Se indica en la parte superior del diagrama que representa el ciclo. Si la condición se evalúa como verdadera, comenzará a ejecutarse el ciclo. En este ejemplo, la condición pregunta si el contenido de la variable sNombre sea diferente que la palabra “FIN".

• Dentro del diagrama del ciclo, hay un grupo de instrucciones que serán el proceso repetitivo.

• Por último, generalmente ubicado como ultimas instrucciones dentro del ciclo (aunque no es necesario), se le solicita al usuario que ingrese nuevamente el nombre de un programador. Estas son las instrucciones que permitirán, en algún momento, salir del ciclo.


sNombreE

S

(Conjunto de sentencias dentro del bucle)


sNombreE

S

sNombre != “FIN” (condición de entrada al bucle)

Lectura Adelantada

Lectura repetitiva que define la salida del ciclo

Condicion de entrada. Si se evalua como

verdadera, entra al ciclo.

Es importante notar que una característica de este proceso repetitivo es el que las instrucciones que están dentro del ciclo pueden no ejecutarse nunca.

Por ejemplo, si en la lectura adelantada el usuario ingresara “FIN” como nombre del programador, la condición de entrada al ciclo no se cumpliría y directamente terminaría el programa.

Ciclo Hacer - Mientras. Do – While

A diferencia del ciclo “Mientras”, el “Hacer-Mientras” implica que un conjunto de instrucciones va a ejecutarse por lo menos una vez, antes de preguntar por la condición.

Nuevamente modificaremos el programa para incluir uno de estos ciclos. Por ejemplo, debemos asegurarnos que la cantidad de horas trabajadas es un número positivo.

Notemos que si fuera posible ingresar un número negativo, posiblemente el sueldo tomaría un valor erróneo. Para evitarlo, se realiza una validación, en la cuál prevenimos que los datos que lleguen a la ecuación de cálculo del sueldo sean correctos.


El diagrama quedaría de este modo.

fImporteToal != -1

Si No


sNombre


fCantHoras

“Por favor, ingrese los datos nuevamente”

E

S

E

S

S

“Ingresar categoría del empleado”

iCategoriaE

S


fImporteTotal

fCantHoras *

VALOR_HORA_CAT1

iCategoria

1 2 Default

fImporteTotal

fCantHoras *

VALOR_HORA_CAT2

fImporteTotal

fCantHoras *

VALOR_HORA_CAT3

fImporteToal

-1

“Categoría invalida”

3

S


sNombreE

S

sNombre != “FIN”

fCantHoras < 0

Veamos un poco más detalladamente el ciclo que acabamos de incorporar.


Las instrucciones que se encuentran dentro de este ciclo van a ejecutarse por lo menos una vez, debido a que la condición de repetición se encuentra al final.

Algo importante que no debe confundirse, es que este ciclo se ejecuta Mientras se cumple la condición y no hasta que se cumple.

Deben observar como el diagrama fue evolucionando, y como los diferentes bloques de cada estructura de control fueron indicando visualmente como se ejecutará el programa.

Ciclos repetitivos exactos. For

Cuando se debe ejecutar un conjunto de instrucciones una cantidad determinada y fija de veces, en lugar de utilizar un ciclo condicional, utilizamos lo que llamaremos ciclo repetitivo exacto, ya que sabemos exactamente cuántas veces tendremos que repetir el ciclo.

El tipo de ciclo que usaremos se llama For, debido a su sentencia en C/C++ (y en muchos otros lenguajes).

El For utiliza una variable, generalmente de tipo entero, que debe ser declarada previamente por el programador. Esta variable se irá incrementando en el ciclo hasta llegar al tope previamente establecido. Esto marcará el fin del ciclo, continuando con el flujo del programa.

Utilizaré este nuevo ejemplo para demostrar como utilizar el ciclo For:

Enunciado Un alumno recién graduado desea conocer el promedio de notas que ha sacado en la facultad. Durante 5 años, ha cursado 6 materias por año.

Realizar un programa que le solicite al usuario las notas de todas sus materias e informar el promedio de la carrera.

• ¿Qué datos de entrada tenemos? Las notas del alumno. • ¿Qué datos provistos tenemos? El enunciado ya nos informa la cantidad de materias que curso el

alumno ( 6 materias/año x 5 años = 30 materias) • ¿Cuáles son los datos de salida? El promedio de la carrera.

Hipótesis: No hay. No hacen falta ya que el enunciado es claro y preciso.


/*Declaración de constantes*/ const int CANT_MATERIAS = 30; /*Declaración de variables */ float fNota; flota fSumaNoras: float fPromedio; int i: //esta variable la utilizaremos como indice para contra los ciclos del For

Pseudocódigo

1. fSumaNotas = 0

2. Repetir (desde i = 1 hasta CANT_MATERIAS) //Utilizo una constante.

2.1. Mostrar por pantalla: “ Ingresar la nota nro: “, i

2.2. Guardar la nota en fNota

2.3. fSumaNotas = fSumaNotas + fNota

3. Fin Repetir.

4. fPromedio = fSumaNotas / CANT_MATERIAS

5. Mostar por pantalla: “El promedio de la carrera es de ”, fPromedio

El diagrama de la solución será:


El ciclo en particular es la parte del diagrama representada en gris, en el siguiente gráfico:

Es ciclo ira incrementando la variable i, solicitando las diferentes notas y sumándolas en fSumaNota. Noten que utilizo la variable i como salida en la solicitud de la nota, de esta forma, cuando i contenga el valor 1, solicitará la primer nota, pero una vez que realice el primer ciclo y valga 2, el cartel solicitará la nota nro 2.. y asi sucesivamente.


Trabajo Práctico: Realizar los diagramas

A partir del enunciado, identifique los datos de entrada y salida y, en caso de creerlo necesario, escriba las hipótesis. Desarrolle el análisis y la estrategia de resolución. Complete el ejercicio generando el algoritmo utilizando pseudocódigo. Realice los diagramas de N-S.

Envíe los resultados al tutor para la corrección del análisis.

1. Ingresados dos números, mostrar el resultado de la suma entre ambos.

2. Ingresar valores para las variables A y B. Una vez cargadas, intercalar los valores (que lo cargado en A quede en B, y viceversa).

3. Dados tres números, informar cuál de los tres es el mayor, y su valor (suponer único máximo).

4. Pedir un número tantas veces como necesite, hasta que su valor esté comprendido entre 1 y 10.

5. Dados dos números enteros cuya relación de valores es que el primero es menor o igual al segundo, escribir la secuencia de números que existe entre ambas:

a. Incluyéndolos;

b. Excluyéndolos.

c. En la carga, debemos asegurarnos de que la relación entre los valores es la correcta.

6. ¿Qué pasaría si este control no se tiene en cuenta? ¿Cómo lo solucionaría?

7. Leer una lista de números mientras el promedio entre todos sea menor a 20. Informar la cantidad de valores leídos.

8. Ingresar N juegos de N1 valores enteros cada uno, donde N se informa al comienzo y N1 al cargar cada juego. Emitir el número de juego con promedio más alto y la suma total de todos los juegos.

9. Ingresar una serie de números naturales que termina con -1 e indicar cuántas veces se interrumpe el orden ascendente y cuántos números hay en cada grupo ordenado.


Auto evaluación: Complete verdadero o falso y justifique.

1. Para realizar un proceso repetitivo, debo conocer que cantidad de veces deben repetirse las instrucciones.

2. Cuando utilizo un sí condicional, estoy haciendo que el programa pueda tener mas de un curso de acción

3. No puedo utilizar un ciclo Mientras y un ciclo Hacer-Mientras en el mismo programa

4. Los ciclos Hacer-Mientras se utilizan exclusivamente para realizar validaciones.

5. En todos los ciclos debe cumplirse una condición lógica para que deje de repetir las instrucciones.

6. Debo conocer la sintaxis de por lo menos un lenguaje de computación para poder realizar diagramas de N-S.

7. Las variables se utilizan únicamente para almacenar valores temporalmente.

8. Una condición lógica puede armarse únicamente utilizando operadores aritméticos y de relación.

Cuadro de resultados

Nro V ó F Justificación

1

2

3

4

5


6

7

8

Síntesis

Se introdujeron en este módulo los conceptos de Constante y Variable, estructuras de datos fundamentales que se utilizarán a partir de ahora y probablemente mientras programen.

A esto, se sumaron los diagramas de Nassi-Shneiderman y su utilización para modelar las soluciones antes planteadas con pseudocódigo.

Se hizo mención de los operadores aritméticos, lógicos y de relación, y se propuso una actividad para ejercitar con ellos. El alumno debe tener en cuenta que, al conocer estos operadores, las posibilidades de combinación son infinitas.

Al concepto de sí condicional introducido en el módulo I, se agrego la sentencia Switch, la cuál lleva al programa por más flujos diferentes, no solo dos.

Al ciclo Mientras (condición) – Fin-Mientras, se le sumaron otras estructuras de procesos repetitivos. El Hacer-Mientras, que permite ejecutar las sentencias una vez antes de preguntar por la condición de entrada al ciclo nuevamente y el For, el cuál se utiliza al conocer la cantidad exacta de repeticiones a realizar.

Se propusieron ejercicios de práctica, complementarios de la guía de trabajos prácticos para este módulo.

Nuevamente, se propuso un ejercicio simple de auto evaluación para verificar los conceptos adquiridos.


Glosario

• Constante:

• Variable:

• Declaración en c++:

• Mnemotecnico:

• Almacenar:

• Nassi-Sheneiderman:

• Diagrama de Flujo:

• Operador:

• Tablas de Verdad:

Programación I - Modulo II

Documents

Transcript of Programación I - Modulo II