algoritmos y programaciÓn estructurada en c++

AALLGGOORRIITTMMOOSS YY

PPRROOGGRRAAMMAACCIIÓÓNN

EESSTTRRUUCCTTUURRAADDAA EENN

CC++++

LLiilliiaann MM.. BBeenniiqquuee -- MMaarriiaa MM.. LLiimmaa

ALGORITMOS Y PROGRAMACIÓN ESTRUCTURADA EN C++

Maria M. Lima Quispe :::2:::

AALLGGOORRIITTMMOOSS YY PPRROOGGRRAAMMAACCIIÓÓNN EESSTTRRUUCCTTUURRAADDAA EENN CC++++ Lilian M. Benique R. – Maria M. Lima Q. 1ra. Edición: Marzo 2009

Derechos Reservados Edición e Impresión: RUC: Puno - Perú


Lilian M. Benique Ruelas :::3:::

Dedico esta obra a

a mi familia y a toda la juventud Juliaqueña.

L.M.B.R.



IINNTTRROODDUUCCCCIIÓÓNN

Los capítulos I y II son temas introductorios necesarios para empezar a resolver problemas con las computadoras, el capítulo III hace referencia a problemas de tipo secuencial, en el capítulo IV están los problemas de tipo selectivos (if, if – else, switch), y en el capítulo V tenemos problemas repetitivos (for, while, do-while).

Los arreglos unidimensionales y bidimensionales se encuentran en el capítulo VI, los métodos de ordenación y búsqueda se encuentran en los capítulos VII y VIII, finalmente el tema de funciones se encuentra en el capítulo IX. La mayoría de los ejercicios desarrollados en este libro contienen la parte de análisis, diseño y programación, los programas fueron escritos en el lenguaje de programación C++, para la parte de los diagramas de flujo se utilizó el programa DFD.



CCOONNTTEENNIIDDOO

CAPÍTULO 1: ALGORITMOS Y PROGRAMAS 1.1. LOS SISTEMAS DE PROCESAMIENTO DE LA INFORMACIÓN ..................... 7 1.2. ALGORITMOS ........................................................................................................... 8 1.2.1. Noción de Algoritmo .............................................................................................. 8 1.2.2. Características de los Algoritmos .......................................................................... 8 1.2.3. Partes de la definición de un Algoritmo ............................................................... 9 1.3. APLICACIONES ........................................................................................................ 9 1.3.1. Programas y Aplicaciones ...................................................................................... 9 1.3.2. El ciclo de vida de una aplicación ......................................................................... 10 1.4. LENGUAJES DE PROGRAMACIÓN ...................................................................... 11 1.4.1. Tipos de Lenguajes .................................................................................................. 11 1.4.2. Traductores de Lenguajes ...................................................................................... 12 1.4.2.1. Intérpretes ............................................................................................................. 12 1.4.2.2. Compiladores ....................................................................................................... 13 1.5. PROGRAMACIÓN .................................................................................................... 14 1.5.1. Programación Desordenada .................................................................................. 15 1.5.2. Programación Estructurada ................................................................................... 15 1.5.3. Programación Modular .......................................................................................... 15 1.5.4. Programación Orientada a Objetos ....................................................................... 15 1.6. DATOS Y TIPOS DE DATOS ................................................................................... 16 1.6.1. Datos Numéricos ..................................................................................................... 17 1.6.1.1. Enteros ................................................................................................................... 17 1.6.1.2. Reales ..................................................................................................................... 18 1.6.2. Datos Lógicos ........................................................................................................... 18 1.6.3. Datos tipo carácter y tipo cadena .......................................................................... 18 1.7. CONSTANES Y VARIABLES ................................................................................... 19 1.7.1. Constantes ................................................................................................................ 19 1.7.2. Variables ................................................................................................................... 20 1.8. EXPRESIONES ........................................................................................................... 21 1.8.1. Expresiones Numéricas .......................................................................................... 21 1.8.2. Expresiones Alfanuméricas .................................................................................... 22 1.8.3. Expresiones Booleanas ........................................................................................... 22 1.9. OPERADORES ........................................................................................................... 22 1.9.1. Aritméticos ............................................................................................................... 22 1.9.2. Alfanuméricos ......................................................................................................... 24 1.9.3. Relacionales ............................................................................................................. 24 1.9.4. Lógicos ...................................................................................................................... 26 1.9.5. Paréntesis ................................................................................................................. 27 1.9.6. Orden de prioridad de los operadores ................................................................. 27 1.10. FUNCIONES INTERNAS ....................................................................................... 28 1.11. LA OPERACIÓN DE ASIGNACIÓN .................................................................... 29 Preguntas de Repaso ........................................................................................................ 30 Ejercicios Propuestos ........................................................................................................ 32



CAPÍTULO 2: METODOLOGÍA PARA LA RESOLUCIÓN DE PROBLEMAS CON COMPUTADORAS 2.1. ANÁLISIS DEL PROBLEMA .................................................................................... 34 2.2. DISEÑO DEL ALGORITMO .................................................................................... 37 2.2.1. Representación de los algoritmos .......................................................................... 38 2.2.1.1. Pseudocódigo ....................................................................................................... 38 2.2.1.2. Diagramas de Flujo .............................................................................................. 40 2.2.1.3. Diagramas de Flujo con DFD .............................................................................. 42 2.2.1.4. Diagrama N – S ..................................................................................................... 45 2.3. RESOLUCIÓN DEL PROBLEMA CON LA COMPUTADORA .......................... 46 2.3.1. Codificación del Programa ..................................................................................... 46 2.3.2. Ejecución del Programa .......................................................................................... 47 2.3.3. Comprobación del Programa ................................................................................. 47 2.3.4. Documentación y Mantenimiento ......................................................................... 47 Preguntas de Repaso ........................................................................................................ 49 Ejercicios Propuestos ........................................................................................................ 50 CAPÍTULO 3: ESTRUCTURAS SECUENCIALES ........................................................ 52 Problemas Secuenciales .................................................................................................... 53 Ejercicios Propuestos ........................................................................................................ 73 CAPÍTULO 4: ESTRUCTURAS SELECTIVAS .............................................................. 75 4.1. ESTRUCTURAS SELECTIVAS SIMPLES ............................................................... 75 Problemas Selectivos Simples .......................................................................................... 77 4.2. ESTRUCTURAS SELECTIVAS DOBLES ............................................................... 84 Problemas Selectivos Dobles ........................................................................................... 86 4.3. ESTRUCTURAS SELECTIVAS MÚLTIPLES ......................................................... 97 Problemas Selectivos Múltiples ....................................................................................... 100 Ejercicios ............................................................................................................................ 110 CAPÍTULO 5: ESTRUCTURAS REPETITIVAS ............................................................. 113 5.1. ESTRUCTURAS REPETITIVA mientras ................................................................. 113 Problemas Repetitivos mientras ...................................................................................... 116 5.2. ESTRUCTURAS REPETITIVA hacer - mientras .................................................... 123 Problemas Repetitivos hacer - mientras ......................................................................... 125 5.3. ESTRUCTURAS REPETITIVA desde o para .......................................................... 128 Problemas Repetitivos para o desde ............................................................................... 130 Ejercicios ............................................................................................................................ 138 CAPÍTULO 6: ARRAYS ................................................................................................... 6.1. ARREGLOS UNIDIMENSIONALES: Los Vectores ............................................... 6.1.1. Declaración de Vectores ......................................................................................... 6.1.2. Operaciones con Vectores ...................................................................................... Ejercicios ............................................................................................................................ 6.2. ARREGLOS BIDIMENSIONALES: Las Matrices ................................................... 6.2.1. Declaración de Matrices ......................................................................................... 6.2.2. Operaciones con Matrices ...................................................................................... Ejercicios ............................................................................................................................ CAPÍTULO 7: ORDENACIÓN ........................................................................................ CAPÍTULO 8: BÚSQUEDA ............................................................................................. CAPÍTULO 9: FUNCIONES ............................................................................................



AALLGGOORRIITTMMOOSS

YY

PPRROOGGRRAAMMAASS



CCAAPPIITTUULLOO 11:: Algoritmos y Programas

1.1 LOS SISTEMAS DE PROCESAMIENTO DE LA

INFORMACIÓN

El sistema de procesamiento de la información es un sistema que transforma datos brutos en información organizada, significativa y útil.

- Figura 1.1: Sistema de procesamiento de la información -

La figura 1.1, nos muestra los tres componentes del sistema de procesamiento de la información: El PROCESADOR, que puede ser bastante complicado, se representa por una simple caja y puede aceptar datos llamados ENTRADA, y esta entrada se transforma entonces para producir una información denominada SALIDA o resultados. El conjunto de instrucciones que especifican la secuencia de operaciones a realizar, en orden, para resolver un sistema específico o clase de problemas, se denomina algoritmo.

Para realizar un proceso se le debe suministrar al procesador un algoritmo adecuado. Cuando el procesador es una computadora, el algoritmo ha de expresarse de una forma que recibe el nombre de programa. Un programa se escribe en un lenguaje de programación y a la actividad de expresar un algoritmo en forma de programa se le denomina programación. Cada paso en el algoritmo está expresado por medio de una instrucción en el programa. Por consiguiente, un programa consta de una secuencia de instrucciones, cada una de las cuales, especifica las operaciones que debe realizar la computadora.

Un algoritmo es una fórmula para la resolución de un problema.



1.2 ALGORITMOS

1.2.1 Noción de Algoritmo

“Conjunto ordenado y finito de operaciones que permite hallar la solución de un problema.”

Un algoritmo es un método para resolver un problema

mediante una serie de pasos precisos, definidos y finitos.

Los algoritmos son la base de la programación de ordenadores, ya que los programas de ordenador se puede entender que son algoritmos escritos en un código especial entendible por un ordenador.

Los algoritmos son independientes tanto del lenguaje de

programación en que se expresan como de la computadora que los ejecuta.

En la ciencia de la computación y en la programación, los

algoritmos son más importantes que los lenguajes de programación o las computadoras. Un lenguaje de programación es tan sólo un medio para expresar un algoritmo y una computadora es sólo un procesador para ejecutarlo.

Dada la importancia del algoritmo en la ciencia de la computación, un aspecto muy importante será el diseño de algoritmos.

1.2.2 Características de los Algoritmos

- Figura 1.2: Características de un algoritmo -



1.2.3 Partes de la definición de un Algoritmo

Entrada: Los datos iniciales que posee el algoritmo antes de ejecutarse.

Proceso: Acciones (operaciones) que lleva a cabo el algoritmo.

Salida: Datos (información) que obtiene finalmente el algoritmo.

Ejemplo 1: Para sumar dos números

Entrada : Los números n1 y n2 Proceso : La suma de los números n1 y n2 Salida : El resultado de la suma

Ejemplo 2: Para hallar el área de un cuadrado

Entrada : El lado del cuadrado Proceso : Calcular el área del cuadrado Salida : El resultado del área (area)

Ejemplo 3: Para hallar el promedio de tres notas

Entrada : Las tres notas Proceso : Calcular el promedio Salida : El promedio

1.3 APLICACIONES

1.3.1 Programas y Aplicaciones

Programa: Conjunto unitario de instrucciones que permite a un ordenador realizar funciones diversas, como el tratamiento de textos, el diseño de gráficos, la resolución de problemas matemáticos, el manejo de bancos de datos, etc. Pero normalmente se entiende por programa un “conjunto de instrucciones ejecutables por un ordenador”.

Aplicación: Software formado por uno o más programas, la documentación de los mismos y los archivos necesarios para su funcionamiento, de modo que el conjunto completo de archivos forman una herramienta de trabajo en un ordenador.



Normalmente en el lenguaje cotidiano no se distingue entre aplicación y programa; en nuestro caso entenderemos que la aplicación es un software completo que cumple la función completa para la que fue diseñado, mientras que un programa es el resultado de ejecutar un cierto código entendible por el ordenador.

1.3.2 El ciclo de vida de una aplicación

Una de las cosas que se han definido tras el nacimiento de la ingeniería del software ha sido el ciclo de vida de una aplicación. El ciclo de vida define los pasos que sigue el proceso de creación de una aplicación desde que se propone hasta que finaliza su construcción. Los pasos son: Análisis. En esta fase se determinan los requisitos que tiene

que cumplir la aplicación. Se anota todo aquello que afecta al futuro funcionamiento de la aplicación. Este paso le realiza un analista.

Diseño. Se especifican los esquemas de diseño de la aplicación. Estos esquemas forman los planos del programador, los realiza el analista y representan todos los aspectos que requiere la creación de la aplicación.

Codificación. En esta fase se pasa el diseño a código escrito

en algún lenguaje de programación. Esta es la primera labor que realiza el programador.

Pruebas. Se trata de comprobar que el funcionamiento de la

aplicación es la adecuada. Se realiza en varias fases:

a. Prueba del código. Las realizan programadores. Normalmente programadores distintos a los que crearon el código, de ese modo la prueba es más independiente y generará resultados más óptimos.

b. Versión alfa. Es una primera versión terminada que se revisa a fin de encontrar errores. Estas pruebas convienen que sean hechas por personal no informático.

c. Versión beta. Versión casi definitiva del software en la que no se estiman fallos, pero que se distribuye a los clientes para que encuentren posibles problemas. A veces está versión acaba siendo la definitiva (como ocurre con muchos de los programas distribuidos libremente por Internet).



Mantenimiento. Tiene lugar una vez que la aplicación ha

sido ya distribuida, en esta fase se asegura que el sistema siga funcionando aunque cambien los requisitos o el sistema para el que fue diseñado el software. Antes esos cambios se hacen los arreglos pertinentes, por lo que habrá que retroceder a fases anteriores del ciclo de vida.

- Figura 1.3: Ciclo de vida de una aplicación -

1.4 LENGUAJES DE PROGRAMACIÓN

Es un conjunto de símbolos, caracteres y reglas (programas) que permiten a las personas comunicarse con la computadora. Los lenguajes de programación tienen un conjunto de instrucciones que nos permiten realizar operaciones de entrada/salida, calculo, manipulación de textos, lógica/comparación y almacenamiento/recuperación.

1.4.1 Tipos de Lenguajes

Según el estilo de programación se puede hacer esta división:

Lenguajes imperativos. Son lenguajes donde las instrucciones se ejecutan secuencialmente y van modificando la memoria del ordenador para producir las salidas requeridas. La mayoría de lenguajes (C, Pascal, Basic, Cobol, ...) son de este tipo. Dentro de estos lenguajes están también los lenguajes orientados a objetos (C++, Java, C#,...).

Lenguajes declarativos. Son lenguajes que se concentran más en el qué, que en el cómo (cómo resolver el problema es la pregunta a realizarse cuando se usan lenguajes imperativos). Los lenguajes que se programan usando la pregunta ¿qué queremos? son los declarativos.



El más conocido de ellos es el lenguaje de consulta de Bases de datos, SQL.

Lenguajes funcionales. Definen funciones, expresiones que nos responden a través de una serie de argumentos. Son lenguajes que usan expresiones matemáticas, absolutamente diferentes del lenguaje usado por las máquinas. El más conocido de ellos es el LISP.

Lenguajes lógicos. Lenguajes utilizados para resolver

expresiones lógicas. Utilizan la lógica para producir resultados. El más conocido es el PROLOG.

1.4.2 Traductores de Lenguajes

Los traductores de lenguaje son programas que traducen a su vez los programas fuente escritos en lenguajes de alto nivel a código máquina. Los traductores se dividen en: Intérpretes Compiladores

1.4.2.1 Intérpretes

En el caso de los intérpretes se convierte cada línea a código máquina y se ejecuta ese código máquina antes de convertir la siguiente línea. De esa forma si las dos primeras líneas son correctas y la tercera tiene un fallo de sintaxis, veríamos el resultado de las dos primeras líneas y al llegar a la tercera se nos notificaría el fallo y finalizaría la ejecución.

El intérprete hace una simulación de modo que parece que la máquina entiende directamente las instrucciones del lenguaje, pareciendo que ejecuta cada instrucción (como si fuese código máquina directo).

El BASIC era un lenguaje interpretado, se traducía línea a línea. Hoy en día la mayoría de los lenguajes integrados en páginas web son interpretados, la razón es que como la descarga de Internet es lenta, es mejor que las instrucciones se vayan traduciendo según van llegando en lugar de cargar todas en el ordenador.



Por eso lenguajes como JavaScript (o incluso, en parte, Java) son interpretados.

Proceso

Un programa que se convierte a código máquina mediante un intérprete sigue estos pasos:

1) Lee la primera instrucción 2) Comprueba si es correcta 3) Convierte esa instrucción al código máquina equivalente 4) Lee la siguiente instrucción 5) Vuelve al paso 2 hasta terminar con todas las instrucciones

Ventajas

o Se tarda menos en crear el primer código máquina. El programa se ejecuta antes.

o No hace falta cargar todas las líneas para empezar a ver resultados (lo que hace que sea una técnica idónea para programas que se cargan desde Internet).

Desventajas

o El código máquina producido es peor ya que no se optimiza al valorar una sola línea cada vez. El código optimizado permite estudiar varias líneas a la vez para producir el mejor código máquina posible, por ello no es posible mediante el uso de intérpretes.

o Todos los errores son errores en tiempo de ejecución, no se pueden detectar antes de lanzar el programa. Esto hace que la depuración de los errores sea más compleja.

o El código máquina resultante gasta más espacio. o Hay errores difícilmente detectables, ya que para que los

errores se produzcan, las líneas de errores hay que ejecutarlas. Si la línea es condicional hasta que no probemos todas las posibilidades del programa, no sabremos todos los errores de sintaxis cometidos.

1.4.2.2 Compiladores

Se trata de software que traduce las instrucciones de un lenguaje de programación de alto nivel a código máquina. La diferencia con los intérpretes reside en que se analizan todas las líneas antes de empezar la traducción.



Durante muchos años, los lenguajes potentes han sido compilados. El uso masivo de Internet ha propiciado que esta técnica a veces no sea adecuada y haya lenguajes modernos interpretados o semi-interpretados, mitad se compila hacia un código intermedio y luego se interpreta línea a línea (esta técnica la siguen Java y los lenguajes de la plataforma .NET de Microsoft).

Ventajas

o Se detectan errores antes de ejecutar el programa (errores de compilación).

o El código máquina generado es más rápido (ya que se optimiza). o Es más fácil hacer procesos de depuración de código.

Desventajas

o El proceso de compilación del código es lento. o No es útil para ejecutar programas desde Internet ya que hay

que descargar todo el programa antes de traducirle, lo que ralentiza mucho su uso.

Para conseguir el programa máquina real se debe utilizar un programa llamado montador o enlazador (linker). El proceso de montaje conduce a un programa en lenguaje máquina directamente ejecutable.

11..55 PROGRAMACIÓN

La programación consiste en pasar algoritmos a algún lenguaje de ordenador a fin de que pueda ser entendido por el ordenador. La programación de ordenadores comienza en los años 50 y su evolución a pasado por diversos pasos. La programación se puede realizar empleando diversas técnicas o métodos. Esas técnicas definen los distintos tipos de programaciones.

La compilación es el proceso de traducir programas fuente escritos en lenguajes de alto nivel a lenguaje maquina.



1.5.1 Programación Desordenada

Se llama así a la programación que se realizaba en los albores de la informática (aunque desgraciadamente en la actualidad muchos programadores siguen empleándola). En este estilo de programación, predomina el instinto del programador por encima del uso de cualquier método lo que provoca que la corrección y entendimiento de este tipo de programas sea casi ininteligible.

1.5.2 Programación Estructurada

En esta programación se utiliza una técnica que genera programas que sólo permiten utilizar tres estructuras de control:

Secuencias (instrucciones que se generan secuencialmente) Alternativas (sentencias if) Iterativas (bucles condicionales)

La ventaja de esta programación está en que es más legible (aunque en este caso el código es casi más sencillo en su versión desordenada). Todo programador debería escribir código de forma estructurada.

1.5.3 Programación Modular

Completa la programación anterior permitiendo la definición de módulos independientes cada uno de los cuales se encargará de una tarea del programa. De esta forma el programador se concentra en la codificación de cada módulo haciendo más sencilla esta tarea. Al final se deben integrar los módulos para dar lugar a la aplicación final. El código de los módulos puede ser invocado en cualquier parte del código. Realmente cada módulo se comporta como un subprograma que, a partir de unas determinadas entradas obtienen unas salidas concretas. Su funcionamiento no depende del resto del programa por lo que es más fácil encontrar los errores y realizar el mantenimiento.

1.5.4 Programación Orientada a Objetos

Es la más novedosa, se basa en intentar que el código de los programas se parezca lo más posible a la forma de pensar de las personas. Las aplicaciones se representan en esta programación como una serie de objetos independientes que se comunican entre sí.



Cada objeto posee datos y métodos propios, por lo que los programadores se concentran en programar independientemente cada objeto y luego generar el código que inicia la comunicación entre ellos. Es la programación que ha revolucionado las técnicas últimas de programación ya que han resultado un importante éxito gracias a la facilidad que poseen de encontrar fallos, de reutilizar el código y de documentar fácilmente el código.

1.6 DATOS Y TIPOS DE DATOS

Se denomina datos a las características propias de cualquier entidad. Por ejemplo, la edad y el domicilio de una persona forman parte de sus datos. Los programas procesan datos a fin de obtener resultados o informaciones útiles. El manejo de los datos o información es el primer objetivo de toda computadora. La mayoría de las computadoras pueden trabajar con varios tipos de datos, los algoritmos y los programas correspondientes operan sobre datos. Los tipos de datos pueden ser simples y estructurados. Ver Figura 4.

- Figura 1.4: Tipos de Datos -



Los tipos de datos en C++

Los tipos de datos en C++ se dividen en dos grandes grupos: integrales (datos enteros) y de coma flotante (datos reales).

Los tipos derivados en C++ pueden ser:

- enumeraciones (enum) - estructuras (struct) - uniones (union) - arrays - clases (class y struct) - uniones y enumeraciones anónimas - punteros

1.6.1 Datos Numéricos

El tipo numérico es el conjunto de los valores numéricos. Pueden representarse de dos formas: Tipo numérico entero (integer) Tipo numérico real (real)

1.6.1.1 Enteros

El tipo entero es un subconjunto finito de los números enteros. Los enteros son números completos, no tienen componentes fraccionarios o decimales y pueden ser negativos o positivos. Ejm:

-206 10 -1000 -150 30 2000

char short unsigned short float

signed char int unsigned double

unsigned char long unsigned long long double

En C++ se pueden almacenar números enteros declarando las variables como int, long, unsigned int y unsigned long.



1.6.1.2 Reales

El tipo real consiste en un subconjunto de los números reales. Los números reales siempre tienen un punto decimal y pueden ser positivos ó negativos. Un número real consta de un entero y una parte decimal. Ejm:

-8.12 -0.00098 0.08 0.09520000

1.6.2 Datos Lógicos (booleanos)

El tipo lógico o booleano es aquel dato que sólo puede tomar uno de dos valores: Cierto o verdadero ( True ) 1 Falso ( False ) 0

1.6.3 Datos tipo carácter y tipo cadena

El tipo carácter es el conjunto finito y ordenado de caracteres que la computadora reconoce. Un dato tipo carácter contiene un solo carácter. Los caracteres que reconocen las diferentes computadoras no son estándar; sin embargo, la mayoría reconoce los siguientes caracteres alfabéticos y numéricos: Caracteres alfabéticos (a,b,c, ... , z, A, B, C, ... , Z) Caracteres numéricos (0,1, 2, 3, ..., 9)

Caracteres especiales ( +, -, *, /, , ., ;, <, >, $, . . . ).

Una cadena (string) de caracteres es una sucesión de caracteres que se encuentran delimitados por una comilla (apóstrofo) o dobles comillas, según el tipo de lenguaje de programación. La longitud de una cadena de caracteres es el número de ellos comprendidos entre los separadores o limitadores. Algunos lenguajes tienen datos tipo cadena.

En C++ se pueden almacenar números reales declarando las variables como float y double.



Ejm: ‘ Hola Mundo ’ ‘ 17 de diciembre de 1979 ’ ‘ [email protected]’ “Lenguajes de Programación”

1.7 CONSTANTES Y VARIABLES

1.7.1 Constantes

Son objetos cuyo valor permanece invariable a lo largo de la ejecución de un programa. Una constante es la denominación de un valor concreto, de tal forma que se utiliza su nombre cada vez que se necesita referenciarlo. Ejemplos: Constantes reales.

PI = 3.141592 E = 2.718281

Constante tipo carácter o constante de caracteres.

‘B’ ‘+’ ‘4’ ‘;’ Constante tipo cadena.

“Crisber Sahid Benique Almanza” “Haydee Humpiri Cucho”

Constantes lógicas.

Verdad Falso

La mayoría de los lenguajes de programación permiten diferentes tipos de constantes: enteras, reales, caracteres y boolean o lógicas, y representan datos de esos tipos.

En C++ se pueden almacenar caracteres o cadenas de caracteres declarando variables con char.



Definición de Constantes

En C++ las constantes se crean antes de la función main utilizando la siguiente sintaxis: Ejm: #define PI 3.1416 #define VERDAD 1 #define TRES 3

1.7.2 Variables :

Son objetos cuyo valor puede ser modificado a lo largo de la ejecución de un programa. Dependiendo del lenguaje, hay diferentes tipos de variables, tales como enteras, reales, carácter, lógicas y de cadena. Una variable que es de un cierto tipo puede tomar únicamente valores de ese tipo. Una variable tipo carácter, por ejemplo, puede tomar como valor sólo caracteres, al igual que una variable entera puede tomar sólo valores enteros. Los nombres de las variables, a veces conocidos como identificadores, suelen constar de varios caracteres alfanuméricos, de los cuales el primero normalmente es una letra. No se deben utilizar como nombres de identificadores palabras reservadas del lenguaje de programación.

Definición de Variables en C++

Antes de utilizar una variable en C++ dentro de un programa primero se debe de definir (declarar). La sintaxis básica para declarar una variable es:

Tipo Variable;

#define Nombre Valor



Para declarar varias variables del mismo tipo, la sintaxis es: Ejm: char sexo; int n1, n2, n3; double prom;

1.8 EXPRESIONES

Una expresión es la representación de un cálculo necesario para la obtención de un resultado. Se define una expresión de la siguiente forma: - Un valor es una expresión.

Ejemplos : 1.25, “EDDIE”

- Una constante o variable es una expresión. Ejemplos : PI, E, X.

- Una función es una expresión. Ejemplos : COS(X), SQR(25)

- Una combinación de valores, constantes, variables, funciones, paréntesis y operadores que cumplen determinadas reglas de construcción es una expresión. Ejemplos : COS ( PI * X ) + 1.25 2 * PI * X

N = “EDDIE”

Las expresiones, según el resultado que producen, se clasifican en:

1.8.1 Expresiones Numéricas

Son las que producen resultados de tipo numérico. Se construyen mediante los operadores aritméticos.

Ejemplo : PI * SQR ( 25 ) E + PI

Tipo Variable1, Variable2, Variable3, …;



1.8.2 Expresiones Alfanuméricas

Son las que producen resultados de tipo alfanumérico. Se construyen mediante los operadores alfanuméricos. Ejemplo : “DON” + N

1.8.3 Expresiones Booleanas

Son las que producen resultados CIERTO o FALSO. Se construyen mediante los operadores relacionales y lógicos. Ejemplo : A > 0 y B < = 5

1.9 OPERADORES

Para la construcción de expresiones se pueden utilizar, de forma general, los siguientes operadores:

1.9.1 Aritméticos

Los operadores se utilizan de igual forma que en matemáticas. Por consiguiente:

A . B se escribe en un algoritmo como A * B

6 x 4 se escribe como 6 * 4 35 se escribe como 3^5 Todos los operadores aritméticos no existen en todos los lenguajes de programación. El operador exponenciación es diferente según el tipo de lenguaje de programación.

- Tabla 1.1: Operadores Aritméticos -

Operador Significado Tipos de

operandos Tipo de

resultado ,,** + - * / div mod

Exponenciación Suma Resta Multiplicación División División entera Módulo (resto)

Entero ó real Entero ó real Entero ó real Entero ó real Real Entero Entero

Entero ó real Entero ó real Entero ó real Entero ó real Real Entero Entero



Operadores DIV y MOD

Para la división real se utiliza / y div para la división entera. El operador mod representa el resto de la división entera, aunque hay lenguajes que utilizan otros símbolos como %. Ejm: a) 7 / 2 = 3.5 b) 7 div 2 = 3 c) 7 mod 2 = 1 d) 19 / 6 = 3.17 e) 19 div 6 = 3 f) 19 mod 6 = 1

- Tabla 1.2: Operadores Aritméticos en C++ -

Operadores Aritméticos de Asignación

El operador de asignación (=) hace que el valor situado a la derecha del operador se adjudica a la variable situada a su izquierda.

- Tabla 1.3: Operadores Aritméticos de Asignación en C++ -

Operador Nombre

+ - + - * / % ++ --

Más unitario Negación Suma Resta Multiplicación División Módulo Incremento Decremento

Operador Formato largo Formato reducido

+= -= *= /= %=

a = a + b; a = a – b; a = a * b; a = a / b; a = a % b;

a += b a -= b a *= b a /= b a %= b

7 2

3 1 cociente

resto

19 6

3 1 cociente

resto



Ejm: Si a=10 y b = 4 a) a += b

a = a + b

a = 10 + 4

a = 14

b) a %= b

a = a % b

a = 10 % 4

a = 2

1.9.2 Alfanuméricos

Aquí tenemos el operador de concatenación (+) Ejm: “JUAN” + “A” = “JUANA” “LOS” + “ “ + ”PROGRAMAS” = “LOS PROGRAMAS” “EL” + “CIELO” + “AZÚL” = “ELCIELOAZÚL”

1.9.3 Relacionales

Los operadores relacionales o de relación sirven para expresar las condiciones en los algoritmos. Se pueden aplicar a cualquiera de los cuatro tipos de datos estándar (enteros, real, lógico y carácter).

- Tabla 1.4: Operadores Relacionales -

Ejm: 6 > 5 es verdad 10 <> 5 + 2 es verdad 4 = 2 es falso

Operador Significado

< > =

<= >= <>

Menor que Mayor que Igual que Menor o igual que Mayor o igual que Distinto de



- Tabla 1.5: Operadores Relacionales en C++ -

Ejm: 6 >= 5 es verdad 10 != 10 es falso 4 == 2 es falso

Operador ?:

El operador ?: se conoce como expresión condicional. La expresión condicional es una abreviatura de la sentencia condicional if-else.

La expresión condicional comprueba la condición. Si esa condición es verdadera, se asigna expresión1 a variable; en caso contrario se asigna expresión2 a variable. Ejm: Si a=10 y b = 4, el mayor es: a) mayor = (a>b) ? a : b;

mayor = (10>4) ? 10 : 4;

si (10>4) entonces mayor = 10 sino mayor = 4

como 10>4 entonces mayor = 10

b) Z = (2>6) ? a : b;

Z = (2>6) ? 10 : 4;

si (2>6) entonces Z = 10 sino Z = 4

como 2>6 es falso entonces Z = 4

Operador Nombre

< <= >

>= == != ?:

Menor que Menor o igual que Mayor que Mayor o igual que Igual a No igual a Asignación condicional

variable = (condición) ? expresión1 : expresión2;



1.9.4 Lógicos

Los operadores lógicos o booleanos básicos son:

- Tabla 1.6: Operadores Lógicos -

Tabla de verdad de los operadores lógicos

a b no a a y b a o b

V V F F

V F V F

F F V V

V F F F

V V V F

- Tabla 1.7: Tabla de verdad de los operadores lógicos -

Ejm: a) no ( 6 > 10 )

no ( F )

V b) ( 6 > 10 ) y ( 4 < 30 )

F y V

F

c) ( 10 > 6 ) o ( 5 > 8 )

V o F

V d) no (( 10 > 6 ) o ( 5 > 8 ))

no ( V o F )

no ( V )

F

Operador Significado Operador en C++

not (no) and (y) or (o)

Negación Conjunción Disyunción

! && ||



1.9.5 Paréntesis

Se utilizan para anidar expresiones y se evalúan desde los más internos. Ejm: a ) ( 6 * ( 5 + 4 ) – ( 6 + 3 ) ) + 2

( 6 * 9 – 9 ) + 2

( 5 4 – 9 ) + 2

4 5 + 2

4 7 b) ( 4 – ( 1 0 + ( 6 0 % 4 ) ) )

( 4 – ( 1 0 + 0 ) )

( 4 – 1 0 )

– 6

1.9.6 Orden de prioridad de los operadores

Los operadores de una expresión se evalúan, en general, según el siguiente orden:

1° Paréntesis (comenzando por los más internos) 2° Signo 3° Potencias 4° Productos, divisiones, división entera y resto de la división 5° Sumas y restas 6° Concatenación 7° Relacionales 8° Negación 9° Conjunción 10° Disyunción

La evaluación de operadores de igual orden se realiza siempre de izquierda a derecha. Ejm: a ) ( ( 3 + 2 ) ^ 2 – 1 5 ) / 2 * 5

( 5 ^ 2 – 1 5 ) / 2 * 5

( 2 5 – 1 5 ) / 2 * 5

1 0 / 2 * 5

5 * 5

2 5



b) 5 – 2 > 4 y no 0.5 = 1/2

5 – 2 > 4 y no 0.5 = 0.5

3 > 4 y no 0.5 = 0.5

F y no 0.5 = 0.5

F y no V

F y F

F

1.10 FUNCIONES INTERNAS

Las operaciones que se requieren en los programas exigen muchas veces de un determinado número de operaciones especiales que se denominan funciones internas.

- Tabla 1.8: Algunas Funciones Internas -

Ejm: a ) cuadrado(6) = sqr(6) = 36 b ) sqr(-10) = 100 c) raiz2(81) = sqrt(81) = 9 d) trunc(9.8) = 9 e) trunc(-6.9) = -6 f) redondeo(9.8) = 10 g) redondeo(-6.9) = -7 h) abs(-3.3) = 3.3 i) abs(-8) = 8 j) sen(30) = 0.5

Función Descripción Tipo de

argumento Resultado

abs(x) arctan(x) sen(x) – [sin(x)] cos(x) ln(x) log10(x) cuadrado(x) – [sqr(x)]

raiz2(x) –[sqrt(x)] redondeo(x) trunc(x)

Valor absoluto de x Arco tangente de x Seno de x Coseno de x Logaritmo neperiano de x Logaritmo decimal de x Cuadrado de x

Raíz cuadrada de x Redondeo de x Truncamiento de x

Entero o real Entero o real Entero o real Entero o real Entero o real Entero o real Entero o real

Entero o real Real Real

Igual que argumento Real Real Real Real Real

Igual que argumento

Real Entero Entero



1.11 LA OPERACIÓN DE ASIGNACIÓN

Se representa con el símbolo u operador ←. Se conoce como

instrucción o sentencia de asignación cuando hablamos de lenguajes de programación

La forma de asignar valores a una variable es:

La computadora ejecuta la sentencia de asignación en dos pasos. 1° Se calcula el valor de la expresión 2° El valor hallado se asigna a la variable Ejm: a) ¿Cuál es el valor de la variable suma?

var_a ← 5 Asignamos 5 a la variable a

var_b ← 10 Asignamos 10 a la variable b

suma ← var_a + var_b Sumamos las variables a, b y lo asignamos a la variable suma

La variable suma toma el valor 15. b) ¿Cuál es el valor de la variable x después de las siguientes

operaciones?

x ← 2 x almacena el valor 2

x ← cuadrado (x+x) x ← cuadrado (2+2) x ← cuadrado (4) x toma el valor del cuadrado de 4; 16

x ← raiz2(x+raiz2(x)+5) x ← raiz2(16+raiz2(16)+5) x ← raiz2(16+ 4 +5) x ← raiz2(25) x es la raíz cuadrada de 25; x es 5

Con esta operación podemos asignarle valores a una determinada variable.

variable ← expresión



Preguntas de Repaso

1. Un algoritmo es:

a) Un conjunto ordenado y finito de operaciones que permite hallar la solución de un problema.

b) Un programa que resuelve diagramas de flujo. c) Son pasos no estructurados que ejecuta una máquina.

2. No corresponde a una característica de los Algoritmos a) Los algoritmos deben de ser infinitos. b) Los algoritmos deben de ser precisos. c) Los algoritmos deben de poder repetirse.

3. Elementos que conforman un algoritmo a) Entrada, Proceso, Salida. b) Salida, Datos procesados, Proceso. c) Datos, Salida, Proceso.

4. Fases en la creación de Algoritmos en orden a) Análisis, Diseño, Prueba. b) Prueba, Diseño, Análisis. c) Diseño, Análisis, Prueba.

5. “Software formado por uno o más programas”

a) Aplicación. b) Programa. c) Algoritmo.

6. Corresponde a los pasos del ciclo de vida de una aplicación a) Análisis, Codificación, Mantenimiento b) Programación, Diseño del algoritmo, Ejecución. c) Análisis, Datos Procesados, Diseño del algoritmo.

7. Según el estilo de programación, los tipos de lenguajes son: a) Imperativos, Declarativos, Funcionales, Lógicos b) Funcionales, Lógicos, Declarativos, Orientado a objetos. c) Estructurados, Declarativos, Orientado a objetos, Lógicos.

8. Se convierte cada línea a código máquina y se ejecuta ese código máquina antes de convertir la siguiente línea.

a) Intérpretes. b) Programas. c) Compiladores.



9. La programación consiste en:

a) Pasar algoritmos a algún lenguaje de ordenador a fin de que pueda ser entendido por el ordenador.

b) Elegir un buen lenguaje de programación. c) Resolver problemas computacionales usando módulos.

10. Es la más novedosa, se basa en intentar que el código de los programas se parezca lo más posible a la forma de pensar de las personas. a) Programación Orientada a Objetos. b) Programación Estructurada c) Programación Desordenada

11. Coloque V o F según corresponda :

a) Los tipos de datos pueden ser simples y estructurados ( ) b) Los datos numéricos son enteros y reales ( ) c) Los datos booleanos almacenan 1s y 0s ( ) d) @ es un carácter alfabético ( ) e) Una constante permanece invariable al ejecutarse ( ) f) No es necesario declarar una variable en C++ ( ) g) Una función no puede ser una expresión ( ) h) El operador de concatenación se representa por + ( ) i) Los operadores div y mod son operadores especiales ( ) j) Con operadores relacionales expresamos condiciones ( )



Ejercicios Propuestos I.1. Hallar el valor de las siguientes:

13 / 3 = 13 div 3 = 13 mod 3 = 15 div 4 = 15 mod 4 = I.2. Si p = 16, q = 4 y r = 6, hallar:

p += 14 q /= q r %= 2 q *= p I.3. Encontrar el valor de la variable Z

Z ← 60 mod 7

Z ← (Z + 3)^2

Z ← (6>5) o (3=5) Z ← no Z

Z ← (5 != 5) ? 6 : 4

I.4. Si X =1, Y = 4, Z = 10, hallar:

X > 3 y Y = 4 o X + Y <= Z 2 * Y ^ 2 – 6 * Y + 12 (trunc(6.3) + Y + sqr (Y*Z)) – (– Z ) redondeo (3.6) + X * Z

I.5. Evaluar la expresión: 4 / 2 * 3 / 6 + 6 / 2 - 5 ^ 2 / 5 * 2



MMEETTOODDOOLLOOGGÍÍAA

PPAARRAA LLAA

RREESSOOLLUUCCIIÓÓNN DDEE

PPRROOBBLLEEMMAASS CCOONN

CCOOMMPPUUTTAADDOORRAASS



CCAAPPIITTUULLOO 22:: Metodología para la resolución de problemas con computadoras

La resolución de un problema con la computadora se hace escribiendo un programa, que exige al menos los siguientes pasos:

- Figura 2.1: Pasos para la resolución de problemas con la computadora -

2.1 ANÁLISIS DEL PROBLEMA

El propósito del análisis de un problema es: “ayudar al programador para llegar a una cierta comprensión de la naturaleza del problema”. Requisitos para llegar a una solución eficaz

Buena definición del problema. Descripción detallada de las especificaciones de E/S.

El análisis del problema exige:

Una lectura previa del problema a fin de obtener una idea general de lo que se solicita. La segunda lectura debe servir para responder a las siguientes preguntas:

¿Qué entradas se requieren? ¿Cuál es la salida deseada? ¿Qué método (operación) produce la salida deseada?

- Figura 2.2: Análisis del Problema -

RESOLUCIÓN DE UN

PROBLEMA

ANÁLISIS

DEL PROBLEMA

DISEÑO DEL

ALGORITMO

RESOLUCIÓN DEL

PROBLEMA CON

COMPUTADORA

ANÁLISIS DEL

PROBLEMA

DEFINICIÓN DEL

PROBLEMA

ESPECIFICACIONES

DE ENTRADA Y

SALIDA

OPERACIONES

NECESARIAS



Leer el radio de un círculo y calcular e imprimir su superficie y la longitud de la circunferencia.

Análisis:

Entrada : Radio del círculo (radio) Salida : Superficie del círculo (area) Longitud de circunferencia (circunferencia) Proceso : Cálculo de superficie Cálculo de longitud de circunferencia

- Figura 2.3: Ejemplo 2.a -

Leer la longitud del lado de un cuadrado y calcular e imprimir el área y el perímetro.

Análisis:

Entrada : Longitud del lado del cuadrado (lado) Salida : Área del cuadrado (area) Perímetro del cuadrado (perimetro) Proceso : Cálculo del área del cuadrado Cálculo del perímetro

- Figura 2.4: Ejemplo 2.b -

Proceso Entrada Salida

radio area, circunferencia

Cálculo de superficie y circunferencia


lado area, perimetro

Cálculo del area y del perimetro

Ejemplo 2.a

Ejemplo 2.b



Leer la longitud de la base y la altura de un triángulo rectángulo y calcular e imprimir el área.

Análisis:

Entrada : Longitud de la base del triángulo rectángulo (base) Longitud de la altura del triángulo rectángulo (altura) Salida : Área del triángulo rectángulo Proceso : Cálculo del área del triángulo rectángulo

- Figura 2.5: Ejemplo 2.c -

Calcular el promedio de tres notas

Análisis: Entrada : _____________________________________________ _____________________________________________ _____________________________________________ Salida : _____________________________________________ Proceso : _____________________________________________

Determinar la hipotenusa de un triángulo rectángulo.

Análisis: Entrada : _____________________________________________ _____________________________________________ Salida : _____________________________________________ Proceso : _____________________________________________

Leer un número y calcular la raíz cuadrada

Análisis: Entrada : _____________________________________________ Salida : _____________________________________________ Proceso : _____________________________________________


base, altura area

Cálculo del area

Ejercicio

Ejercicio

Ejercicio

Ejemplo 2.c



2.2 DISEÑO DEL ALGORITMO

En la etapa de diseño se determina ¿Cómo hace el programa la tarea solicitada?. Los métodos más eficaces para el proceso de diseño se basan en el conocido por divide y vencerás (diseño descendente top-down). Es decir, la resolución de un problema complejo se realiza dividiendo el problema en subproblemas y a continuación dividir estos subproblemas en otros de nivel más bajo, hasta que pueda ser implementada una solución en la computadora. Así, el problema del ejemplo 2.a se puede dividir en tres problemas más simples o subproblemas.

- Figura 2.6: Refinamiento de un algoritmo -

El proceso de romper el problema en cada etapa y expresar cada paso en forma más detallada se denomina refinamiento sucesivo. Para problemas complejos se necesitan con frecuencia diferentes niveles de refinamiento antes de que se pueda obtener un algoritmo claro, preciso y completo.

Superficie y longitud

de circunferencia

Entrada de datos

Cálculo de area

Cálculo de circunferencia

Salida resultados

radio area=PI*radio^2

circunfe

rencia

=2*PI*

radio

area circunferencia



Subproblemas Refinamiento

Entrada de datos Leer radio

Calculo de área y circunferencia

area = 3.141592*radio^2 circunferencia = 2*3.141592*radio

Salida de resultados Escribir area, circunferencia

- Tabla 2.1: Refinamiento del ejemplo 2.a -

Luego de los pasos anteriores (diseño descendente y refinamiento por pasos) es preciso representar el algoritmo mediante una determinada herramienta de programación.

2.2.1 Representación de los algoritmos

Los métodos usuales para representar un algoritmo son:

- Pseudocódigo. - Diagramas de Flujo. - Diagramas N-S (Nassi - Schneiderman).

2.2.1.1 Pseudocódigo

Es un lenguaje de especificación (descripción) de algoritmos. El pseudocódigo o pseudolenguaje, son una serie de instrucciones en nuestro lenguaje natural (español, ingles, etc.) y expresiones que representan cada uno de los pasos que resuelven un problema especifico (algoritmo). Es la representación narrativa de los pasos que debe seguir un algoritmo para dar solución a un problema determinado. El pseudocódigo utiliza palabras que indican el proceso a realizar, por todo lo anterior es una técnica NO GRÁFICA. Se considera un primer borrador, dado que el pseudocódigo tiene que traducirse posteriormente a un lenguaje de programación. Cabe señalar que el pseudocódigo no puede ser ejecutado por una computadora. Así, de los ejercicios 2.a, 2.b y 2.c sus pseudocódigos serían:



Leer el radio de un círculo y calcular e imprimir su superficie y la longitud de la circunferencia. (Ejercicio 2.a)

Diseño:

inicio leer radio

area 3.141592 * radio ^ 2

circunferencia 2 * 3.141592 * radio escribir area, circunferencia fin

Leer la longitud del lado de un cuadrado y calcular e imprimir el área y el perímetro. (Ejercicio 2.b)

Diseño:

inicio leer lado

area lado * lado

perimetro lado + lado + lado + lado escribir area, perimetro fin

Leer la longitud de la base y la altura de un triángulo rectángulo y calcular e imprimir el área. (Ejercicio 2.c)

Diseño:

inicio leer base, altura

area base * altura / 2 escribir area fin

Ejemplo 2.d

Ejemplo 2.e

Ejemplo 2.f



Calcular el promedio de tres notas

Diseño:

inicio __________________________ __________________________ __________________________ fin

Determinar la hipotenusa de un triángulo rectángulo.

Diseño:

inicio __________________________ __________________________ __________________________ fin

Leer un número y calcular la raíz cuadrada

Diseño:

inicio __________________________ __________________________ __________________________ fin

2.2.1.2 Diagramas de Flujo

Un diagrama de flujo es la representación gráfica de un algoritmo. También se puede decir que es la representación detallada en forma gráfica de como deben realizarse los pasos en la computadora para producir resultados. Esta representación gráfica se da cuando varios símbolos (que indican diferentes procesos en la computadora), se relacionan entre si mediante líneas que indican el orden en que se deben ejecutar los procesos.

Ejercicio

Ejercicio

Ejercicio



Los símbolos utilizados han sido normalizados por el instituto norteamericano de normalización (ANSI).

SÍMBOLO NOMBRE DESCRIPCIÓN

Terminal

Indica el comienzo “inicio” o final “fin” de nuestro algoritmo. Representa también una parada o interrupción programada que sea necesario realizar.

Proceso

Dentro de el se coloca una expresión para que se ejecute.

Entrada/Salida

Permite la introducción de datos desde los periféricos, “entrada”, o registro de información procesada en un periférico, “salida”.

Entrada manual

Indica que se recibe un dato desde el teclado y dentro de este se coloca la variable en donde se almacenará.

Pantalla

Dentro de el se coloca el mensaje y/o datos que queremos aparezcan en el monitor.

Llamada a función o módulo

(subprograma)

Indica que se debe de ejecutar la función o módulo que esta escrita dentro de él.

Conector en la misma página

Se utiliza para continuar la secuencia del algoritmo en otra parte de la hoja. El conector debe de estar en ambos lados y con el mismo número.

Conector con otra página

Se utiliza para continuar la secuencia del algoritmo en otra página. El conector debe de estar en ambos lados y con el mismo número.



Decisión

Se utiliza para plantear una pregunta y con la respuesta se optará por avanzar por solo uno de los caminos posibles.

Pantalla

Se utiliza en ocasiones en lugar del símbolo de E/S.

Comentarios

Se utiliza para añadir comentarios a otros símbolos del diagrama de flujo.

Indicador de dirección o línea

de flujo.

Se usan para indicar el flujo o camino a seguir para la ejecución de operaciones.

- Tabla 2.2: Símbolos DFD -

2.2.1.3 Diagramas De Flujo con DFD

2.2.1.3.1 DFD

DFD es un programa de libre disposición para ayuda al diseño e implementación de algoritmos expresados en diagramas de flujo (DF). Además incorpora opciones para el depurado de los algoritmos, lo que facilita enormemente la localización de los errores de ejecución y lógicos más habituales. Su utilización es muy sencilla, al tratarse de una herramienta gráfica, y además incluye un menú de ayuda muy completo.

– Figura 2.7: Pantalla de inicio –



2.2.1.3.2 Barra de Herramientas

La barra de herramientas consta de los bloques de Botones de objetos, Subprogramas, Ejecución, Depuración y Zoom.

- Figura 2.8: Barra de Herramientas -

Los botones de objetos de izquierda a derecha son: Cursor, Asignación, Ciclo mientras, Ciclo para, Decisión, Lectura, Salida, Llamada.

- Figura 2.9: Botones de objetos -

2.2.1.3.3 Símbolos DFD más usados

Botón Descripción

Asignación - Proceso

Ciclo mientras

Ciclo para

Decisión – Condición

Lectura - Entrada

Salida

- Tabla 2.3: Símbolos DFD más usados -

Así, del ejercicio 2.a, 2.b y 2.c los diagramas de flujo son:



Leer el radio de un círculo y calcular e imprimir su superficie y la longitud de la circunferencia. (Ejercicio 2.a)

Diseño:

Leer la longitud del lado de un cuadrado y calcular e imprimir el área y el perímetro. (Ejercicio 2.b)

Diseño:

Ejemplo 2.h

leer radio

escribir area,circunferencia

inicio

fin

area 3.141592 * radio ^ 2

circunferencia 2 * 3.141592 * radio

Ejemplo 2.g

leer lado

escribir area, perimetro

inicio

fin

area lado * lado

perimetro lado + lado + lado + lado



Leer la longitud de la base y la altura de un triángulo rectángulo y calcular e imprimir el área. (Ejercicio 2.c)

Diseño:

2.2.1.4 Diagrama N-S (Nassi - Schneiderman).

El diagrama N-S de Nassi-Schneiderman (diagrama de Chapin) es como un diagrama de flujo en el que se omiten las flechas de unión y las cajas son contiguas, se pueden escribir diferentes acciones en una caja.

nombre del algoritmo

acción1

acción2

acción3

…

fin

Ejm: Diagrama N-S del ejercicio 2.i

leer base, altura

calcular area ← base * altura / 2


Ejemplo 2.i

leer base, altura


inicio

fin

area base * altura / 2



2.3 RESOLUCIÓN DEL PROBLEMA CON LA COMPUTADORA Una vez que el algoritmo está diseñado y representado gráficamente mediante una herramienta de programación (diagrama de flujo, pseudocódigo o diagrama N-S) se debe pasar a la fase de resolución practica del problema con la computadora. Esta fase se descompone a su vez en las siguientes subfases:

- Figura 2.10: Resolución del Problema mediante la computadora -

El programa que implementa el algoritmo debe ser escrito en un lenguaje de programación y siguiendo las reglas gramaticales o sintaxis del mismo. La fase de conversión del algoritmo en un lenguaje de programación se denomina codificación, ya que el algoritmo escrito en un lenguaje específico de programación se denomina código. Tras la codificación del programa, deberá ejecutarse en una computadora y a continuación de comprobar los resultados pasar a la fase final de documentación

2.3.1 Codificación del Programa

La codificación es la operación de escribir la solución del problema (de acuerdo a la lógica del diagrama de flujo o pseudocódigo), en una serie de instrucciones detalladas, en un código reconocible por la computadora, la serie de instrucciones detalladas se le conoce como código fuente, el cual se escribe en un lenguaje de programación o lenguaje de alto nivel.

RESOLUCIÓN DEL

PROBLEMA CON

COMPUTADORA

CODIFICACIÓN DEL

PROGRAMA

EJECUCIÓN DEL

PROGRAMA

COMPROBACIÓN

DEL PROGRAMA



2.3.2 Ejecución del Programa

El código o programa fuente debe ser traducido a lenguaje máquina, este proceso se realiza con el compilador y el sistema operativo que se encarga prácticamente de la compilación. Si tras la compilación se presentan errores en el programa fuente, es preciso volver a editar el programa, corregir los errores y compilarlo de nuevo. Este proceso se repite hasta que no existan errores y se obtiene el programa objeto que todavía no es ejecutable directamente. Se debe instruir al sistema operativo para que realice la fase de montaje o enlace (link), carga, del programa objeto con las librerías del programa del compilador. El proceso de montaje produce un programa ejecutable. Una vez creado el programa ejecutable, se puede ya ejecutar desde el sistema operativo.

2.3.3 Comprobación del Programa

Aquí encontramos las fases de verificación y depuración. La verificación de un programa es el proceso de ejecución del programa con una amplia variedad de datos de entrada, que determinarán si el programa tiene errores. La depuración es el proceso de encontrar los errores del programa y corregir o eliminar dichos errores. Al ejecutar un programa se pueden producir tres tipos de errores: Errores de compilación, de ejecución y lógicos.

2.3.4 Documentación y Mantenimiento

La documentación es la guía o comunicación escrita es sus variadas formas, ya sea en enunciados, procedimientos, dibujos o diagramas. A menudo un programa escrito por una persona, es usado por otra. Por ello la documentación sirve para ayudar a comprender o usar un programa o para facilitar futuras modificaciones (mantenimiento).



La documentación se divide en tres partes:

- Documentación Interna - Documentación Externa - Manual del Usuario

El mantenimiento se lleva acabo después de terminado el programa, cuando se detecta que es necesario hacer algún cambio, ajuste o complementación al programa para que siga trabajando de manera correcta. Para poder realizar este trabajo se requiere que el programa este correctamente documentado.

Preguntas de Repaso

1. Se trata de entender cuáles serán los datos de entrada y salida: a) Análisis del problema. b) Diseño del algoritmo. c) Codificación.

2. El diseño del algoritmo es : a) Independiente del lenguaje de programación. b) Un proceso complicado. c) La parte inicial de todo problema.

3. Son herramientas para diseñar algoritmos.

a) Diagramas de Flujo, Pseudocódigos. b) Pseudocódigos, Pseudos-lenguajes. c) Diagramas N-S, DFDs

4. Es la operación de escribir la solución del problema en una serie de

instrucciones detalladas, en un código reconocible por la computadora.

a) Codificación. b) Pseudo-codificación. c) Mantenimiento.

5. Es la guía o comunicación escrita es sus variadas formas, ya sea en

enunciados, procedimientos, dibujos o diagramas. a) Documentación. b) Depuración. c) Programación.



Ejercicios Propuestos II.1. Realizar el análisis de los siguientes:

Hallar la suma, resta, producto y división de dos números Algoritmo que lee una temperatura en la escala centígrada y nos

calcula y escribe su valor en las escalas Reamur, Fahrenheit y Kelvin.

Dada una cantidad en kilómetros convertirlo a metros. El dueño de una tienda compró un artículo a un precio

determinado. Obtener el precio en que lo vendió, si perdió el 15%.

II.2. Realizar el pseudocódigo de los siguientes:

Hallar la suma, resta, producto y división de dos números Dada una cantidad en kilómetros convertirlo a metros. Algoritmo que lee una temperatura en la escala centígrada y nos

calcula y escribe su valor en las escalas Reamur, Fahrenheit y Kelvin.



EESSTTRRUUCCTTUURRAASS

SSEECCUUEENNCCIIAALLEESS



CCAAPPIITTUULLOO 33:: Estructuras Secuenciales

- Figura 3.1: Estructuras Secuenciales -

Las tareas se suceden de tal modo que la salida de una es la entrada de la siguiente y así sucesivamente hasta el final del proceso.

inicio acción1 acción2 acción3 fin - Pseudocódigo -

- Diagrama de Flujo –

acción1

acción2

acción1

fin

inicio



1. Calcular la suma y el producto de dos números enteros.

Si los números enteros son 10 y 9

V.E.

Números (a,b)

V.S.

Suma (s) Producto (p)

Prueba de Escritorio:

Programa:

A b s p Pantalla

10 9 19 90 19,90

#include<iostream.h>

void main()

{

int a,b,s,p;

cout<<"ingrese a: ";cin>>a;

cout<<"ingrese b: ";cin>>b;

s=a+b;

p=a*b;

cout<<"Suma es : "<<s<<endl;

cout<<"Producto es: "<<p;

}

leer a,b

escribir s,p

inicio

fin

s a + b

p a * b

Diagrama de flujo:



2. Leer un número e imprimir su cuadrado.

Por ejemplo, el cuadrado del número 8:

648*882

V.E.

Número (n)

V.S.

Cuadrado (c)

Pseudocódigo:

inicio

leer n

c n * n

escribir c

fin


Programa:

n c Pantalla

8 64 64


void main()

{

float n,c;

cout<<"Ingrese el número: ";cin>>n;

c = n*n;

cout<<"El cuadrado es: "<<c;

}

leer n

escribir c

inicio

fin

c n * n

Diagrama de flujo:



3. Calcular la edad de una persona.

Si una persona nació el año 1987 y el año actual es 2008, ¿Cuántos años tendrá?

V.E.

Año de nacimiento (an) Año actual (aa)

V.S.

Edad (e)

Pseudocodigo:

inicio

leer an,aa

e aa - an

escribir e

Fin


Programa:

an aa e Pantalla

1987 2008 21 21


void main()

{

int an,aa,e;

cout<<"Año de nacimiento: ";cin>>an;

cout<<"Año actual : ";cin>>aa;

e=aa-an;

cout<<"Edad : "<<e;

}

leer an,aa

escribir e

inicio

fin

e aa-an

Diagrama de flujo:



4. Se desea leer la longitud del lado de un cuadrado y calcular e imprimir el área y el perímetro.

Área = L2

Perímetro = L+L+L+L

Si el lado del cuadrado es 10, ¿Cuánto es el área y el perímetro del cuadrado?

V.E.

Lado (L)

V.S.

Área (A) Perímetro (P)


Programa:

L A P Pantalla

10 100 40 100,40


void main()

{

float L,A,P;

cout<<"Ingrese lado: ";cin>>L;

A = L*L;

P = L+L+L+L;

cout<<"El área es : "<<A;

cout<<"El perímetro es: "<<P;

}

L

L

L

L

leer L

escribir A,P

inicio

fin

A L * L

P L+L+L+L

Diagrama de flujo:



5. Se desea leer la longitud de la base y la altura de un triángulo y calcular e imprimir el área.

2

hbÁrea

Si la base es 12, la altura es 5, ¿Cuánto es el área?

V.E.

Base (b) Altura (h) V.S.

Área (A)


Programa:

b h A Pantalla

12 5 30 30


void main()

{

float b,h,A;

cout<<"Ingrese base : ";cin>>b;

cout<<"Ingrese altura: ";cin>>h;

A=(b*h)/2;

cout<<"El área es: "<<A;

}

b

h

leer b,h

escribir A

inicio

fin

A (b*h)/2

Diagrama de flujo:



6. Determinar la hipotenusa de un triángulo rectángulo.

222 cacoh

Si cateto opuesto es 4, cateto adyacente 3, ¿Cuánto es la hipotenusa?

V.E.

Catetos ( co, ca )

V.S.

Hipotenusa ( h )


Programa:

Se incluye la librería math.h para que trabaje la función raíz cuadrada (sqrt).

Co ca h Pantalla

4 3 5 5

ca

co h


#include<math.h>

void main()

{

float co,ca,h;

cout<<"Ingrese cateto opuesto : ";cin>>co;

cout<<"Ingrese cateto adyacente: ";cin>>ca;

h=sqrt(co*co+ca*ca);

cout<<"Hipotenusa es: "<<h;

}

leer co,ca

escribir h

inicio

fin

h sqrt(co*co+ca*ca)

Diagrama de flujo:



7. Realice la siguiente conversión: De una temperatura dada en grados Celsius a grados Fahrenheit.

325

9 CF

Si Celsius es 45, ¿A cuántos grados Fahrenheit equivale?

V.E.

Celsius ( C )

V.S.

Fahrenheit ( F )


Programa:

C F Pantalla

45 113 113


void main()

{

float C,F;

cout<<"Ingrese grados Celsius:";cin>>C;

F = (9*C)/5+32;

cout<<"Grados Fahrenheit: "<<F;

}

leer C

escribir F

inicio

fin

F (9*C)/5+32

Diagrama de flujo:



8. La presión, el volumen y la temperatura de una masa de aire se relacionan por la formula:

Masa = ( presión * volumen )/( 0.37 * ( temperatura + 460 ))

¿Cuánto es la masa? En la fórmula se desconoce la presión, volumen y temperatura (variables de entrada), estos datos deben ser ingresados por el usuario.

V.E.

Presión (p) Volumen (v) Temperatura (t)

V.S.

Masa (m)


Programa:

p v t m Pantalla

10 5 18 0.282709 0.282709


void main()

{

float p,v,t,m;

cout<<"Ingrese presión : ";cin>>p;

cout<<"Ingrese volumen : ";cin>>v;

cout<<"Ingrese temperatura: ";cin>>t;

m = (p*v)/(0.37*(t+460));

cout<<"Masa : "<<m;

}

leer p,v,t

escribir m

inicio

fin

m (p*v)/(0.37*(t+460))

Diagrama de flujo:



9. Calcular el número de pulsaciones que una persona debe tener por cada 10 segundos de ejercicio, si la fórmula es:

Num. de pulsaciones = ( 220 – edad ) / 10

V.E.

Edad (e)

V.S.

N° de pulsaciones (np)


Programa:

e np Pantalla

28 19.2 19.2


void main()

{

int e,np;

cout<<"ingrese edad: ";cin>>e;

np=(220-e)/10;

cout<<"Número de Pulsaciones es: "<<np;

}

leer e

escribir np

inicio

fin

np (220-e)/10

Diagrama de flujo:



10. Leer un número y escribir el valor absoluto del mismo.

El valor absoluto de -3, es:

33

El valor absoluto de 10, es:

1010

V.E.

Número (n)

V.S.

Valor absoluto (va)


Programa:

Se incluye la librería math.h para que trabaje la función valor absoluto (abs).

n va Pantalla

-3 3 3


#include<math.h>

void main()

{

int n,va;

cout<<"Ingrese Número: ";cin>>n;

va = abs(n);

cout<<"Su valor absoluto es: "<<va;

}

leer n

escribir va

inicio

fin

va abs(n)

Diagrama de flujo:



11. Dada una cantidad en soles obtener la equivalencia en dólares, asumiendo que el tipo de cambio es un dato desconocido.

Si usted tiene 21 soles y el tipo de cambio es 3, ¿Cuántos dólares tiene?

V.E.

Soles (s) Tipo de cambio (tc) V.S.

Dólares (d)


Programa:

s tc d Pantalla

21 3 7 7


void main()

{

float s,tc,d;

cout<<"Ingrese Soles : ";cin>>s;

cout<<"Tipo de cambio: ";cin>>tc;

d = s / tc;

cout<<"Dólares: "<<d;

}

leer s,tc

escribir d

inicio

fin

d s / tc

Diagrama de flujo:



12. Calcular el nuevo salario de un obrero si obtuvo un incremento de del 25% sobre su salario anterior.

Si el Salario anterior es 1000 soles, ¿Cuánto es el Nuevo salario? Nuevo salario = ( 25%* 1000 ) + 1000

= ( 0.25 *1000 ) + 1000 = 250 + 1000 = 1250

V.E.

Salario anterior (sa)

V.S.

Nuevo salario (ns)

Pseudocodigo:

inicio

leer sa

ns sa * 0.25 + sa

escribir ns

fin


Programa:

sa ns Pantalla

1000 1250 1250


void main()

{

float sa,ns;

cout<<"Salario anterior: ";cin>>sa;

ns = sa * 0.25 + sa;

cout<<"Nuevo salario: "<<ns;

}

leer sa

escribir ns

inicio

fin

ns sa * 0.25 + sa

Diagrama de flujo:



13. Suponga que un individuo desea invertir su capital en un banco y desea saber cuánto dinero ganará después de un mes si el banco paga a razón del 2% mensual.

Si el Capital es 2000 soles, ¿Cuánto es el dinero que ganará después de un mes? Ganancia = 0.02 * 2000 = 40

V.E.

Capital (C)

V.S.

Ganancia (G)


Programa:

C G Pantalla

2000 40 40


void main()

{

float C,G;

cout<<"Ingrese capital: ";cin>>C;

G = C * 0.02;

cout<<"Ganacia es: "<<G;

}

leer C

escribir G

inicio

fin

G C * 0.02

Diagrama de flujo:



14. Una tienda ofrece un descuento del 15% sobre el total de la compra, un cliente desea saber cuanto deberá pagar finalmente por su compra.

Si el Total de la compra es 500 soles, ¿Cuánto pagará finalmente el cliente? Descuento = 0.15 * 500 = 75 Total a pagar = 500 – 75 = 425

V.E.

Total de compra (tc)

V.S.

Total a pagar (tp)

O.V.

Descuento (d)

Programa:


void main()

{

float tc,tp,d;

cout<<"Total de Compra: ";cin>>tc;

d = 0.15 * tc;

tp = tc - d;

cout<<"Total a Pagar: "<<tp;

}

leer tc

escribir tp

inicio

fin

d 0.15 * tc

tp tc -d

Diagrama de flujo:



15. Se desea obtener el salario bruto, total de impuestos y salario neto de un trabajador conociendo el número de horas trabajadas, el salario hora, y la tasa de impuestos que se le debe deducir.

Si el Número de horas trabajadas es 80, el Salario hora 8 soles y la tasa de impuestos 10%. Salario bruto = 80 * 8 = 640 Total de impuestos = 640 * 0.10 = 64 Salario neto = 640 – 64 = 576

V.E.

Horas trabajadas (HT) Salario hora (SH) Tasa de impuestos (T)

V.S.

Salario bruto (SB) Total de impuestos (TI) Salario neto (SN)

Programa:


void main()

{

float HT,SH,T,TI,SB,SN;

cout<<"Ingrese horas trabajadas : ";cin>>HT;

cout<<"Ingrese salario hora : ";cin>>SH;

cout<<"Ingrese tasa de impuestos: ";cin>>T;

SB=HT*SH;

TI=SB*T;

SN=SB-TI;

cout<<"Salario bruto es : "<<SB<<endl;

cout<<"Total de impuestos: "<<TI<<endl;

cout<<"Salario neto es : "<<SN;

}

leer HT,SH,T

escribir SB,TI,SN

inicio

fin

SB HT * SH

TI SB * T

SN SB - TI

Diagrama de flujo:



16. Un vendedor recibe un sueldo base mas un 10% extra por comisión de sus ventas, el vendedor desea saber cuanto dinero obtendrá por concepto de comisiones por las tres ventas que realiza en el mes y el total que recibirá en el mes tomando en cuenta su sueldo base y comisiones.

Si el Sueldo base es 600 soles, los montos de las tres ventas son: 140, 80 y 250. Total de Ventas = 140 + 80 + 230 = 450 Comisión = 0.10 * 450 = 45 Total = 450 + 45 = 495

V.E. Sueldo base (sb) Ventas (v1,v2,v3)

V.S.

Comisión de ventas (c) Total a recibir (t)

O.V.

Total ventas (tv)

Programa:


void main()

{ float sb,v1,v2,v3,tv,c,t;

cout<<"Sueldo base: ";cin>>sb;

cout<<"Venta 1: ";cin>>v1;



tv = v1+v2+v3;

c = 0.10*tv;

t = sb+c;

cout<<"Comisión es: "<<c<<endl;

cout<<"Total : "<<t;

}

leer sb,v1,v2,v3

escribir c,t

inicio

fin

tv v1+v2+v3

c 0.10 * tv

t sb + c

Diagrama de flujo:



17. Un maestro desea saber que porcentaje de varones y que porcentaje de mujeres hay en un grupo de alumnos.

Si el total de alumnos es 38, el número de mujeres es 20. Varones = 38 – 20 = 18

Porcentaje de mujeres:

Cantidad Porcentaje 38 100 20 %m

%63.5238

100*20% m

Porcentaje de varones:

Cantidad Porcentaje 38 100 18 %v

%37.4738

100*18% v

V.E. Total de alumnos (ta) Número de mujeres (nm)

V.S.

Porcentaje de varones (pv) Porcentaje de mujeres (pm)

O.V.

Número de varones (nv)

Programa:


void main()

{ float ta,nm,nv,pm,pv;

cout<<"Total de alumnos : ";cin>>ta;

cout<<"Número de mujeres: ";cin>>nm;

nv = ta-nm;

pm = (nm*100)/ta;

pv = (nv*100)/ta;

cout<<"% de Varones: "<<pv<<endl;

cout<<"% de Mujeres: "<<pm;

}

leer ta,nm

escribir pv,pm

inicio

fin

nv ta - nm

pm ( nm*100 )/ta

pv ( nv*100 )/ta

Diagrama de flujo:



18. El dueño de una tienda compra un artículo a un precio determinado. Obtener el precio en que lo debe vender, para obtener una ganancia del 30%.

Si el Precio de compra es 120 soles.

Precio venta = 120 * 0.30 + 120 = 36 + 120 = 156

V.E. Precio de compra (pc)

V.S.

Precio de venta (pv)

Pseudocodigo:

inicio

leer pc

pv pc * 0.30 + pc

escribir pv

fin

Programa:


void main()

{

float pc,pv;

cout<<"Ingrese precio de compra: ";cin>>pc;

pv = pc * 0.30 + pc;

cout<<"Precio de venta: "<<pv;

}

leer pc

escribir pv

inicio

fin

pv pc * 0.30 + pc

Diagrama de flujo:



19. En un hospital existen tres áreas: Ginecología, Pediatría, Traumatología. El presupuesto anual del hospital se reparte conforme a la siguiente tabla:

Área Porcentaje del presupuesto

Ginecología 45% Traumatología 25% Pediatría 30%

Obtener la cantidad de dinero que recibirá cada área, para cualquier monto presupuestal.

V.E.

Presupuesto anual (pa)

V.S.

Monto para Ginecología (G) Monto para Traumatología (T) Monto para Pediatría (P)

Programa:


void main()

{

float pa,G,T,P;

cout<<"Ingrese Presupuesto Anual: ";cin>>pa;

G = 0.45 * pa;

T = 0.25 * pa;

P = 0.30 * pa;

cout<<"Ginecología : "<<G<<endl;

cout<<"Traumatología: "<<T<<endl;

cout<<"Pediatría : "<<P;

}

leer pa

escribir G,T,P

inicio

fin

G 0.45 * pa

T 0.25 * pa

P 0.30 * pa

Diagrama de flujo:



20. Tres personas deciden invertir su dinero para fundar una empresa. Cada una de ellas invierte una cantidad distinta. Obtener el porcentaje que cada quien invierte con respecto a la cantidad total invertida.

Sean x,y,z las personas e invierten 200, 500 y 300 respectivamente. Total invertido = 200 + 500 + 300 = 1000

Porcentaje de x: Dinero invertido Porcentaje 1000 100 200 %x

%201000

100*200% x

Para las personas y,z cambia el dinero invertido, las formulas serían:

%501000

100*500% y %30

1000

100*300% z

V.E.

Dinero de x (dx) Dinero de y (dy) Dinero de z (dz)

V.S.

Porcentaje de x (px) Porcentaje de y (py) Porcentaje de z (pz)

O.V.

Total invertido (T) Programa:


void main()

{ float dx,dy,dz,px,py,pz,T;

cout<<"Dinero de X: ";cin>>dx;

cout<<"Dinero de Y: ";cin>>dy;

cout<<"Dinero de Z: ";cin>>dz;

T = dx + dy + dz;

px = dx * 100/T;

py = dy * 100/T;

pz = dz * 100/T;

cout<<"% de X: "<<px<<endl;

cout<<"% de Y: "<<py<endl;

cout<<"% de Z: "<<pz;

}

inicio

fin

T dx + dy + dz

px dx * 100 / T

py dy * 100 / T

pz dz * 100 / T

Diagrama de flujo:

px,py,pz

dx,dy,dz



21. Hallar el área de un triángulo en función de las longitudes de sus lados:

))()(( cpbpappArea

Donde p = (a+b+c)/2 (semiperímetro)

V.E. Lados (a,b,c)

V.S.

Area (A)

O.V.

Semiperímetro (p)

Pseudocodigo:

inicio

leer a,b,c

p (a+b+c)/2

A sqrt(p*(p-a)*(p-b)*(p-c))

escribir A

fin

Programa:

a

c

b

leer a,b,c

escribir A

inicio

fin

p (a+b+c)/2

Diagrama de flujo:

A sqrt(p*(p-a)*(p-b)*(p-c))


#include<math.h>

void main( )

{

double a,b,c,p,A;

cout<<"Ingrese a: ";cin>>a;

cout<<"Ingrese b: ";cin>>b;

cout<<"Ingrese c: ";cin>>c;

p = (a+b+c)/2;

A = sqrt(p*(p-a)*(p-b)*(p-c));

cout<<"El area es : "<<A<<endl;

}



Ejercicios Propuestos

Realizar el análisis, diseño (pseudocódigo, diagrama de flujo) y programa de los siguientes:

3.1. Calcular la suma, resta, producto y división de dos números, e imprimir el resultado.

3.2. Leer un número e imprimir el cubo.

3.3. Calcular el área de un cuadrado, de acuerdo a la siguiente formula:

2

2dA

3.4. Calcular el área de un rombo, de acuerdo a la siguiente formula:

2

* BDACArea

Donde: AC es diagonal menor BD es diagonal mayor

3.5. Dada una cantidad en kilómetros convertirlo a metros. 3.6. Un almacén ofrece descuentos del 25% sobre el monto total de la compra,

un cliente desea saber cuánto es el descuento y cuánto es lo que debe pagar finalmente.

3.7. Cuánto es el salario mensual de una persona que trabaja 8 horas diarias, y

por hora recibe 7 soles, tomando en cuenta que al mes solo trabaja algunos días.

3.8. Un vendedor recibe un sueldo base de 450 soles más un 20% extra por

comisión de sus ventas, el vendedor desea saber cuanto dinero obtendrá por concepto de comisiones por las cuatro ventas que realiza en el mes y el total que recibirá en el mes tomando en cuenta su sueldo base y comisiones.

d

B

C A

D



3.9. El dueño de una tienda compró un artículo a un precio determinado. Obtener el precio en que lo vendió, si perdió el 15%.

3.10. Lilian, Cristian y Joel deben repartirse un dinero que dejó su padre. El

monto se reparte de acuerdo a la siguiente tabla:

Hijos Porcentaje

Lilian 25%

Cristian 35%

Joel 40%

¿Cuánto dinero recibe cada hijo?




SSEELLEECCTTIIVVAASS



- Pseudocódigo -

CCAAPPIITTUULLOO 44:: Estructuras Selectivas

- Figura 4.1: Estructuras Selectivas -

En las estructuras selectivas se evalúa una condición y en función del resultado de la misma se realiza una opción u otra. Las condiciones se especifican usando expresiones lógicas.

4.1 ESTRUCTURAS SELECTIVAS SIMPLES

En esta estructura se ejecuta una determinada acción o acciones cuando se cumple una determinada condición.

si condición entonces

AcciónV …

fin_si

AcciónV

condición

verdadera

falsa

- Diagrama de Flujo -



- Sintaxis en C++ -

if(condición)

{

AcciónV;

}

La condición, puede estar compuesta por variables, expresiones o funciones; sin embargo el valor que representa solo podrá tomar uno de dos valores Verdadero (si) ó Falso (no). AcciónV, puede estar conformados por una ó varias sentencias. Si estuviera conformada por una sentencia no es necesario utilizar llaves ({ }) pero si estuviera conformada por varias sentencias obligatoriamente deberán utilizar llaves. Esta AcciónV se ejecuta cuando la condición es verdadera. Ejm: Si la edad de una persona es mayor o igual a 18 se imprimirá “Mayor de edad”. if( edad >= 18 )

{

cout<<”Mayor de edad”;

}

Puede escribirse también de la siguiente manera. if( edad >= 18 )cout<<”Mayor de edad”;

La condición en este ejemplo es: edad >= 18 La AcciónV es: cout<<”Mayor de edad”;



SIMPLES

1. Leer un número y determinar si es “Positivo”.

Un número es positivo si es mayor a cero.

V.E.

Número (N)

SALIDA

“Positivo”

Pseudocodigo:

inicio

leer N

si N>0 entonces

escribir “Positivo”

fin_si

fin

Programa:


void main()

{

int N;

cout<<"Ingrese número: ";cin>>N;

if(N>0)

{

cout<<"Positivo";

}

}

leer N

inicio

fin

N >0

“Positivo”

Si No

Diagrama de flujo:



2. Determinar si un número entero es “Neutro”.

Un número es neutro si es igual a cero.

V.E.

Número (N)

SALIDA

“Neutro”

Pseudocodigo:

inicio

leer N

si N==0 entonces

escribir “Neutro”

fin_si

fin

Programa:


void main()

{

int N;

cout<<"Ingrese Número: ";cin>>N;

if(N==0)

{

cout<<"Neutro";

}

}

leer N

inicio

fin

N==0

“Neutro”

Si No

Diagrama de flujo:



3. Determinar si una persona es “Mayor de Edad”.

Una persona es mayor de edad a partir de los 18 años para adelante.

V.E.

Edad (E)

SALIDA

“Mayor de Edad”

Pseudocodigo: inicio

leer E

si E>=18 entonces

escribir “Mayor de Edad”

fin_si

fin

Programa:


void main()

{

int E;

cout<<"Ingrese edad: ";cin>>E;

if(E >= 18)

{

cout<<"Mayor de Edad";

}

}

leer E

inicio

fin

E>=18

“Mayor de

Edad”

Si No

Diagrama de flujo:



4. Determinar si dos números A y B son “Iguales”.

V.E.

Números (A,B) SALIDA

“Iguales”

Pseudocodigo:

inicio

leer A,B

si A==B entonces

escribir “Iguales”

fin_si

fin

Programa:


void main()

{

int A,B;

cout<<"Ingrese A: ";cin>>A;

cout<<"Ingrese B: ";cin>>B;

if(A==B)

{

cout<<"Iguales";

}

}

leer A,B

inicio

fin

A==B

“Iguales”

Si No

Diagrama de flujo:



5. Determinar si una persona es “Menor de Edad”.

Una persona es menor de edad hasta los 17 años.

V.E.

Edad (E)

SALIDA

“Menor de Edad”

Pseudocodigo:

inicio

leer E

si E<=17 entonces

escribir “Menor de Edad”

fin_si

fin

Programa:


void main()

{

int E;


if(E <= 17)

{

cout<<"Menor de Edad";

}

}

leer E

inicio

fin

E<=17

“Menor de

Edad”

Si No

Diagrama de flujo:



6. Determinar si dos números A y B son “Diferentes”.

V.E.


“Diferentes”

Pseudocodigo:

inicio

leer A,B

si A!=B entonces

escribir “Diferentes”

fin_si

fin

Programa:


void main()

{

int A,B;



if(A!=B)

{

cout<<"Diferentes";

}

}

leer A,B

inicio

fin

A!=B

“Diferentes”

Si No

Diagrama de flujo:



7. Leer un número y determinar si es “Negativo”.

Un número es negativo cuando es menor que 0.

V.E.

Número (N)

SALIDA

“Negativo”

Pseudocodigo:

inicio

leer N

si N<0 entonces

escribir “Negativo”

fin_si

fin

Programa:


void main()

{

int N;


if(N<0)

{

cout<<"Negativo";

}

}

leer N

inicio

fin

N < 0

“Negativo”

Si No

Diagrama de flujo:



8. Determinar si un Número es “Par”.

Un número como 18 al dividirlo entre 2 da como resto 0:

Si 18 MOD 2 es igual a 0 el número 18 es PAR.

V.E.

Número (N) SALIDA

“Par”


leer N

si N%2==0 entonces

escribir “Par”

fin_si

fin

Programa:


void main()

{

int N;

cout<<"Ingrese N: ";cin>>N;

if( N%2 ==0 )

{

cout<<"Par";

}

}

leer N

inicio

fin

Si No N%2==0

“Par”

Diagrama de flujo:

2

9

18

0 Resto



La fórmula sería: N mod 3 == 0

9. Determinar si un número es múltiplo de tres.

Un número como 18 al dividirlo entre 3 da como resto 0: Un número como 21 al dividirlo entre 3 da como resto 0: Un número como 17 al dividirlo entre 3 da como resto 2:

Si 18 MOD 3 es igual a 0 el número 18 es múltiplo de 3.


V.E.

Número (N) SALIDA

“Múltiplo de tres”

3

6

18

0 Resto

3

7

21

0 Resto

3

5

17

2 Resto




leer N

si N%3==0 entonces

escribir “Múltiplo de tres”

fin_si

fin

Programa:


void main()

{

int N;


if( N%3 ==0 )

{

cout<<"Múltiplo de tres";

}

}

leer N

inicio

fin

Si No N%3==0

“Múltiplo de tres”

Diagrama de flujo:



10. Determinar si un Número es “Impar”.

Un número como 17 al dividirlo entre 2 da como resto 1:

Si 17 MOD 2 es igual a 1 el número 17 es IMPAR.

V.E.

Número (N) SALIDA

“Impar”


leer N

si N%2==1 entonces

escribir “Número Impar”

fin_si

fin

Programa:


void main()

{

int N;


if( N%2 ==1 )

{

cout<<"Número Impar";

}

}

leer N

inicio

fin

Si No N%2==1

“Impar”

Diagrama de flujo:

2

8

17

1 Resto



La fórmula sería: N mod 5 == 0

11. Determinar si un número es múltiplo de cinco.

Un número como 15 al dividirlo entre 5 da como resto 0: Un número como 20 al dividirlo entre 5 da como resto 0: Y un número como 17 al dividirlo entre 5 da como resto 2:



V.E.

Número (N) SALIDA

“Múltiplo de cinco”

5

3

15

0 Resto

5

4

20

0 Resto

5

3

17

2 Resto




leer N

si N%5==0 entonces

escribir “Múltiplo de cinco”

fin_si

fin

Programa:


void main()

{

int N;


if( N%5==0 )

{

cout<<"Múltiplo de cinco";

}

}

leer N

inicio

fin

Si No N%5==0

“Múltiplo de cinco”

Diagrama de flujo:



- Pseudocódigo -

- Sintaxis en C++ -

4.2 ESTRUCTURAS SELECTIVAS DOBLES

Esta estructura permite elegir entre dos opciones o alternativas posibles. Si la condición es verdadera se ejecuta la AcciónV ó AccionesV, si es falsa se ejecuta AcciónF ó AccionesF.

si condición entonces

AcciónV si_no

AcciónF fin_si

if(condición)

{

AcciónV;

}

else

{

AcciónF;

}

La condición, puede estar compuesta por variables, expresiones o funciones; sin embargo el valor que representa solo podrá tomar uno de dos valores (Verdadero o Falso). En C++ el valor 0 significa Falso y un valor diferente de 0 significa Verdadero.

AcciónV, AcciónF pueden estar conformados por una ó por varias sentencias. Si estuviera conformada por una sentencia no es necesario utilizar llaves ({ }) pero si estuviera conformada por varias sentencias obligatoriamente deberán utilizar llaves.

Ejm: Para determinar si una persona es mayor de edad o menor de edad.

AcciónV

Condición

verdadera

falsa

AcciónF


Cuando la condición es verdadera imprime “Mayor de edad”, en caso contrario imprime “Menor de edad”.



if( edad>=18 )

{


}

else

{

cout<<”Menor de edad”;

}

La condición es: edad >= 18 La AcciónV es: cout<<”Mayor de edad”; La AcciónF es: cout<<”Menor de edad”; La AcciónV depende de la condición, como se observa en lo siguiente, la condición varia de >= a <= al igual que de “Mayor de edad” a “Menor de edad”. if( edad<=18 )

{

cout<<” Menor de edad”;

}

else

{


} La condición es: edad <= 18 La AcciónV es: cout<<”Menor de edad”; La AcciónF es: cout<<”Mayor de edad”; Nota: Los dos segmentos de código solucionan el mismo problema.

Cuando la condición es verdadera imprime “Menor de edad”, en caso contrario imprime “Mayor de edad”.



DOBLES

12. Determinar si una persona es “Mayor de edad” o es “Menor de edad”.

V.E.

Edad (E) SALIDA

“Mayor de edad” o “Menor de edad”

Pseudocodigo:

inicio

leer E

si E>=18 entonces

escribir “Mayor de edad”

si_no

escribir “Menor de edad”

fin_si

fin

Programa:


void main()

{

int E;


if(E >= 18)

{

cout<<"Mayor de edad";

}

else

{

cout<<"Menor de edad";

}

}

leer E

inicio

fin

E>=18

“Mayor de

edad”

Si No

“Menor de

edad”

Diagrama de flujo:



13. Determinar si un número es “Neutro” o “No es neutro”.

V.E.

Número (N) SALIDA

“Neutro” o “No es Neutro”

Pseudocodigo:

inicio

leer N

si N==0 entonces

escribir “Neutro”

si_no

escribir “No es Neutro”

fin_si

fin

Programa:


void main()

{

int N;


if(N==0)

{

cout<<"Neutro";

}

else

{

cout<<"No es Neutro";

}

}

Diagrama de flujo:

leer N

inicio

fin

N==0

“Neutro”

Si No

“No es

Neutro”



14. Determinar si un número es “Negativo” o “Positivo”.

V.E.

Número (N)

SALIDA

“Negativo” o “Positivo”

Pseudocodigo:

inicio

leer N

si N<0 entonces

escribir “Negativo”

si_no

escribir “Positivo”

fin_si

fin

Programa:


void main()

{

int N;


if(N<0)

{

cout<<"Negativo";

}

else

{

cout<<"Positivo";

}

}

Diagrama de flujo:

leer N

inicio

fin

N<0

“Negativo”

Si No

“Positivo”



15. Determinar si dos números A y B son “Iguales” o son “Diferentes”.

V.E.

Números (A, B)

SALIDA

“Iguales” o “Diferentes”

Pseudocodigo:

inicio

leer A,B

si A==B entonces

escribir “Iguales”

si_no

escribir “Diferentes”

fin_si

fin

Programa:


void main()

{

int A,B;



if(A==B)

{

cout<<"Iguales";

}

else

{

cout<<"Diferentes";

}

}

Diagrama de flujo:

leer A,B

inicio

fin

A==B

“Iguales”

Si No

“Diferentes”



16. Determinar si un número es “Par” o “Impar”.

V.E.

Número (N) SALIDA

“Par” o “Impar”

Pseudocodigo:

inicio

leer N

si N%2==0 entonces

escribir “Par”

si_no

escribir “Impar”

fin_si

fin

Programa:


void main()

{

int N;

cout<<"Ingrese Número: ";cin>>N;

if(N%2==0)

{

cout<<"Par";

}

else

{

cout<<"Impar";

}

}

Diagrama de flujo:

leer N

inicio

fin

Si No N%2==0

“Par” “Impar”



17. Determinar el mayor de dos números.

V.E.


A o B

Pseudocodigo:

inicio

leer A,B

si A > B entonces

escribir A

si_no

escribir B

fin_si

fin

Programa:


void main()

{

int A,B;



if(A > B)

{

cout<<A;

}

else

{

cout<<B;

}

}

leer A,B

inicio

fin

Si No A > B

A B

Diagrama de flujo:



18. Determinar el menor de dos números.

V.E.


A o B

Pseudocodigo:

inicio

leer A,B

si A < B entonces

escribir A

si_no

escribir B

fin_si

fin

Programa:


void main()

{

int A,B;



if(A < B)

{

cout<<A;

}

else

{

cout<<B;

}

}

leer A,B

inicio

fin

Si No A < B

A B

Diagrama de flujo:



19. Hacer un algoritmo que calcule el total a pagar por la compra de camisas. Si se compran tres camisas o mas se aplica un descuento del 20% sobre el total de la compra y si son menos de tres camisas un descuento del 10%.

V.E.

Número de Camisas (NC) Precio Unitario (PU)

V.S

Total a pagar (TP)

O.V.

Total de Compra (TC) Descuento (D)

Diagrama de flujo:

inicio

leer NC,PU

TC = NC * PU

si NC>=3 entonces

D = 0.20 * TC

si_no

D = 0.10 * TC

fin_si

TP = TC – D

escribir TP

fin

Pseudocódigo:

leer NC,PU

inicio

fin

Si No NC >= 3

TC NC * PU

D 0.20*TC D 0.10*TC

TP TC - D

escribir TP



Programa:


Con 5 camisas y precio unitario 10 soles

Con 2 camisas y precio unitario 10 soles.

Con 8 camisas y precio unitario 25 soles.

NC PU TC D TP Pantalla

5 10 50 10 40 40


2 10 20 2 18 18


8 25 200


void main()

{

float NC,PU,TC,D,TP;

cout<<"Número de camisas: ";cin>>NC;

cout<<"Precio unitario : ";cin>>PU;

TC = NC * PU;

if(NC>=3)

{

D = 0.20 * TC;

}

else

{

D = 0.10 * TC;

}

TP = TC - D;

cout<<"Total a pagar: "<<TP;

}



20. Determinar si un alumno aprueba o reprueba un curso, sabiendo que aprobara si su promedio de tres calificaciones es mayor o igual a 70; reprueba en caso contrario.

V.E.

Calificaciones (C1, C2, C3)

O.V.

Promedio (P)

SALIDA

“Aprueba” o “Reprueba”

Pseudocódigo:

inicio

leer C1,C2,C3

P = (C1+C2+C3)/3

si P >= 70 entonces

escribir “Aprueba”

si_no

escribir “Reprueba”

fin_si

Fin

leer C1,C2,C3

inicio

fin

Si No P >= 70

P (C1+C2+C3)/3

“Aprueba” “Reprueba”

Diagrama de flujo:



Programa:


Con 50, 10 y 90

Con 80, 80 y 90

Con 70, 60 y 50

C1 C2 C3 P Pantalla

50 10 90 50 Reprueba

C1 C2 C3 P Pantalla

80 80 90 83.33 Aprueba

C1 C2 C3 P Pantalla

70 60 50


void main()

{

float C1,C2,C3,P;

cout<<"Calificacion 1: ";cin>>C1;



P = ( C1 + C2 + C3 )/3;

if(P >= 70)

{

cout<<"Aprueba";

}

else

{

cout<<"Reprueba";

}

}



21. Calcular el total que una persona debe pagar en una tienda de llantas, el precio de cada llanta es de 800 si se compran menos de 5 llantas y de 700 si se compran de 5 a más.

V.E.

Número de llantas (N)

V.S

Total a pagar (TP)

Diagrama de flujo:

inicio

leer N

si N < 5 entonces

TP = N * 800

si_no

TP = N * 700

fin_si

escribir TP

fin

Pseudocódigo:

leer N

inicio

fin

Si No N < 5

TPN*800 TPN*700

escribir TP



Programa:


Con 3 llantas.

Con 5 llantas.

Con 8 llantas.

N TP Pantalla

3 3*800=2400 2400

N TP Pantalla

5 5*700=3500 3500

N TP Pantalla

8 8*700=5600 5600


void main()

{

float N,TP;

cout<<"Número de llantas: ";cin>>N;

if(N<5)

{

TP = N * 800;

}

else

{

TP = N * 700;

}


}



- Pseudocódigo -

4.3 ESTRUCTURAS SELECTIVAS MÚLTIPLES A veces en la práctica es necesario que existan más de dos elecciones posibles. La estructura de decisión múltiple evaluará una expresión que podrá tomar n valores distintos, según se elija uno de estos valores se ejecutará una determinada acción ó acciones.

según_sea expresión hacer e1: acción s11 acción s12 . . acción s1n e2: acción s21 acción s22 . . acción s2n . . en: acción sn1 acción sn2 . . acción snn si_no acción X fin _ según

expresión 1

acción s1 acción s2 acción s3 acción s4 acción sn

2 3 4 n




- Sintaxis en C++ -

switch (selector)

{

case alternativa_1: Acción1;break;




.

.

.

case alternativa_N: AcciónN;break;

default:

AcciónX;

}

El selector puede ser una variable, una expresión o una función; sin embargo, el valor que representa debe ser escalar. Es decir: numérico entero, o carácter individual. De ninguna manera puede ser una cadena o un float. Este selector será evaluado en cada alternativa hasta que encuentre su lugar. Cada alternativa está conformada por un único valor. Cada acción, puede estar conformada por una ó varias sentencias. El uso del default es opcional, sin embargo sirve para ejecutar algo cuando el selector no encuentra su lugar; es decir que su valor no se encuentra contenido en ninguna alternativa. Ejm: El siguiente segmento de código imprime los días de la semana de acuerdo a la variable DIA que toma valores de 1 a 7. switch (DIA)

{

case 1: cout<<”Lunes”;break;

case 2: cout<<”Martes”;break;

case 3: cout<<”Miércoles”;break;

case 4: cout<<”Jueves”;break;

case 5: cout<<”Viernes”;break;

case 6: cout<<”Sábado”;break;

case 7: cout<<”Domingo”;break;

default:

cout<<”Día no válido”;

}



Del ejemplo, el selector es: DIA Las alternativas van de 1 a 7 Las acciones son imprimir “Lunes” o “Martes”, ..., o “Domingo”. El default es, imprimir “Día no válido”

En vez de utilizar la estructura selectiva múltiple (switch), se puede utilizar varios ifs. if (DIA == 1)

{

cout<<”Lunes”;

}

if (DIA == 2)

{

cout<<”Martes”;

}

if (DIA == 3)

{

cout<<”Miercoles”;

}

if (DIA == 4)

{

cout<<”Jueves”;

}

if (DIA == 5)

{

cout<<”Viernes”;

}

if (DIA == 6)

{

cout<<”Sabado”;

}

if (DIA == 7)

{

cout<<”Domingo”;

}



V.E.

Mes (MES) SALIDA

“Enero” o “Febrero” o “Marzo” … o “Mes no válido”

MÚLTIPLES

22. Construir un algoritmo que escriba los nombres de los meses del año, en función de la entrada correspondiente a la variable MES. Si el valor de la variable MES no esta en el rango de 1 a 12 imprimir el mensaje “Mes no válido”.

Diagrama de flujo:

leer MES

inicio

MES>=1 AND

MES<=12

“Mes no

válido”

“Enero” “Febrero” “Marzo” … “Diciembre”

fin

1 2

1

12 3

1

1

V

F



Pseudocódigo: inicio

leer MES según_sea MES hacer 1: imprimir “Enero” 2: imprimir “Febrero” 3: imprimir “Marzo” 4: imprimir “Abril” 5: imprimir “Mayo” 6: imprimir “Junio” 7: imprimir “Julio” 8: imprimir “Agosto” 9: imprimir “Setiembre” 10: imprimir “Octubre” 11: imprimir “Noviembre” 12: imprimir “Diciembre”

si_no

imprimir “Mes no válido” fin _ según

fin Programa:


void main( )

{

int MES;

cout<<"Ingrese mes: ";cin>>MES;

switch(MES)

{

case 1:cout<<"Enero";break;

case 2:cout<<"Febrero";break;

case 3:cout<<"Marzo";break;

case 4:cout<<"Abril";break;

case 5:cout<<"Mayo";break;

case 6:cout<<"Junio";break;

case 7:cout<<"Julio";break;

case 8:cout<<"Agosto";break;

case 9:cout<<"Setiembre";break;

case 10:cout<<"Octubre";break;

case 11:cout<<"Noviembre";break;

case 12:cout<<"Diciembre";break;

default:

cout<<"Mes no válido";

}

}



23. Se desea convertir las calificaciones alfabéticas A, B, C, D y E a calificaciones numéricas 4, 5, 6, 7 y 8 respectivamente.

V.E.

Calificación alfabética (Cal)

Mensaje de Salida

4, 5, 6, 7 u 8

Pseudocódigo:

inicio

leer Cal según_sea Cal hacer “A” : imprimir 4 “B” : imprimir 5 “C” : imprimir 6 “D” : imprimir 7 “E” : imprimir 8

fin _ según fin

Diagrama de flujo:

Cal

leer Cal

inicio

fin

A B D C

4 5 6 7 8

E



Programa:


Con A

Con B

Con E

Cal Pantalla

A 4

Cal Pantalla

B 5

Cal Pantalla

E


void main()

{

char Cal;

cout<<"Ingrese calificación: ";cin>>Cal;

switch(Cal)

{

case 'A':cout<<4;break;

case 'B':cout<<5;break;

case 'C':cout<<6;break;

case 'D':cout<<7;break;

case 'E':cout<<8;break;

}

}



24. Algoritmo que lee una calificación alfabética en una variable tipo carácter y nos escribe su valor numérico que será establecido por la tabla de conversión de medidas ponderadas.

Nota alfabética Media Ponderada Numérica Muy deficiente “M” 1.5 Insuficiente “ I ” 4.0 Suficiente “F” 5.5 Bien “B” 6.5 Notable “N” 8.0 Sobresaliente “S” 9.5

V.E.

Nota alfabética (Nota) SALIDA

1.5 ó 4.0 ó 5.5 ó 6.5 ó 8.0 ó 9.5

Diagrama de flujo:

Nota

leer Nota

inicio

fin

M I B F

1.5 4.0 5.5 6.5 8.0

N

9.5

S




leer Nota según_sea Nota hacer “M” : imprimir 1.5 “I” : imprimir 4.0 “F” : imprimir 5.5 “B” : imprimir 6.5 “N” : imprimir 8.0 “S” : imprimir 9.5

fin _ según fin

Programa:


Con S

Nota Pantalla

S 9.5


void main()

{

char Nota;

cout<<"Ingrese calificación: ";cin>>Nota;

switch(Nota)

{

case 'M':cout<<1.5;break;

case 'I':cout<<4.0;break;

case 'F':cout<<5.5;break;

case 'B':cout<<6.5;break;

case 'N':cout<<8.0;break;

case 'S':cout<<9.5;break;

}

}



V.E.

Número de mes (mes) SALIDA

“Verano” o “Otoño” o “Invierno” o “Primavera” o “Estación desconocida”

25. Determinar el nombre correspondiente de una estación de acuerdo al número del mes, considerando 3 meses completos por estación, en caso de ser un número de mes fuera del rango de 1 a 12 imprimir estación desconocida.

Mes Estación

Enero, Febrero y Marzo Abril, Mayo y Junio Julio, Agosto, Setiembre Octubre, Noviembre, Diciembre

Verano Otoño

Invierno Primavera

Diagrama de flujo:

leer mes

inicio

mes>=1

AND

mes<=12

“Estación

desconocida” 1

V

F

fin

“Verano” “Otoño” “Invierno” “Primavera”

1,2,3 4,5,6 7,8,9 10,11,12

1




leer mes según_sea mes hacer 1, 2, 3 : imprimir “Verano” 4, 5, 6 : imprimir “Otoño” 7, 8, 9 : imprimir “Invierno” 10,11,12 : imprimir “Primavera”

si_no imprimir “Estación desconocida” fin _ según

fin Programa:


Con mes 12

Con mes 5

mes Pantalla

12 Primavera

mes Pantalla

5 Otoño


void main()

{

int mes;

cout<<"Ingrese número del mes: ";cin>>mes;

switch(mes)

{

case 1:case 2:case 3:cout<<"Verano";break;

case 4:case 5:case 6:cout<<"Otoño";break;

case 7:case 8:case 9:cout<<"Invierno";break;

case 10:case 11:case 12:cout<<"Primavera";break;

}

}



COMPUESTOS

26. Leer 2 números; si son iguales que los multiplique, si el primero es mayor que el segundo que los reste y si no que los sume. Los dos números son iguales: Si A = 5 y B = 5, la respuesta es 25 (5 * 5) Si A = 12 y B = 12, la respuesta es 144 (12 * 12) El primer número es mayor que el segundo: Si A = 17 y B = 12, la respuesta es 5 (17 - 12) Si A = 25 y B = 5, la respuesta es 20 (25 – 5) El primer número es menor que el segundo: Si A = 1 y B = 10, la respuesta es 11 (1 + 10) Si A = 8 y B = 17, la respuesta es 25 (8 + 17)

V.E.

Números (A, B) SALIDA

Respuesta (R) Diagrama de flujo:

Leer A,B

inicio

fin

Si No A==B

R A * B

escribir R

A > B Si No

R A - B R A + B



Pseudocodigo:

inicio

leer A,B

si A == B entonces

R = A * B

si_no

si A > B entonces

R = A – B

Si_no

R = A + B

fin_si

fin_si

escribir R

fin

Programa:


void main()

{

int A,B,R;

cout<<"A: ";cin>>A;

cout<<"B: ";cin>>B;

if(A == B)

{

R = A * B;

}

else

{

if(A > B)

R = A - B;

else

R = A + B;

}

cout<<"R: "<<R;

}



27. Una frutería ofrece las manzanas con descuento de acuerdo a la tabla:

N° kilos comprados %Descuento

0 – 2 0%

2.01 – 5 10%

5.01 – 10 15%

10.01 en adelante 20%

Determinar cuánto pagará una persona que compre manzanas en esa frutería, si el costo del kilo es 2 soles.

Diagrama de flujo:

Leer NK

Inicio

Fin

Si No NK<=2

D 0

Escribir TP

NK<=5 Si No

D0.10*ST

ST NK * 2

NK<=10

D0.15*ST D0.20*ST

Si No

TP ST - D

V.E.

Número de Kilos (NK)

V.S.

Total a Pagar (TP)

O.V.

Sub Total (ST) Descuento (D)



Programa:


Con mes 12

mes Pantalla

12 Primavera


void main()

{

float NK,TP,ST,D;

cout<<"Número de kilos: ";cin>>NK;

ST = NK * 2.0;

if(NK <= 2)

{

D = 0;

}

else

{

if(NK <= 5)

{

D = 0.10 * ST;

}

else

{

if(NK <= 10)

{

D = 0.15 * ST;

}

else

{

D = 0.20 * ST;

}

}

}


}



28. Determinar el mayor de 3 números enteros distintos.

V.E.

Números (a,b,c)

V.S.

El mayor (may)

Pseudocodigo:

inicio

leer a,b,c

may = a

si may < b entonces

may = b

fin_si

si may < c entonces

may = c

fin_si

escribir may

fin

leer a,b,c

Inicio

Fin

escribir may

may a

No

Si may < b

may b

No

Si may < c

may c

Diagrama de flujo:



Programa:

Con tres números como 17, 12 y 79 podemos hacer las siguientes combinaciones de ingreso de datos para las variables a, b y c; así como las condiciones que nos ayudarán a determinar el mayor, menor y medio de tres números distintos, podemos imprimirlos también en orden ascendente y/o descendente.

EL MAYOR

- Tabla 4.1: Condiciones para el mayor de tres números -

a b c La condición El mayor Significado

17 12 79 c > a AND a > b c

79 es mayor

que 17 y 17

es mayor

que 12

17 79 12 b > a AND a > c b

12 79 17 b > c AND c > a b

12 17 79 c > b AND b > a c

79 17 12 a > b AND b > c a

79 12 17 a > c AND c > b a


void main()

{

int a,b,c,may;

cout<<"Ingrese a: "; cin>>a;

cout<<"Ingrese b: "; cin>>b;

cout<<"Ingrese c: "; cin>>c;

may = a;

if(may < b)

{

may = b;

}

if(may < c)

{

may = c;

}

cout<<"El mayor es: "<<may<<endl;

}



EL MENOR

- Tabla 4.2: Condiciones para el menor de tres números -

EL MEDIO

- Tabla 4.3: Condiciones para el medio de tres números -

ASCENDENTE Y DESCENDENTE

- Tabla 4.4: Condiciones para imprimir en orden ascendente y/o descendente -

a b c La condición El menor Significado

17 12 79 c > a AND a > b b

12 es menor

que 17 y 17

es menor

que 79

17 79 12 b > a AND a > c c

12 79 17 b > c AND c > a a

12 17 79 c > b AND b > a a

79 17 12 a > b AND b > c c

79 12 17 a > c AND c > b b

a b c La condición El medio Significado

17 12 79 c > a AND a > b a

17 es mayor

que 12 y 17

es menor

que 79

17 79 12 b > a AND a > c a

12 79 17 b > c AND c > a c

12 17 79 c > b AND b > a b

79 17 12 a > b AND b > c b

79 12 17 a > c AND c > b c

a b c La condición Ascendente Descendente

17 12 79 c > a AND a > b b,a,c c,a,b

17 79 12 b > a AND a > c c,a,b b,a,c

12 79 17 b > c AND c > a a,c,b b,c,a

12 17 79 c > b AND b > a a,b,c c,b,a

79 17 12 a > b AND b > c c,b,a a,b,c

79 12 17 a > c AND c > b b,c,a a,c,b



29. Determinar el menor de 3 números enteros distintos.

Para hallar el menor de tres números enteros distintos, utilizamos las condiciones de la tabla 4.2.

V.E.

Números (a,b,c)

V.S.

El menor (a o b o c) Diagrama de Flujo:

fin

leer a,b,c

inicio

Si

No c >a &&

a > b

Si

No b >a &&

a > c

Si

No b >c &&

c > a

Si

No c >b &&

b > a

Si

No a >b &&

b > c

b

c

a

a

c

b



Pseudocódigo:

inicio

leer a,b,c

si c > a && a > b entonces

escribir b

si_no

si b > a && a > c entonces

escribir c

si_no

si b > c && c > a entonces

escribir a

si_no

si c > b && b > a entonces

escribir a

si_no

si a > b && b > c entonces

escribir c

si_no

escribir b

fin_si

fin_si

fin_si

fin_si

fin_si

fin



Programa:


void main()

{

int a,b,c;

cout<<"Ingrese a: ";cin>>a;

cout<<"Ingrese b: ";cin>>b;

cout<<"Ingrese c: ";cin>>c;

if(c>a && a>b)

{

cout<<"El menor es "<<b<<endl;

}

else

{

if(b>a && a>c)

{

cout<<"El menor es "<<c<<endl;

}

else

{

if(b>c && c>a)

{

cout<<"El menor es "<<a<<endl;

}

else

{

if(c>b && b>a)

{

cout<<"El menor es "<<a<<endl;

}

else

{

if(a>b && b>c)

{

cout<<"El menor es "<<c<<endl;

}

else

{

cout<<"El menor es "<<b<<endl;

}

}

}

}

}

}



Ejercicios

Realizar el análisis, diseño (Pseudocódigo o diagrama de flujo) y programa de los siguientes:

4.1. Determinar si un número “No es Neutro”. 4.2. Leer una nota y determinar si un alumno “Aprueba” o “Desaprueba” un

curso, si la nota mínima aprobatoria es 14.

4.3. Si un ángulo es igual a 90 grados, imprimir el mensaje “El ángulo es un ángulo recto” sino imprimir el mensaje “El ángulo no es un ángulo recto”.

4.4. Leer dos números e imprimirlos en orden ascendente. 4.5. En un almacén se hace un 20% de descuento a los clientes cuya compra

supere los 1000 soles. ¿Cuál será la cantidad que pagara una persona por su compra?.

4.6. Un obrero necesita calcular su salario semanal, el cual se obtiene de la siguiente manera:

Si trabaja 40 horas o menos se le paga 16 soles por hora Si trabaja más de 40 horas se le paga 16 soles por cada una de las primeras 40 horas y 20 soles por cada hora extra.

4.7. En un supermercado se hace una promoción, mediante la cual el cliente obtiene un descuento dependiendo de un número que se escoge al azar. Si el número escogido es menor que 74 el descuento es del 15% sobre el total de la compra, si es mayor o igual a 74 el descuento es del 20%. Obtener cuánto dinero se le descuenta.

4.8. En una tienda de accesorios para computadoras, el precio de venta de los

diskettes es el mismo para cualquier marca, sin embargo el descuento varía de acuerdo a la marca y se establece en la siguiente tabla. Determinar el importe a pagar por la cantidad de diskettes comprados de una sola marca, considerando que no se paga impuestos. Mostrar importe bruto, descuento e importe a pagar.

Marca Descuento

%

3M NCR

Sentinel Burroughs

Imation

10 15 20 25 30



4.9. Diseñar un algoritmo, programa para resolver una ecuación de segundo

grado.

Ax2 + Bx + C = 0

4.10. Leer tres números diferentes y determine el número medio del conjunto de los tres números (el número medio es aquel número que no es ni mayor, ni menor).

4.11. Leer tres números distintos y ordenarlos en forma descendente. 4.12. En una tienda se efectúa una promoción en la cual se hace un descuento

sobre el valor de la compra total según el color de la bolita que el cliente saque al pagar en caja. Si la bolita es de color blanco no se le hará descuento alguno, si es verde se le hará un 10% de descuento, si es amarilla un 25%, si es azúl un 50% y si es roja un 100%. Determinar la cantidad final que el cliente deberá pagar por su compra. Se sabe que solo hay bolitas de los colores mencionados.

4.13. Utilizando el operador ? determinar el mayor de dos números. 4.14. Escribir un programa que permita seleccionar la operación aritmética a

ejecutarse entre dos números, dependiendo del valor de una variable ope.

Ope Operación

1 2 3 4

Sumar Restar Multiplicar Dividir

4.15. Un ángulo se considera agudo si es menor de 90 grados, obtuso si es

mayor de 90 grados y recto si es igual a 90 grados. Utilizando esta información, escriba un programa que acepte un ángulo en grados y muestre el tipo de ángulo que es.

4.16. Leer tres notas y calcular el promedio. Si la nota1 es aprobatoria aumentar

2 puntos sobre el promedio, si la nota2 está entre 8 y 10 aumentar 1 punto al promedio. Imprimir promedio final.

4.17. Leer tres notas, si la nota1 está entre 8 y 12 aumentar 3 puntos a la nota1, si

la nota2 está entre 15 y 17 aumentarle 2 puntos a la nota2 y si la nota3 está entre 14 y 18 aumentar 1 punto sobre el promedio final. Imprimir promedio final.

4.18. Hallar el menor de 5 números.



4.19. Leer el año de nacimiento de una persona y determine si hasta este año esa

persona es o no “Mayor de edad”. 4.20. Un trabajador desea saber cuánto será su salario final, si es política de la

empresa dar una bonificación de 50 soles por cada hijo menor de edad, una bonificación de 100 si es casado y una bonificación de 80 soles si el trabajador está estudiando.




RREEPPEETTIITTIIVVAASS



- Pseudocódigo -

CCAAPPIITTUULLOO 55:: Estructuras Repetitivas

- Figura 5.1: Estructuras Repetitivas -

Las computadoras están especialmente diseñadas para todas aquellas aplicaciones en las cuales una operación o conjunto de ellas deben repetirse muchas veces. Las estructuras que repiten una secuencia de instrucciones un número determinado de veces se denominan bucles y se denomina iteración al hecho de repetir la ejecución de una secuencia de acciones.

5.1 ESTRUCTURA REPETITIVA mientras

La estructura repetitiva mientras es aquella en la que el cuerpo del bucle (Acción o Acciones) se ejecutan mientras se cumple una determinada condición. Generalmente se utiliza cuando no se sabe el número de veces que se ejecutaran determinadas acciones.

mientras condición hacer

Acción … fin_mientras

Acción

condición

V

F




- Sintaxis en C++ -

while(condición)

{

Acción;

…

}

La condición puede ser una variable, una expresión o el valor de una función; sin embargo el valor que representa sólo puede ser verdadero o falso. En C++ el valor 0 significa falso y un valor diferente de 0 significa verdadero. La acción, puede estar conformada por una o varias sentencias. Si estuviera conformada por dos o mas sentencias deben estar entre llaves. El programa se ejecuta siguiendo estos pasos: [1] Se evalúa la condición. [2] Si la condición es verdadera ejecuta la Acción o Acciones, sino el programa abandona la sentencia while [3] Tras ejecutar las Acciones, volvemos al paso 1. Ejm: i = 1; while(i<=5)

{

cout<<i<<endl;

i = i + 1;

}

La inicialización del contador es: i=1; La condición es: i <= 5 Las acciones son: cout<<i<<endl; i = i + 1; El incremento del contador es i = i + 1; La prueba de escritorio del programa:




Otra forma de representar esta estructura repetitiva es con el programa DFD como:

i Pantalla

1

2

3

4

5

6

1

2

3

4

5

Cuerpo del bucle

Inicialización del contador

Incremento del contador

Condición



El contador i va a recorrer de 2 a 100 aumentando de 2 en 2

2<=100

MIENTRAS ( while )

1. Imprimir la secuencia:

Pseudocodigo:

inicio

i 2

mientras i <= 100 hacer

escribir i

i i + 2

fin_mientras

fin

Diagrama de flujo: Programa:


void main()

{

int i;

i=2;

while(i<=100)

{

cout<<i<<endl;

i=i+2;

}

}

2

4

6

8

.

.

.

98

100



El contador i va a recorrer de 100 a 2 disminuyendo de 2 en 2

100 >= 2


Pseudocodigo:

inicio

i 100

mientras i >= 2 hacer

escribir i

i i - 2

fin_mientras

fin



void main()

{

int i;

i=100;

while(i>=2)

{

cout<<i<<endl;

i=i-2;

}

}

100

98

96

94

.

.

.

4

2



Trabajamos con s que es el acumulador y

guarda resultados de las sumas

3. Imprimir la secuencia y calcular la suma de sus elementos:


i 100

s 0


escribir i

s s + i

i i - 2

fin_mientras

escribir s

fin

El acumulador s se inicializa con 0, por ser acumulador de sumas.



void main()

{

int i;

long s;

i = 100;

s = 0;

while(i>=2)

{

cout<<i<<endl;

s = s + i;

i = i - 2;

}

cout<<"Suma: "<<s;

}

100

98

96

94

.

.

.

4

2



Programa:

4. Calcular K: K = 103 + 83 + 63 + 43 + 23

O.V.

Acumulador ( K ) Contador (i)

V.S.

Suma de la secuencia (K) (acumulador)

Pseudocodigo:

inicio

i 10

K 0


K K + i * i * i;

i i - 2

fin_mientras

escribir K

fin

DFD 1.0:


void main()

{

int i;

long K;

i = 10;

K = 0;

while(i>=2)

{

K = K + i * i * i;

i = i - 2;

}

cout<<"K = "<<K;

}



La fórmula del acumulador es:

s = s + num

5. Leer por teclado un número que represente una cantidad de números que a su vez se ingresaran también por teclado. Calcular la suma de todos esos números. Si la cantidad de números es 3, debemos ingresar tres números como por ejemplo: 10, 30 y 6, la suma de estos (10+30+6) es 46. Nuestro acumulador s debe inicializar con 0.

Si la cantidad de números es 5, debemos ingresar cinco números como por ejemplo: 7, 3, 2, 6 y 1; la suma de estos (7+3+2+6+1) es 19.

Pseudocodigo:

inicio

i 1

s 0

mientras i<=cn hacer

leer num

s s + num;

i i + 1

fin_mientras

escribir s

fin

i 1 2 3

num 10 30 6

s=0 s=s+10 s=10

s=s+30 s=40

s=s+6 s=46

i 1 2 3 4 5

num 7 3 2 6 1

s=0 s=s+7 s=7

s=s+3 s=10

s=s+2 s=12

s=s+6 s=18

s=s+1 s=19

E.V.

Cantidad de números (cn) Número (num)

O.V.

Contador (i)

V.S.

Suma ( s )



Programa:

6. Leer por teclado un número que represente una cantidad de números que a su vez se ingresaran también por teclado. Calcular el producto de esos números. Complete el siguiente Pseudocódigo.

El acumulador de productos debe inicializarse con 1 Pseudocódigo:

inicio

i 1

__ __

mientras i <= cn hacer

leer num

_ _____ num;

i i + 1

fin_mientras

escribir __

fin



Diagrama de Flujo:

7. Leer una lista de números desde el teclado y sumarlos; la

lista de números termina cuando se ingresa un número negativo.

Pseudocodigo:

inicio

s 0

leer num

mientras num > 0 hacer

s s + num;

leer num

fin_mientras

escribir s

fin

8. Realizar el programa del ejercicio anterior.

E.V.

Número (num)

V.S.

Suma ( s )



- Sintaxis en C++ -

- Pseudocódigo -

5.2 ESTRUCTURA REPETITIVA hacer - mientras

El bucle hacer-mientras es parecido al bucle mientras, la diferencia entre ambos es que, en la estructura repetitiva hacer-mientras el cuerpo del bucle se ejecuta al menos una vez antes de que se evalúe la condición. La elección entre un bucle mientras y un bucle hacer-mientras depende del problema a resolver.

hacer Acción …

fin_mientras condición

do{

Acción;

…

}

while(condición);

La condición puede ser una variable, una expresión o el valor de una función; sin embargo el valor que representa sólo puede ser verdadero o falso. En C++ el valor 0 significa falso y un valor diferente de 0 significa verdadero. Lo que va entre llaves es la Acción o Acciones a ejecutar repetitivamente mientras la condición sea verdad. Cuando la condición sea falsa termina el bucle o ciclo.

Acción

condición

F

V




Es decir los pasos son: [1] Ejecutar la Acción o Acciones [2] Evaluar la condición [3] Si la condición es verdadera volver al paso 1, sino continuar fuera del while

Ejm: i = 1; do{

cout<<i<<endl;

i = i + 1;

}

while(i<=5);

La inicialización del contador es: i=1; Las acciones son: cout<<i<<endl; i = i + 1; El incremento del contador es i = i + 1; La condición es: i <= 5 La prueba de escritorio del programa: Prueba de Escritorio:

La sentencia do-while, se utiliza también cuando no se sabe el número de veces que se ejecutaran determinadas acciones o sentencias.

i Pantalla

1

2

3

4

5

6

1

2

3

4

5



El contador i va a recorrer de 2 a 100 aumentando de 2 en 2

2<=100

HACER - MIENTRAS ( do – while )


Pseudocodigo:

inicio

i 2

hacer

escribir i

i i + 2

mientras i <= 100

fin

Turbo C++ 4.5:

2

4

6

8

.

.

.

98

100



El contador i va a recorrer de 50 a 0 disminuyendo de

10 en 10


Pseudocodigo:

inicio

i 50

hacer

escribir i

i i - 10

mientras i >= 0

fin

Turbo C++ 4.5:

50 40 30 20 10 0



11. Imprimir la suma de los números:

O.V.

Acumulador (s) Contador (i)

V.S.

Suma de los elementos ( s ) [Acumulador]

Pseudocodigo:

inicio

i 50

s 0

hacer

s s + i

i i - 10

mientras i >= 0

escribir s

fin

Turbo C++ 4.5:

50 40 30 20 10 0



- Pseudocódigo -

5.3 ESTRUCTURA REPETITIVA para o desde

Esta estructura repetitiva se utiliza generalmente cuando se sabe el número de veces que se repetirá una acción o conjunto de acciones. La estructura para o desde ejecuta las acciones del cuerpo del bucle un número especificado de veces y de modo automático controla el número de iteraciones o pasos a través del cuerpo del bucle.

desde con vini hasta vfin [inc|dec] hacer

Acciones …

fin_desde

para con vini hasta vfin [inc|dec] hacer

Acciones …

fin_para

vini es el valor inicial para el contador (con) vfin es el valor final del contador. (condición) inc|dec puede ser el incremento o decremento.

Para con vini,vfin,inc|dec

Acción

cierre



- Sintáxis en C++ -

for(inicialización; condición; incremento/decremento)

{

Acción;

…

}

En la parte de inicialización se debe dar un valor inicial a la variable que va a controlar el proceso repetitivo (contador). La condición establece la continuidad o el término del proceso repetitivo. Mientras la condición sea verdad el proceso continúa. Cuando la condición sea falsa el proceso termina. Normalmente en esta condición interviene la variable inicializada (el contador). El incremento o decremento se realiza a la variable inicializada (contador). La Acción, puede estar conformada por una o varias acciones. Si estuviera conformada por una acción no necesita llaves. El funcionamiento es: [1] Se ejecuta la instrucción de inicialización [2] Se evalúa la condición [3] Si la condición es cierta, entonces se ejecuta la Acción o Acciones. Si la condición es falsa, abandonamos el bloque for [4] Tras ejecutar la Acción o Acciones, se ejecuta la instrucción de incremento o decremento y se vuelve al paso 2. Ejm: Para imprimir la secuencia: for(i=50; i>=0; i=i-10)

{

cout<<i<<”\t”;

}

La inicialización del contador i es 50, la condición es que i>=0 y el decremento es de 10 en 10.

50 40 30 20 10 0



PARA O DESDE ( for )


Pseudocodigo:

inicio

desde i2 hasta 100 incremento 2 hacer

escribir i

fin_desde

fin



void main()

{

int i;

for(i=2;i<=100;i=i+2)

{

cout<<i<<endl;

}

}

2

4

6

8

.

.

.

98

100




Pseudocodigo:

inicio

desde i100 hasta 2 decremento 2 hacer

escribir i

fin_desde

fin



void main()

{

int i;

for(i=100;i>=2;i=i-2)

{

cout<<i<<endl;

}

}

100

98

96

94

.

.

.

4

2




Pseudocodigo:

inicio


escribir i

fin_desde

fin



void main()

{

int i;

for(i=5;i<=100;i=i+5)

{

cout<<i<<endl;

}

}

5

10

15

20

.

.

.

95

100




Pseudocodigo:

inicio


escribir i

fin_desde

fin



void main()

{

int i;

for(i=100;i>=10;i=i-5)

{

cout<<i<<endl;

}

}

100

95

90

85

.

.

.

10



Programa:

16. Mostrar en pantalla la tabla de multiplicar del 1 al 18 para cualquier número, de la siguiente manera:

Ejemplo: Ingrese un número: 7

V.E.

Número (n)

SALIDA

Tabla de multiplicar

Turbo C++ 4.5:

7 x 1 = 7 7 x 2 = 14 7 x 3 = 21 . . . 7 x 18 = 126


void main()

{

int i,n;

cout<<"Ingrese n: ";cin>>n;

for(i=1;i<=18;i=i+1)

{

cout<<n<<" x "<<i<<" = "<<n*i<<endl;

}

}



Programa:

17. Calcular la suma de la secuencia: 100,95,90,85,...,10

El acumulador de sumas se inicializa con 0.

O.V.

Acumulador de sumas (suma) Contador (i)

V.S.

Suma de la secuencia (suma)

Pseudocódigo:

inicio

suma 0


suma suma + i

fin_desde

escribir suma

fin

DFD 1.0:


void main()

{

int i,suma;

suma = 0;

for(i=100;i>=10;i=i-5)

{

suma = suma + i;

}

cout<<"suma: "<<suma;

}



Programa:

18. Calcular el producto de la secuencia: 1,2,3, ...,10

El acumulador de productos se inicializa con 1.

O.V.

Acumulador de productos (p) Contador (i)

V.S.

Producto de la secuencia (p)

Pseudocodigo:

inicio

p 1


p p * i

fin_desde

escribir p

fin

DFD 1.0:


void main()

{

int i;

long p;

p = 1;

for(i=1;i<=10;i=i+1)

{

p = p * i;

}

cout<<"Producto: "<<p;

}



Programa:

19. Calcular J: J = 12 + 22 + 32 + 42 + … + 102

O.V.

Acumulador ( J ) Contador (i)

V.S.

Suma de la secuencia ( J )

Pseudocodigo:

inicio

J 0


J J + i * i

fin_desde

escribir J

fin

DFD 1.0:


void main()

{

int i;

long J;

J = 0;

for(i=1;i<=10;i=i+1)

{

J = J + i * i;

}

cout<<"J = "<<J;

}



Ejercicios

Realizar el análisis, diseño (pseudocódigo, diagrama de flujo) y programa de los siguientes:

5.1. Determinar simultáneamente los valores máximo y mínimo de una lista de 100 números ingresados por teclado.

5.2. Imprimir la suma de los números impares menores o iguales que n. 5.3. Imprimir la suma de los números pares de los números que van del 1 al

200. 5.4. Calcular la suma de los n primeros números enteros utilizando la

estructura desde. 5.5. Imprimir las treinta primeras potencias de 3, es decir, 3 elevado a 1, 3

elevado a 2, etc. 5.6. Obtener la suma de los números pares hasta 1000 inclusive. 5.7. Dados dos números enteros, realizar el algoritmo que calcule su cociente y

su resto. 5.8. De una lista de 20 números ingresados por teclado. Se desea calcular el

valor del número mayor. 5.9. Leer 10 números. Determinar la media de los números positivos y la

media de los números negativos.

5.10. Dado un entero positivo n ( >1 ), comprobar si es primo o compuesto. 5.11. Utilizando las estructuras repetitivas mientras, hacer_mientras y para o

desde, imprimir la secuencia 2, 4, 6, 8, …, 100 en forma vertical. 5.12. Utilizando las estructuras repetitivas mientras, hacer_mientras y para o

desde, imprimir la secuencia 1000, 900, 800, …, 0 en forma horizontal. 5.13. De un salón de 30 estudiantes calcular el promedio de las edades. 5.14. De un salón de 25 estudiantes calcular el promedio de notas del curso de

programación.



AARRRRAAYYSS



CCAAPPIITTUULLOO 66:: Arrays

- Figura 6.1: Arrays (Arreglos) -

Los arrays (arreglos) pueden ser unidimensionales, bidimensionales y multidimensionales.

6.1 ARREGLOS UNIDIMENSIONALES: Los Vectores

Es un arreglo de “n” elementos organizados en una dimensión donde “n” recibe el nombre de longitud o tamaño del vector.

Un vector NOTAS que consta de 10 elementos se puede representar por la siguiente figura:

- Figura 6.2: Vectores -

12.5 16 20 14 … 14.5

0 1 2 3 … 9

NOTAS:

Índices

Nombre del vector Elementos



El primer índice (posición) de un vector es 0.

Los vectores se almacenan en memoria central de la computadora en orden adyacente.

- Figura 6.3: Almacenamiento del vector NOTAS en memoria -

Cada elemento del vector NOTAS puede ser referenciado dándole el nombre del arreglo, seguido por el número de posición (índice) de dicho elemento encerrados por corchetes ([ ]). NOTAS[0] = 12.5 NOTAS[1] = 16 NOTAS[2] = 20

6.1.1 Declaración de Vectores Para declarar un vector se utiliza la siguiente sintaxis:

Ejemplo: float NOTAS[10]; // vector de 10 números decimales int edad[50]; //vector de 50 números enteros char nombre[20]; // vector de 20 caracteres

12.5

16

20

14

…

14.5

Dirección X

Dirección X+1

Dirección X+2

Dirección X+3

…

Dirección X+9

NOTAS[0]

NOTAS[1]

NOTAS[2]

NOTAS[3]

…

NOTAS[9]

Memoria

nombreTipo nombreVariable[Tamaño];



6.1.2 Operaciones con Vectores

Recorrido o Acceso Secuencial al Vector

A la operación de efectuar una acción general sobre todos los elementos de un vector se denomina recorrido del vector. Estas operaciones se realizan utilizando estructuras repetitivas. Ejemplo: Para recorrer un vector de 10 elementos for(i=0;i<10;i++)

{

//acciones

}

Ejemplo: Para recorrer un vector de n elementos for(i=0;i<n;i++)

{

//acciones

}

Asignación o Inicialización de un Vector

Si desea asignar valores a todos los elementos de un vector, se debe recurrir a las estructuras repetitivas. Ejemplo: Inicializar el vector A Podemos inicializar el vector A haciendo uso de estructuras secuenciales como:

A[0]=1 A[1]=1 A[2]=1 A[3]=1 A[4]=1 A[5]=1 A[6]=1 A[7]=1

1 1 1 1 1 1 1 1

0 1 2 3 4 5 6 7

A:

La sentencia que

resume todas estas

sería:

A[ i ]=1

La variable i recorre de 0 a 7.



for(i=0;i<8;i++)

{

A[i]=1;

}

Lectura/Escritura de datos en un Vector

Las operaciones de Entrada/Salida normalmente se realizan con las estructuras repetitivas (generalmente con for). Ejemplo: Leer 15 números y almacenarlos en el vector Z for(i=0;i<15;i++)

{

cout<<”Ingrese número: ”;

cin>>Z[i];

}

Otra forma de solicitar los 15 números es: for(i=0;i<15;i++)

{

cout<<”Z[“<<i<<”]: ”;

cin>>Z[i];

}

Ejemplo: Imprimir el vector Z en forma horizontal for(i=0;i<15;i++)

{

cout<<Z[i]<<”\t”;

}

Ejemplo: Imprimir el vector Z en forma vertical for(i=0;i<15;i++)

{

cout<<Z[i]<<”\n”;

}



VECTORES

1. Inicializar el vector A e imprimir sus elementos en forma horizontal.

Diagrama de flujo:

1 1 1 1 1 1 1

0 1 2 3 4 5 6

A:

Fin

i 0

inicio

Si

No i < 7

A[i] 1

i i + 1

i < 7

A[i]

i i + 1

i 0

Si

No



Primero debemos declarar el vector A para almacenar siete elementos de tipo entero. int A[7];

Para la inicialización del vector A, utilizamos la estructura repetitiva for, dentro del bucle for colocamos A[i] = 1. El índice i recorrerá desde la posición 0 hasta la 6. for(i=0;i<7;i++)

{

A[i] = 1;

}

Para imprimir el vector también utilizamos la estructura repetitiva for.

for(i=0;i<7;i++)

{

cout<<A[i]<<"\t";

}

Para imprimir una tabulación entre los elementos del vector A.

cout<<“\t”;

Para imprimir un salto de línea.

cout<<endl;

Programa:


void main( )

{

int A[7],i;

for(i=0;i<7;i++)

{

A[i] = 1;

}

for(i=0;i<7;i++)

{

cout<<A[i]<<"\t";

}

cout<<endl;

}



2. Inicializar el vector M e imprimir sus elementos en forma horizontal.

Diagrama de flujo:

1 0 1 0 1 0 1 0

0 1 2 3 4 5 6 7

M: 1

8

Fin

i 0

inicio

Si

No i < 9

M[i] 0

i%2== 1

M[i] 1

i i + 1

Si No

i < 9

M[i]

i i + 1

i 0

Si

No



Primero debemos declarar el vector M para almacenar nueve elementos. int M[9];

Para la inicialización del vector M, utilizamos la estructura repetitiva for. for(i=0;i<9;i++)

{

//…

}

Dentro del bucle for, debemos colocar el código necesario para colocar en las posiciones impares 0 y en los demás 1 Pares Impares

M[0]=1 M[1]=0 M[2]=1 M[3]=0 M[4]=1 M[5]=0 M[6]=1 M[7]=0 M[8]=1

Utilizamos la estructura selectiva doble, para separar las posiciones pares de impares. if(i%2==1)

{

M[i] = 0;

}

else

{

M[i] = 1;

}

Para imprimir el vector también utilizamos la estructura repetitiva for. for(i=0;i<9;i++)

{

cout<<M[i]<<"\t";

}



Imprime una tabulación entre los elementos del vector M.

cout<<“\t”;

Imprime un salto de línea.

cout<<endl;

Programa:


void main( )

{

int M[9],i;

for(i=0;i<9;i++)

{

if(i%2==1)

{

M[i] = 0;

}

else

{

M[i] = 1;

}

}

for(i=0;i<9;i++)

{

cout<<M[i]<<"\t";

}

cout<<endl;

}



3. Inicializar el vector L e imprimir sus elementos en forma vertical.

Diagrama de flujo:

L: 2 2 2 2 5 5 5 5

0 1 2 3 4 5 6 7

5

8

Fin

i 0

inicio

Si

No i < 9

L[i] 2

i < 4

L[i] 5

i i + 1

Si No

i < 9

L[i]

i i + 1

i 0

Si

No



Utilizamos la estructura selectiva doble, para separar las posiciones menores de 4 de las demás. if(i < 4)

{

L[i] = 2;

}

else

{

L[i] = 5;

}

Programa:


void main( )

{

int L[9],i;

for(i=0;i<9;i++)

{

if(i<4)

{

L[i] = 2;

}

else

{

L[i] = 5;

}

}

for(i=0;i<9;i++)

{

cout<<L[i]<<"\t";

}

cout<<endl;

}



4. Leer 10 números enteros, almacenarlos en un vector V e imprimirlos en forma vertical.

Programa:

5. Leer n números


void main()

{

//Declaramos el vector V de 10 elementos

int V[10], i;

// Leer vector V de 10 elementos

for(i=0;i<10;i++)

{

cout<<"V["<<i<<"]= ";cin>>V[i];

}

// Imprimir vector V

for(i=0;i<10;i++)

{

cout<<V[i]<<endl;

}

}



enteros, almacenarlos en un vector A e imprimirlos en forma horizontal.

Programa:


void main()

{

//Declaramos el vector A de 100 elementos máximo

int A[100];

int i,n;

cout<<"Ingrese longitud del vector: ";cin>>n;

// Leer vector A de n elementos

for(i=0;i<n;i++)

{

cout<<"A["<<i<<"]= ";cin>>A[i];

}

// Imprimir vector A

for(i=0;i<n;i++)

{

cout<<A[i]<<"\t";

}

cout<<endl;

}



6. Leer e imprimir los elementos de un vector A de n elementos y calcular la suma de los mismos.

Programa:


void main()

{

int A[100];

int i,n,suma;

//El acumulador suma inicializamos con 0

suma = 0;


// Leer vector A de n elementos e ir sumando

for(i=0;i<n;i++)

{

cout<<"A["<<i<<"]=";cin>>A[i];

suma = suma + A[i];

}


for(i=0;i<n;i++)

{

cout<<A[i]<<"\t";

}

cout<<endl;

cout<<"La suma es: "<<suma<<endl;

}



7. Leer un vector A de n elementos, calcule e imprima la suma y el promedio de sus elementos.

Programa:


void main()

{

int A[100],i,n;

float suma,promedio;

suma = 0;



for(i=0;i<n;i++)

{

cout<<"A["<<i<<"]=";cin>>A[i];

suma = suma + A[i];

}


for(i=0;i<n;i++)

{

cout<<A[i]<<"\t";

}

cout<<endl;

cout<<"La suma es: "<<suma<<endl;

promedio = suma/n;

cout<<"El promedio es: "<<promedio<<endl;

}



8. Leer 2 vectores A y B de 5 elementos, calcule e imprima el vector suma S.

Programa:


void main()

{

int A[5],B[5],S[5],i;

cout<<"Ingrese elementos del vector A"<<endl;

for(i=0;i<5;i++)

{

cout<<"A["<<i<<"]=";cin>>A[i];

}

cout<<"Ingrese elementos del vector B"<<endl;

for(i=0;i<5;i++)

{

cout<<"B["<<i<<"]=";cin>>B[i];

}

// Sumar vector A y B

for(i=0;i<5;i++)

{

S[i] = A[i] + B[i];

}

// Imprimir vector S

cout<<"Elementos del vector S"<<endl;

for(i=0;i<5;i++)

{

cout<<S[i]<<"\t";

}

cout<<endl;

}



9. Lea un vector Z de 10 elementos e imprima el mayor elemento.

Programa:


void main()

{

int Z[10],i,mayor;

cout<<"Ingrese elementos del vector Z"<<endl;

for(i=0;i<10;i++)

{

cout<<"Z["<<i<<"]=";cin>>Z[i];

}

// Buscar el mayor

mayor = Z[0];

for(i=1;i<10;i++)

{

if(mayor < Z[i])

{

mayor = Z[i];

}

}

cout<<"El mayor elemento es: "<<mayor<<endl;

}



10. Lea un vector U de 12 elementos e imprima el menor elemento.

Programa:


void main()

{

int U[12],i,menor;

cout<<"Ingrese elementos del vector U"<<endl;

for(i=0;i<12;i++)

{

cout<<"U["<<i<<"]=";cin>>U[i];

}

// Buscar el mayor

menor = U[0];

for(i=1;i<12;i++)

{

if(menor > U[i])

{

menor = U[i];

}

}

cout<<"El menor elemento es: "<<menor<<endl;

}



6.2 ARREGLOS BIDIMENSIONALES: Las Matrices

Una matriz CURSOS que consta de 5 filas y 4 columnas se representa por la siguiente figura:

La matriz CURSOS es de orden 5x4. Cada elemento de la matriz CURSOS puede ser referenciado al igual que los vectores, solo que en el caso de las matrices utilizamos dos índices uno para filas y el otro para las columnas. CURSOS[0][2] = 14 //se encuentra en la fila 0 columna 2 CURSOS[3][0] = 17 //se encuentra en la fila 3 columna 0 CURSOS[4][3] = 10 //se encuentra en la fila 4 columna 3 CURSOS[0][0] = 12 //se encuentra en la fila 0 columna 0

6.2.1 Declaración de Matrices

Para declarar una matriz se utiliza la siguiente sintaxis:

Ejemplo: int CURSOS[5][4]; //almacena 20 enteros en 5 filas y 4 columnas int Lista[3][5]; // almacena 15 enteros en 3 filas y 5 columnas

12

20

15

12

14 8

13 19

7

17

11

6

9 16

12 18

18 8 5 10

Fila 0--->

Fila 1--->

Fila 2--->

Fila 3--->

Fila 4--->

Colu

mna 0--

->

Colu

mna 1--

->

Colu

mna 2--

->

Colu

mna 3--

->

5x4

nombreTipo nombreVariable[TamF][TamC];



6.2.2 Operaciones con Matrices

Recorrido o Acceso Secuencial a la Matriz

A diferencia de los vectores, para el recorrido de una matriz utilizamos dos estructuras repetitivas (for). Ejemplo: Para recorrer la matriz CURSOS de 5 filas y 4 columnas for(i=0;i<5;i++)

{

for(j=0;j<4;j++)

{

//acciones

}

}

Ejemplo: Para recorrer una matriz de n filas y m columnas for(f=0;f<n;f++)

{

for(c=0;c<m;c++)

{

//acciones

}

}

Asignación o Inicialización de una Matriz

Si se desea asignar valores a todos los elementos de una matriz, se utiliza también las estructuras repetitivas. Ejemplo: Inicializar la matriz Q.

1

1

1

1

1 1

1 1

1

1

1

1

1 1

1 1

1 1 1 1

Q:

5x4



for(f=0;f<5;f++)

{

for(c=0;c<4;c++)

{

Q[f][c]=1;

}

}

Lectura/Escritura de datos en una Matriz

Las operaciones de Entrada/Salida de una matriz también se realizan con estructuras repetitivas. Ejemplo: Leer 15 números y almacenarlos en una matriz Z de 3 filas y 5 columnas. for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

cin>>Z[f][c];

}

}

Ejemplo: Imprimir la matriz Z for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

cout<<Z[f][c]<<”\t”;

}

cout<<endl;

}



MATRICES

11. Inicializar e imprimir la matriz P.

Programa:

1

1

1

1

1

1

1

1

1

1

1

1

P:

4x3 #include<iostream.h>

void main()

{

int P[4][3],f,c;

//Inicializar la matriz P

for(f=0;f<4;f++)

{

for(c=0;c<3;c++)

{

P[f][c] = 1;

}

}

//Imprimir matriz P

for(f=0;f<4;f++)

{

for(c=0;c<3;c++)

{

cout<<P[f][c]<<"\t";

}

cout<<endl;

}

}



12. Inicializar e imprimir la matriz S.

Programa:

S:

3x6

1

2

1

2

1

2

3 3 3

1

2

1

2

1

2

3 3 3


void main()

{

int S[3][6],f,c;

//Inicializar la matriz S

for(f=0;f<3;f++)

{

for(c=0;c<6;c++)

{

S[f][c] = f+1;

}

}

//Imprimir matriz S

for(f=0;f<3;f++)

{

for(c=0;c<6;c++)

{

cout<<S[f][c]<<"\t";

}

cout<<endl;

}

}



13. Inicializar e imprimir la matriz T.

Programa:

1

0

0

1

0

0

0 0 1 3x3

T:


void main()

{

int T[3][3],f,c;

//Inicializar la matriz T

for(f=0;f<3;f++)

{

for(c=0;c<3;c++)

{

if(f==c)

{

T[f][c] = 1;

}

else

{

T[f][c] = 0;

}

}

}

//Imprimir matriz T

for(f=0;f<3;f++)

{

for(c=0;c<3;c++)

{

cout<<T[f][c]<<"\t";

}

cout<<endl;

}

}



14. Leer la matriz A de 3 filas y 5 columnas, calcular e imprimir la suma de sus elementos.

Programa:


void main()

{

int A[3][5],f,c,suma = 0;

//Leer matriz A

for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

cout<<"A["<<f<<"]["<<c<<"]= ";cin>>A[f][c];

}

}

//Sumar los elementos de matriz A

for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

suma = suma + A[f][c];

}

}

cout<<"La suma de los elementos es: "<<suma<<endl;

}



15. Leer la matriz B de 2 filas y 6 columnas, calcular e imprimir la suma y el promedio de sus elementos.

Programa:


void main()

{

int B[2][6],f,c;

float promedio, suma = 0;

//Leer matriz B

for(f=0;f<2;f++)

{

for(c=0;c<6;c++)

{

cout<<"B["<<f<<"]["<<c<<"]= ";cin>>B[f][c];

}

}

//Sumar los elementos de matriz B

for(f=0;f<2;f++)

{

for(c=0;c<6;c++)

{

suma = suma + B[f][c];

}

}

cout<<"La suma de los elementos es: "<<suma<<endl;

promedio = suma/12;

cout<<"El promedio es: "<<promedio<<endl;

}



16. Hallar el mayor elemento de una matriz C de n filas y m columnas.

Programa:


void main()

{

int C[100][100],f,c,mayor,nf,nc;

cout<<"Ingrese numero de filas: ";cin>>nf;

cout<<"Ingrese numero de columnas: ";cin>>nc;

for(f=0;f<nf;f++)

{

for(c=0;c<nc;c++)

{

cout<<"C["<<f<<"]["<<c<<"]= ";cin>>C[f][c];

}

}

mayor = C[0][0];

for(f=0;f<nf;f++)

{

for(c=0;c<nc;c++)

{

if(mayor < C[f][c])

{

mayor = C[f][c];

}

}

}

cout<<"El mayor elemento es: "<<mayor<<endl;

}



17. Hallar el menor elemento de una matriz D de 6 filas y 4 columnas.

Programa:


void main()

{

int D[6][4],f,c,menor,nf,nc;

for(f=0;f<6;f++)

{

for(c=0;c<4;c++)

{

cout<<"D["<<f<<"]["<<c<<"]= ";cin>>D[f][c];

}

}

menor = D[0][0];

for(f=0;f<6;f++)

{

for(c=0;c<4;c++)

{

if(menor > D[f][c])

{

menor = D[f][c];

}

}

}

cout<<"El menor elemento es: "<<menor<<endl;

}



18. Leer dos matrices A y B de 3 filas y 5 columnas, calcule e imprima la matriz suma S.

Programa:


void main()

{

int A[3][5],B[3][5],S[3][5],f,c;

cout<<"Ingrese elementos de matriz A"<<endl;

for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

cout<<"A["<<f<<"]["<<c<<"]= ";cin>>A[f][c];

}

}

cout<<"Ingrese elementos de matriz B"<<endl;

for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

cout<<"B["<<f<<"]["<<c<<"]= ";cin>>B[f][c];

}

}

//Suma de matrices A y B

for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

S[f][c]=A[f][c]+B[f][c];

}

}

//Imprimir matriz S

for(f=0;f<3;f++)

{

for(c=0;c<5;c++)

{

cout<<S[f][c]<<"\t";

}

cout<<endl;

}

}



Ejercicios

Resolver los siguientes:

6.1. Calcular el número de elementos positivos de un vector de n elementos. 6.2. Almacenar las edades de un salón de 25 estudiantes, calcular el promedio

de sus edades.

6.3. Imprimir una matriz identidad de 6 x 6.

6.4. Se dispone de un vector V de 50 números reales distintos de cero. Crear un nuevo vector en la que sus elementos resulten de dividir los elementos del vector V por el elemento V[k], siendo k un valor dado.

6.5. Leer una matriz de 3 x 3, calcular la suma de cada una de sus filas y

columnas, dejando dichos resultados en 2 vectores, uno de la suma de filas y otro de las columnas.

6.6. Se dispone de N temperaturas almacenadas en un vector, calcular la media

y obtener el número de temperaturas mayores o iguales a la media.

6.7. De un vector de N elementos, determinar el mayor elemento.

6.8. De una matriz Z de n filas y m columnas, determine el menor elemento.

6.9. Se dispone de las notas de cuarenta alumnos. Cada uno de ellos puede tener una o varias notas. Escribir un programa que permita obtener la media de cada alumno y la media de la clase.

6.10. Se introducen una serie de valores numéricos desde teclado, siendo el

valor final de entrada de datos o centinela -100. Imprimir los valores leídos, la suma y el promedio de dichos números.



OORRDDEENNAACCIIÓÓNN



CCAAPPIITTUULLOO 77:: Ordenación

Ordenación es la operación de organizar un conjunto de datos en algún orden dado, puede ser en forma ascendente o descendente en datos numéricos, o bien en orden alfabético directo o inverso. Se trata de una de las operaciones más típicas de la programación. Existen varios métodos de Ordenación.

7.1 MÉTODO DE ORDENACIÓN BURBUJA


void main()

{

int A[100],i,j,n,AUX;



for(i=1;i<=n;i++)

{

cout<<"A["<<i<<"]=";cin>>A[i];

}

//Ordenar el vector

for(i=1;i<=n-1;i++)

{

for(j=1;j<=n-i;j++)

{

if(A[j]>A[j+1])

{

AUX = A[j];

A[j] = A[j+1];

A[j+1]= AUX;

}

}

}

// Imprimir vector A ordenado

for(i=1;i<=n;i++)

{

cout<<A[i]<<"\t";

}

cout<<endl;

}



BBÚÚSSQQUUEEDDAA



CCAAPPIITTUULLOO 88:: Búsqueda

Búsqueda es la operación de ubicar un dato dentro de un conjunto de datos, podemos determinar si se encuentra o no, podemos contar el número de veces que se repite un dato.

8.1 MÉTODO DE BÚSQUEDA LINEAL O SECUENCIAL

El programa siguiente busca un dato en un vector de n elementos y muestra la posición en la que se encuentra.


void main()

{

int A[100],i,n,dato,pos = -1;



for(i=1;i<=n;i++)

{

cout<<"A["<<i<<"]=";cin>>A[i];

}

cout<<"Ingrese elemento a buscar ...";cin>>dato;

//Buscar el dato

for(i=1;i<=n-1;i++)

{

if(dato == A[i])

{

pos = i;

break;

}

}

if(pos != -1)

{

cout<<"El "<<dato<<" esta en la posicion "<<pos<<endl;

}

else

{

cout<<"El "<<dato<<" no se encuentra."<<endl;

}

}



FFUUNNCCIIOONNEESS



CCAAPPIITTUULLOO 99:: Funciones

Una función es un conjunto de instrucciones con un nombre determinado y que realizan una tarea específica dentro de un programa.

Además de la función main, podemos crear nuestras propias funciones dentro de un programa. La forma de implementar una función es:

-

tipo: Sirve para elegir el tipo de datos que devuelve la función. Toda función puede obtener un resultado. Eso se realiza mediante la instrucción return. El tipo puede ser: int, char, long, float, double,.... y también void. Éste último se utiliza si la función no devuelve ningún valor (y suelen llamarse procedimientos). NombreFunción: El identificador de la función debe cumplir reglas correspondientes al nombre de los identificadores. Lista de argumentos: Llamados también parámetros, su uso es opcional, hay funciones sin parámetros. Los parámetros son una serie de valores que la función puede requerir para poder ejecutar su trabajo. En realidad es una lista de variables y los tipos de las mismas.

tipo NombreFunción(Lista de argumentos) {

acciones;

return(variable); }

Debe comenzar por una letra

Sólo puede contener letras, números y el carácter _

No puede estar repetido en el mismo algoritmo o

programa.

Que sea aclarativo, es decir, que represente lo que

realmente hace.



En la estructura general de un programa con funciones, tenemos 3 puntos importantes:

La sentencia return se puede utilizar para devolver un valor.

8.2 RECURSIVIDAD

La recursividad es una técnica de creación de funciones en la que una función se llama a sí misma. Ciertos problemas como el de las torres de Hanoi, por ejemplo, serían casi imposibles de resolver sin esta técnica. La idea es que la función resuelva parte del problema y se llame a sí misma para resolver la parte que queda, y así sucesivamente. En cada llamada el problema debe ser cada vez más sencillo hasta llegar a una llamada en la que la función devuelve un único valor. Ejm: La función factorial con recursividad

Inclusión de librerías

Declaración de prototipos o funciones propias Declaración de variables globales Función principal void main( ) { …

Llamar a la función propia … }

Implementación de funciones propias f1( … ) { … }

1

2

3

int factorial(int n)

{

if (n ==0)

return 1;

else

return (n * factorial(n-1));

}



FUNCIONES

1. Función para sumar dos números enteros

2. Suma de dos números n1 y n2 con funciones


//declaración del prototipo

int suma(int,int);

void main()

{

//llamar a la función suma

cout<<suma(3,4)<<endl;

}

//Implementación de la función

int suma(int a,int b)

{

return a+b;

}


//declaración del prototipo

int suma(int,int);

void main()

{

int n1,n2;

cout<<"Ingrese n1: ";cin>>n1;


//llamar a la función suma

cout<<suma(n1,n2)<<endl;

}

//Implementación de la función

int suma(int a,int b)

{

return a+b;

}



3. Operaciones básicas de dos números con funciones


//declaración de prototipos

float suma(float,float);

float resta(float,float);

float multiplica(float,float);

float division(float,float);

void main()

{

float n1,n2;



//Llamada a las funciones

cout<<"Suma= "<<suma(n1,n2)<<endl;

cout<<"Resta= "<<resta(n1,n2)<<endl;

cout<<"Producto= "<<multiplica(n1,n2)<<endl;

cout<<"Division= "<<division(n1,n2)<<endl;

}

//Implementación de funciones

float suma(float a,float b)

{

return a+b;

}

float resta(float a, float b)

{

return a-b;

}

float multiplica(float a, float b)

{

return a*b;

}

float division(float m, float n)

{

return m/n;

}



4. Operaciones básicas de dos números con menú y funciones


//declaración de prototipos

float suma(float,float);

float resta(float,float);

float multiplica(float,float);

float division(float,float);

void imprimemenu();

void calcula();

void main()

{

imprimemenu();

calcula();

}

//Implementación de funciones

float suma(float a,float b)

{

return a+b;

}

float resta(float a, float b)

{

return a-b;

}

float multiplica(float a, float b)

{

return a*b;

}

float division(float m, float n)

{

return m/n;

}

void imprimemenu()

{

cout<<"********************"<<endl;

cout<<"[S] Suma "<<endl;

cout<<"[R] Resta "<<endl;

cout<<"[M] Multiplicacion "<<endl;

cout<<"[D] Division "<<endl;

cout<<"[X] Salir "<<endl;

cout<<"********************"<<endl;

}



void calcula()

{

float n1,n2;

char opc;

do{

cout<<"Ingrese opcion: ";cin>>opc;

if(opc == 'X')

{

break;

}

else

{



switch(opc)

{

case 'S':cout<<suma(n1,n2)<<endl;break;

case 'R':cout<<resta(n1,n2)<<endl;break;

case 'M':cout<<multiplica(n1,n2)<<endl;break;

case 'D':cout<<division(n1,n2)<<endl;break;

case 'X':break;

}

}

imprimemenu();

}while(opc!='X');

}

algoritmos y programaciÓn estructurada en c++

Documents